// Copyright 2017 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef COBALT_SCRIPT_V8C_V8C_ENGINE_H_
#define COBALT_SCRIPT_V8C_V8C_ENGINE_H_

#include <memory>
#include <vector>

#include "base/threading/thread_checker.h"
#include "base/timer/timer.h"
#include "cobalt/script/javascript_engine.h"
#include "cobalt/script/v8c/v8c_heap_tracer.h"
#include "v8/include/libplatform/libplatform.h"
#include "v8/include/v8.h"

namespace cobalt {
namespace script {
namespace v8c {

class V8cEngine : public JavaScriptEngine {
 public:
  // Helper function to allow others to retrieve us (a |V8cEngine|) from our
  // |v8::Isolate|.
  static V8cEngine* GetFromIsolate(v8::Isolate* isolate) {
    return static_cast<V8cEngine*>(isolate->GetData(kIsolateDataIndex));
  }

  explicit V8cEngine(const Options& options);
  ~V8cEngine() override;

  scoped_refptr<GlobalEnvironment> CreateGlobalEnvironment() override;
  void CollectGarbage() override;
  void AdjustAmountOfExternalAllocatedMemory(int64_t bytes) override;
  bool RegisterErrorHandler(JavaScriptEngine::ErrorHandler handler) override;
  HeapStatistics GetHeapStatistics() override;
  void UpdateDateTimeConfiguration() override;

  v8::Isolate* isolate() const { return isolate_; }
  V8cHeapTracer* heap_tracer() const { return v8c_heap_tracer_.get(); }

 private:
  // Where we store ourselves as embedder private data in our corresponding
  // |v8::Isolate|.
  static const int kIsolateDataIndex = 0;

  THREAD_CHECKER(thread_checker_);

  // An isolated instance of the V8 engine.
  v8::Isolate* isolate_;

  std::unique_ptr<V8cHeapTracer> v8c_heap_tracer_;

  // Used to handle javascript errors.
  ErrorHandler error_handler_;

  JavaScriptEngine::Options options_;
};

}  // namespace v8c
}  // namespace script
}  // namespace cobalt

#endif  // COBALT_SCRIPT_V8C_V8C_ENGINE_H_
