// 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 INCLUDE_V8_CPPGC_H_

#define INCLUDE_V8_CPPGC_H_

#include <cstdint>

#include <memory>

#include <vector>

#include "cppgc/common.h"

#include "cppgc/custom-space.h"

#include "cppgc/heap-statistics.h"

#include "cppgc/visitor.h"

#include "v8-internal.h"       // NOLINT(build/include_directory)

#include "v8-platform.h"       // NOLINT(build/include_directory)

#include "v8-traced-handle.h"  // NOLINT(build/include_directory)

namespace cppgc {

class AllocationHandle;

class HeapHandle;

}  // namespace cppgc

namespace v8 {

class Object;

namespace internal {

class CppHeap;

}  // namespace internal

class CustomSpaceStatisticsReceiver;

/**

 * Describes how V8 wrapper objects maintain references to garbage-collected C++

 * objects.

 */

struct WrapperDescriptor final {

  /**

   * The index used on `v8::Ojbect::SetAlignedPointerFromInternalField()` and

   * related APIs to add additional data to an object which is used to identify

   * JS->C++ references.

   */

  using InternalFieldIndex = int;

  /**

   * Unknown embedder id. The value is reserved for internal usages and must not

   * be used with `CppHeap`.

   */

  static constexpr uint16_t kUnknownEmbedderId = UINT16_MAX;

  constexpr WrapperDescriptor(InternalFieldIndex wrappable_type_index,

                              InternalFieldIndex wrappable_instance_index,

                              uint16_t embedder_id_for_garbage_collected)

      : wrappable_type_index(wrappable_type_index),

        wrappable_instance_index(wrappable_instance_index),

        embedder_id_for_garbage_collected(embedder_id_for_garbage_collected) {}

  /**

   * Index of the wrappable type.

   */

  InternalFieldIndex wrappable_type_index;

  /**

   * Index of the wrappable instance.

   */

  InternalFieldIndex wrappable_instance_index;

  /**

   * Embedder id identifying instances of garbage-collected objects. It is

   * expected that the first field of the wrappable type is a uint16_t holding

   * the id. Only references to instances of wrappables types with an id of

   * `embedder_id_for_garbage_collected` will be considered by CppHeap.

   */

  uint16_t embedder_id_for_garbage_collected;

};

struct V8_EXPORT CppHeapCreateParams {

  CppHeapCreateParams(

      std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces,

      WrapperDescriptor wrapper_descriptor)

      : custom_spaces(std::move(custom_spaces)),

        wrapper_descriptor(wrapper_descriptor) {}

  CppHeapCreateParams(const CppHeapCreateParams&) = delete;

  CppHeapCreateParams& operator=(const CppHeapCreateParams&) = delete;

  std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces;

  WrapperDescriptor wrapper_descriptor;

  /**

   * Specifies which kind of marking are supported by the heap. The type may be

   * further reduced via runtime flags when attaching the heap to an Isolate.

   */

  cppgc::Heap::MarkingType marking_support =

      cppgc::Heap::MarkingType::kIncrementalAndConcurrent;

  /**

   * Specifies which kind of sweeping is supported by the heap. The type may be

   * further reduced via runtime flags when attaching the heap to an Isolate.

   */

  cppgc::Heap::SweepingType sweeping_support =

      cppgc::Heap::SweepingType::kIncrementalAndConcurrent;

};

/**

 * A heap for allocating managed C++ objects.

 *

 * Similar to v8::Isolate, the heap may only be accessed from one thread at a

 * time. The heap may be used from different threads using the

 * v8::Locker/v8::Unlocker APIs which is different from generic Oilpan.

 */

class V8_EXPORT CppHeap {

 public:

  static std::unique_ptr<CppHeap> Create(v8::Platform* platform,

                                         const CppHeapCreateParams& params);

  virtual ~CppHeap() = default;

  /**

   * \returns the opaque handle for allocating objects using

   * `MakeGarbageCollected()`.

   */

