#ifndef Caches_h

#define Caches_h

#include <string>

#include <vector>

#include "ConcurrentMap.h"

#include "robin_hood.h"

#include "Common.h"

#include "Metadata.h"

namespace tns {

struct StructInfo;

struct pair_hash {

template <class T1, class T2>

std::size_t operator() (const std::pair<T1, T2> &pair) const {

return std::hash<T1>()(pair.first) ^ std::hash<T2>()(pair.second);

}

};

class Caches {

public:

class WorkerState {

public:

WorkerState(v8::Isolate* isolate, std::shared_ptr<v8::Persistent<v8::Value>> poWorker, void* userData)

: isolate_(isolate),

poWorker_(poWorker),

userData_(userData) {

}

v8::Isolate* GetIsolate() {

return this->isolate_;

}

std::shared_ptr<v8::Persistent<v8::Value>> GetWorker() {

return this->poWorker_;

}

void* UserData() {

return this->userData_;

}

private:

v8::Isolate* isolate_;

std::shared_ptr<v8::Persistent<v8::Value>> poWorker_;

void* userData_;

};

Caches(v8::Isolate* isolate, const int& isolateId_ = -1);

~Caches();

bool isWorker = false;

static std::shared_ptr<ConcurrentMap<std::string, const Meta*>> Metadata;

static std::shared_ptr<ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>> Workers;

inline static std::shared_ptr<Caches> Init(v8::Isolate* isolate, const int& isolateId) {

auto cache = std::make_shared<Caches>(isolate, isolateId);

// create a new shared_ptr that will live until Remove is called

isolate->SetData(0, static_cast<void*>(new std::shared_ptr<Caches>(cache)));

return cache;

}

inline static std::shared_ptr<Caches> Get(v8::Isolate* isolate) {

auto cache = isolate->GetData(0);

if (cache != nullptr) {

return *reinterpret_cast<std::shared_ptr<Caches>*>(cache);

}

// this should only happen when an isolate is accessed after disposal

// so we return a dummy cache

return std::make_shared<Caches>(isolate);

}

static void Remove(v8::Isolate* isolate);

inline int getIsolateId() {

return isolateId_;

}

inline void InvalidateIsolate() {

isolateId_ = -1;

}

inline bool IsValid() {

return isolateId_ != -1;

}

void SetContext(v8::Local<v8::Context> context);

v8::Local<v8::Context> GetContext();

robin_hood::unordered_map<const Meta*, std::unique_ptr<v8::Persistent<v8::Value>>> Prototypes;

robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Object>>> ClassPrototypes;

robin_hood::unordered_map<const BaseClassMeta*, std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>> CtorFuncTemplates;

robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Function>>> CtorFuncs;

robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Function>>> ProtocolCtorFuncs;

robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Function>>> StructConstructorFunctions;

robin_hood::unordered_map<BinaryTypeEncodingType, std::unique_ptr<v8::Persistent<v8::Object>>> PrimitiveInteropTypes;

robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Function>>> CFunctions;

robin_hood::unordered_map<id, std::shared_ptr<v8::Persistent<v8::Value>>> Instances;

robin_hood::unordered_map<std::pair<void*, std::string>, std::shared_ptr<v8::Persistent<v8::Value>>, pair_hash> StructInstances;

robin_hood::unordered_map<const void*, std::shared_ptr<v8::Persistent<v8::Object>>> PointerInstances;

std::function<v8::Local<v8::FunctionTemplate>(v8::Local<v8::Context>, const BaseClassMeta*, KnownUnknownClassPair, const std::vector<std::string>&)> ObjectCtorInitializer;

std::function<v8::Local<v8::Function>(v8::Local<v8::Context>, StructInfo)> StructCtorInitializer;

robin_hood::unordered_map<std::string, double> Timers;

robin_hood::unordered_map<const InterfaceMeta*, std::vector<const MethodMeta*>> Initializers;

std::unique_ptr<v8::Persistent<v8::Function>> EmptyObjCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> EmptyStructCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> SliceFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> OriginalExtendsFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> WeakRefGetterFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> WeakRefClearFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> SmartJSONStringifyFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> InteropReferenceCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> PointerCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> FunctionReferenceCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> UnmanagedTypeCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

using unique_void_ptr = std::unique_ptr<void, void(*)(void const*)>;

template<typename T>

auto unique_void(T * ptr) -> unique_void_ptr

{

return unique_void_ptr(ptr, [](void const * data) {

T const * p = static_cast<T const*>(data);

delete p;

});

}

std::vector<unique_void_ptr> cacheBoundObjects_;

template<typename T>

void registerCacheBoundObject(T *ptr) {

this->cacheBoundObjects_.push_back(unique_void(ptr));

}

private:

v8::Isolate* isolate_;

std::shared_ptr<v8::Persistent<v8::Context>> context_;

int isolateId_;

};

}

#endif /* Caches_h */