// Copyright 2020 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_EXECUTION_LOCAL_ISOLATE_WRAPPER_INL_H_
#define V8_EXECUTION_LOCAL_ISOLATE_WRAPPER_INL_H_

#include "src/execution/isolate.h"
#include "src/execution/local-isolate-wrapper.h"
#include "src/execution/off-thread-isolate.h"
#include "src/heap/heap-inl.h"
#include "src/heap/off-thread-heap.h"
#include "src/logging/log.h"
#include "src/logging/off-thread-logger.h"

namespace v8 {
namespace internal {

class HeapMethodCaller {
 public:
  explicit HeapMethodCaller(LocalHeapWrapper* heap) : heap_(heap) {}

  ReadOnlySpace* read_only_space() {
    return heap_->is_off_thread() ? heap_->off_thread()->read_only_space()
                                  : heap_->main_thread()->read_only_space();
  }

  void OnAllocationEvent(HeapObject obj, int size) {
    return heap_->is_off_thread()
               ? heap_->off_thread()->OnAllocationEvent(obj, size)
               : heap_->main_thread()->OnAllocationEvent(obj, size);
  }

  bool Contains(HeapObject obj) {
    return heap_->is_off_thread() ? heap_->off_thread()->Contains(obj)
                                  : heap_->main_thread()->Contains(obj);
  }

 private:
  LocalHeapWrapper* heap_;
};

class LoggerMethodCaller {
 public:
  explicit LoggerMethodCaller(LocalLoggerWrapper* logger) : logger_(logger) {}

  bool is_logging() const {
    return logger_->is_off_thread() ? logger_->off_thread()->is_logging()
                                    : logger_->main_thread()->is_logging();
  }

  void ScriptEvent(Logger::ScriptEventType type, int script_id) {
    return logger_->is_off_thread()
               ? logger_->off_thread()->ScriptEvent(type, script_id)
               : logger_->main_thread()->ScriptEvent(type, script_id);
  }
  void ScriptDetails(Script script) {
    return logger_->is_off_thread()
               ? logger_->off_thread()->ScriptDetails(script)
               : logger_->main_thread()->ScriptDetails(script);
  }

 private:
  LocalLoggerWrapper* logger_;
};

class IsolateMethodCaller {
 public:
  explicit IsolateMethodCaller(LocalIsolateWrapper* isolate)
      : isolate_(isolate) {}

  LocalLoggerWrapper logger() {
    return isolate_->is_off_thread()
               ? LocalLoggerWrapper(isolate_->off_thread()->logger())
               : LocalLoggerWrapper(isolate_->main_thread()->logger());
  }

  LocalHeapWrapper heap() {
    return isolate_->is_off_thread()
               ? LocalHeapWrapper(isolate_->off_thread()->heap())
               : LocalHeapWrapper(isolate_->main_thread()->heap());
  }

  ReadOnlyHeap* read_only_heap() {
    return isolate_->is_off_thread()
               ? isolate_->off_thread()->read_only_heap()
               : isolate_->main_thread()->read_only_heap();
  }

  Object root(RootIndex index) {
    return isolate_->is_off_thread() ? isolate_->off_thread()->root(index)
                                     : isolate_->main_thread()->root(index);
  }

  int GetNextScriptId() {
    return isolate_->is_off_thread()
               ? isolate_->off_thread()->GetNextScriptId()
               : isolate_->main_thread()->GetNextScriptId();
  }

 private:
  LocalIsolateWrapper* isolate_;
};

// Helper wrapper for HandleScope behaviour with a LocalIsolateWrapper.
class LocalHandleScopeWrapper {
 public:
  explicit LocalHandleScopeWrapper(LocalIsolateWrapper local_isolate)
      : is_off_thread_(local_isolate.is_off_thread()) {
    if (is_off_thread_) {
      new (off_thread()) OffThreadHandleScope(local_isolate.off_thread());
    } else {
      new (main_thread()) HandleScope(local_isolate.main_thread());
    }
  }
  ~LocalHandleScopeWrapper() {
    if (is_off_thread_) {
      off_thread()->~OffThreadHandleScope();
    } else {
      main_thread()->~HandleScope();
    }
  }

  template <typename T>
  Handle<T> CloseAndEscape(Handle<T> handle) {
    if (is_off_thread_) {
      return off_thread()->CloseAndEscape(handle);
    } else {
      return main_thread()->CloseAndEscape(handle);
    }
  }

 private:
  HandleScope* main_thread() {
    return reinterpret_cast<HandleScope*>(&scope_storage_);
  }
  OffThreadHandleScope* off_thread() {
    return reinterpret_cast<OffThreadHandleScope*>(&scope_storage_);
  }

  std::aligned_union_t<0, HandleScope, OffThreadHandleScope> scope_storage_;
  bool is_off_thread_;
};

}  // namespace internal
}  // namespace v8

#endif  // V8_EXECUTION_LOCAL_ISOLATE_WRAPPER_INL_H_