  cppgc::AllocationHandle& GetAllocationHandle();

  /**

   * \returns the opaque heap handle which may be used to refer to this heap in

   *   other APIs. Valid as long as the underlying `CppHeap` is alive.

   */

  cppgc::HeapHandle& GetHeapHandle();

  /**

   * Terminate clears all roots and performs multiple garbage collections to

   * reclaim potentially newly created objects in destructors.

   *

   * After this call, object allocation is prohibited.

   */

  void Terminate();

  /**

   * \param detail_level specifies whether should return detailed

   *   statistics or only brief summary statistics.

   * \returns current CppHeap statistics regarding memory consumption

   *   and utilization.

   */

  cppgc::HeapStatistics CollectStatistics(

      cppgc::HeapStatistics::DetailLevel detail_level);

  /**

   * Collects statistics for the given spaces and reports them to the receiver.

   *

   * \param custom_spaces a collection of custom space indicies.

   * \param receiver an object that gets the results.

   */

  void CollectCustomSpaceStatisticsAtLastGC(

      std::vector<cppgc::CustomSpaceIndex> custom_spaces,

      std::unique_ptr<CustomSpaceStatisticsReceiver> receiver);

  /**

   * Enables a detached mode that allows testing garbage collection using

   * `cppgc::testing` APIs. Once used, the heap cannot be attached to an

   * `Isolate` anymore.

   */

  void EnableDetachedGarbageCollectionsForTesting();

  /**

   * Performs a stop-the-world garbage collection for testing purposes.

   *

   * \param stack_state The stack state to assume for the garbage collection.

   */

  void CollectGarbageForTesting(cppgc::EmbedderStackState stack_state);

  /**

   * Performs a stop-the-world minor garbage collection for testing purposes.

   *

   * \param stack_state The stack state to assume for the garbage collection.

   */

  void CollectGarbageInYoungGenerationForTesting(

      cppgc::EmbedderStackState stack_state);

  /**

   * \returns the wrapper descriptor of this CppHeap.

   */

  v8::WrapperDescriptor wrapper_descriptor() const;

 private:

  CppHeap() = default;

  friend class internal::CppHeap;

};

class JSVisitor : public cppgc::Visitor {

 public:

  explicit JSVisitor(cppgc::Visitor::Key key) : cppgc::Visitor(key) {}

  ~JSVisitor() override = default;

  void Trace(const TracedReferenceBase& ref) {

    if (ref.IsEmptyThreadSafe()) return;

    Visit(ref);

  }

 protected:

  using cppgc::Visitor::Visit;

  virtual void Visit(const TracedReferenceBase& ref) {}

};

/**

 * Provided as input to `CppHeap::CollectCustomSpaceStatisticsAtLastGC()`.

 *

 * Its method is invoked with the results of the statistic collection.

 */

class CustomSpaceStatisticsReceiver {

 public:

  virtual ~CustomSpaceStatisticsReceiver() = default;

  /**

   * Reports the size of a space at the last GC. It is called for each space

   * that was requested in `CollectCustomSpaceStatisticsAtLastGC()`.

   *

   * \param space_index The index of the space.

   * \param bytes The total size of live objects in the space at the last GC.

   *    It is zero if there was no GC yet.

   */

  virtual void AllocatedBytes(cppgc::CustomSpaceIndex space_index,

                              size_t bytes) = 0;

};

}  // namespace v8

namespace cppgc {

template <typename T>

struct TraceTrait<v8::TracedReference<T>> {

  static cppgc::TraceDescriptor GetTraceDescriptor(const void* self) {

    return {nullptr, Trace};

  }

  static void Trace(Visitor* visitor, const void* self) {

    static_cast<v8::JSVisitor*>(visitor)->Trace(

        *static_cast<const v8::TracedReference<T>*>(self));

  }

};

}  // namespace cppgc

#endif  // INCLUDE_V8_CPPGC_H_