#include "Reference.h"

#include "Caches.h"

#include "Constants.h"

#include "Helpers.h"

#include "Interop.h"

#include "ObjectManager.h"

#include "Pointer.h"

using namespace v8;

namespace tns {

void Reference::Register(Local<Context> context, Local<Object> interop) {

Isolate* isolate = v8::Isolate::GetCurrent();

Local<v8::Function> ctorFunc =

Reference::GetInteropReferenceCtorFunc(context);

bool success =

interop->Set(context, tns::ToV8String(isolate, "Reference"), ctorFunc)

.FromMaybe(false);

tns::Assert(success, isolate);

}

Local<Value> Reference::FromPointer(Local<Context> context, Local<Value> type,

void* handle) {

Isolate* isolate = v8::Isolate::GetCurrent();

Local<Value> pointer = Pointer::NewInstance(context, handle);

ObjectManager::Register(context, pointer);

Local<v8::Function> interopReferenceCtorFunc =

Reference::GetInteropReferenceCtorFunc(context);

Local<Value> args[2] = {type, pointer};

Local<Object> instance;

bool success = interopReferenceCtorFunc->NewInstance(context, 2, args)

.ToLocal(&instance);

tns::Assert(success, isolate);

ObjectManager::Register(context, instance);

return instance;

}

Local<v8::Function> Reference::GetInteropReferenceCtorFunc(

Local<Context> context) {

Isolate* isolate = v8::Isolate::GetCurrent();

auto cache = Caches::Get(isolate);

Persistent<v8::Function>* interopReferenceCtor =

cache->InteropReferenceCtorFunc.get();

if (interopReferenceCtor != nullptr) {

return interopReferenceCtor->Get(isolate);

}

Local<FunctionTemplate> ctorFuncTemplate =

FunctionTemplate::New(isolate, ReferenceConstructorCallback);

ctorFuncTemplate->SetClassName(tns::ToV8String(isolate, "Reference"));

ctorFuncTemplate->InstanceTemplate()->SetInternalFieldCount(1);

ctorFuncTemplate->InstanceTemplate()->SetHandler(

IndexedPropertyHandlerConfiguration(IndexedPropertyGetCallback,

IndexedPropertySetCallback));

Local<ObjectTemplate> proto = ctorFuncTemplate->PrototypeTemplate();

proto->SetAccessorProperty(tns::ToV8String(isolate, "value"),

FunctionTemplate::New(isolate, GetValueCallback),

FunctionTemplate::New(isolate, SetValueCallback));

Local<v8::Function> ctorFunc;

if (!ctorFuncTemplate->GetFunction(context).ToLocal(&ctorFunc)) {

tns::Assert(false, isolate);

}

tns::SetValue(isolate, ctorFunc, new ReferenceTypeWrapper());

Local<Value> prototypeValue;

bool success = ctorFunc->Get(context, tns::ToV8String(isolate, "prototype"))

.ToLocal(&prototypeValue);

tns::Assert(success && prototypeValue->IsObject(), isolate);

Local<Object> prototype = prototypeValue.As<Object>();

Reference::RegisterToStringMethod(context, prototype);

cache->InteropReferenceCtorFunc =

std::make_unique<Persistent<v8::Function>>(isolate, ctorFunc);

cache->InteropReferenceCtorFunc->SetWrapperClassId(

Constants::ClassTypes::DataWrapper);

return ctorFunc;

}

void Reference::ReferenceConstructorCallback(

const FunctionCallbackInfo<Value>& info) {

Isolate* isolate = info.GetIsolate();

Local<Context> context = isolate->GetCurrentContext();

Persistent<Value>* val = nullptr;

BaseDataWrapper* typeWrapper = nullptr;

if (info.Length() == 1) {

if (!info[0]->IsNullOrUndefined()) {

val = new Persistent<Value>(isolate, info[0]);

}

} else if (info.Length() > 1) {

if (!info[0]->IsNullOrUndefined() && !info[1]->IsNullOrUndefined()) {

Local<Value> typeValue = info[0];

typeWrapper = tns::GetValue(isolate, typeValue);

tns::Assert(typeWrapper != nullptr, isolate);

val = new Persistent<Value>(isolate, info[1]);

}

}

if (val != nullptr) {

val->SetWeak();

}

ReferenceWrapper* wrapper = new ReferenceWrapper(typeWrapper, val);

Local<Object> thiz = info.This();

tns::SetValue(isolate, thiz, wrapper);

ObjectManager::Register(context, thiz);

}

v8::Intercepted Reference::IndexedPropertyGetCallback(

uint32_t index, const PropertyCallbackInfo<Value>& info) {

Isolate* isolate = info.GetIsolate();

Local<Object> thiz = info.Holder();

Local<Context> context = isolate->GetCurrentContext();

DataPair pair = Reference::GetDataPair(thiz);

const TypeEncoding* typeEncoding = pair.typeEncoding_;

size_t size = pair.size_;

void* data = pair.data_;

if (data == nullptr && typeEncoding == nullptr &&

pair.typeWrapper_ == nullptr) {

// GetDataPair threw (released native object).

return v8::Intercepted::kYes;

}

void* ptr = (uint8_t*)data + index * size;

BaseCall call((uint8_t*)ptr);

Local<Value> result;

if (typeEncoding != nullptr) {

result = Interop::GetResult(context, typeEncoding, &call, false);

} else {

result = Interop::GetResultByType(context, pair.typeWrapper_, &call);

}

info.GetReturnValue().Set(result);

return v8::Intercepted::kYes;

}

v8::Intercepted Reference::IndexedPropertySetCallback(

uint32_t index, Local<Value> value,

const PropertyCallbackInfo<v8::Boolean>& info) {

Isolate* isolate = info.GetIsolate();

Local<Context> context = isolate->GetCurrentContext();

Local<Object> thiz = info.Holder();

DataPair pair = Reference::GetDataPair(thiz);

const TypeEncoding* typeEncoding = pair.typeEncoding_;

size_t size = pair.size_;

void* data = pair.data_;

if (data == nullptr && typeEncoding == nullptr &&

pair.typeWrapper_ == nullptr) {

// GetDataPair threw (released native object).

return v8::Intercepted::kYes;

}

void* ptr = (uint8_t*)data + index * size;

if (typeEncoding != nullptr) {

Interop::WriteValue(context, typeEncoding, ptr, value);

} else {

Interop::WriteTypeValue(context, pair.typeWrapper_, ptr, value);

}

// Not intercepted: the native write is done, but V8 must still perform

// the ordinary store, which is what the old void-returning callback did

// by falling through without setting a return value.

return v8::Intercepted::kNo;

}

void Reference::GetValueCallback(const FunctionCallbackInfo<Value>& info) {

Isolate* isolate = info.GetIsolate();

Local<Context> context = isolate->GetCurrentContext();

Local<Value> result = Reference::GetReferredValue(context, info.This());

if (result.IsEmpty()) {

info.GetReturnValue().SetUndefined();

} else {

info.GetReturnValue().Set(result);

}

}

void Reference::SetValueCallback(const FunctionCallbackInfo<Value>& info) {

Isolate* isolate = info.GetIsolate();

Local<Value> value = info[0];

BaseDataWrapper* baseWrapper =

tns::GetValueOrReport(isolate, info.This(), "Reference value set");

if (baseWrapper == nullptr) {

return;

}

tns::Assert(baseWrapper->Type() == WrapperType::Reference, isolate);

ReferenceWrapper* wrapper = static_cast<ReferenceWrapper*>(baseWrapper);

Persistent<Value>* poValue = new Persistent<Value>(isolate, value);

wrapper->SetData(nullptr);

wrapper->SetEncoding(nullptr);

wrapper->SetValue(poValue);

}

Local<Value> Reference::GetReferredValue(Local<Context> context,

Local<Value> value) {

Isolate* isolate = v8::Isolate::GetCurrent();

BaseDataWrapper* baseWrapper = tns::GetValue(isolate, value);

if (baseWrapper == nullptr || baseWrapper->Type() != WrapperType::Reference) {

return value;

}

ReferenceWrapper* wrapper = static_cast<ReferenceWrapper*>(baseWrapper);

if (wrapper->Data() != nullptr && wrapper->Encoding() != nullptr) {

const TypeEncoding* encoding = wrapper->Encoding();

uint8_t* data = (uint8_t*)wrapper->Data();

BaseCall call(data);

Local<Value> jsResult = Interop::GetResult(context, encoding, &call, true);

if (wrapper->Value() != nullptr) {

wrapper->Value()->Reset(isolate, jsResult);

} else {

wrapper->SetValue(new Persistent<Value>(isolate, jsResult));

}

wrapper->SetData(nullptr);

wrapper->SetEncoding(nullptr);

return jsResult;

}

if (wrapper->Value() == nullptr) {

return Local<Value>();

}

Local<Value> innerValue = wrapper->Value()->Get(isolate);

baseWrapper = tns::GetValue(isolate, innerValue);

if (baseWrapper != nullptr && baseWrapper->Type() == WrapperType::Reference) {

wrapper = static_cast<ReferenceWrapper*>(baseWrapper);

if (wrapper->Value() != nullptr) {

return Reference::GetReferredValue(context,

wrapper->Value()->Get(isolate));

}

}

BaseDataWrapper* typeWrapper = wrapper->TypeWrapper();

if (typeWrapper != nullptr &&

Reference::IsSupportedType(typeWrapper->Type()) &&

baseWrapper != nullptr && baseWrapper->Type() == WrapperType::Pointer) {

Reference::DataPair pair = Reference::GetDataPair(value.As<Object>());

if (pair.data_ != nullptr) {

BaseCall call((uint8_t*)pair.data_);

Local<Value> result;

if (pair.typeEncoding_ != nullptr) {

result = Interop::GetResult(context, pair.typeEncoding_, &call, false);

} else {

result = Interop::GetResultByType(context, typeWrapper, &call);

}

return result;

}

}

return innerValue;

}

void* Reference::GetWrappedPointer(Local<Context> context,

Local<Value> reference,

const TypeEncoding* typeEncoding) {

if (reference.IsEmpty() || reference->IsNullOrUndefined()) {

return nullptr;

}

Isolate* isolate = v8::Isolate::GetCurrent();

BaseDataWrapper* wrapper =

tns::GetValueOrReport(isolate, reference, "Reference pointer access");

if (wrapper == nullptr) {

return nullptr;

}

tns::Assert(wrapper->Type() == WrapperType::Reference, isolate);

ReferenceWrapper* refWrapper = static_cast<ReferenceWrapper*>(wrapper);

if (refWrapper->Data() != nullptr) {

return refWrapper->Data();

}

Local<Value> value = refWrapper->Value()->Get(isolate);

BaseDataWrapper* wrappedValue = tns::GetValue(isolate, value);

if (wrappedValue == nullptr) {

BaseDataWrapper* typeWrapper = refWrapper->TypeWrapper();

if (typeWrapper == nullptr) {

return nullptr;

}

if (typeWrapper->Type() == WrapperType::Primitive) {

PrimitiveDataWrapper* primitiveWrapper =

static_cast<PrimitiveDataWrapper*>(typeWrapper);

const TypeEncoding* enc = primitiveWrapper->TypeEncoding();

size_t size = primitiveWrapper->Size();

void* data = malloc(size);

Interop::WriteValue(context, enc, data, value);

refWrapper->SetData(data, true);

return data;

}

if (typeWrapper->Type() != WrapperType::StructType) {

return nullptr;

}

StructTypeWrapper* structTypeWrapper =

static_cast<StructTypeWrapper*>(refWrapper->TypeWrapper());

StructInfo structInfo = structTypeWrapper->StructInfo();

void* data = malloc(structInfo.FFIType()->size);

Interop::InitializeStruct(context, data, structInfo.Fields(), value);

refWrapper->SetData(data, true);

refWrapper->SetEncoding(typeEncoding);

return data;

}

if (wrappedValue->Type() == WrapperType::ObjCClass) {

ObjCClassWrapper* classWrapper =

static_cast<ObjCClassWrapper*>(wrappedValue);

void* handle = malloc(sizeof(Class*));

Class clazz = classWrapper->Klass();

*static_cast<Class*>(handle) = clazz;

refWrapper->SetData(handle, true);

return (Class**)handle;

}

if (wrappedValue->Type() == WrapperType::ObjCProtocol) {

ObjCProtocolWrapper* protoWrapper =

static_cast<ObjCProtocolWrapper*>(wrappedValue);

Protocol* proto = protoWrapper->Proto();

void* handle = malloc(sizeof(Protocol**));

*static_cast<Protocol**>(handle) = proto;

refWrapper->SetData(handle, true);

return (Protocol**)handle;

}

if (wrappedValue->Type() == WrapperType::ObjCObject) {

ObjCDataWrapper* dataWrapper = static_cast<ObjCDataWrapper*>(wrappedValue);

id target = dataWrapper->Data();

void* handle = malloc(sizeof(id));

*static_cast<id*>(handle) = target;

refWrapper->SetData(handle, true);

return (id)handle;

}

if (wrappedValue->Type() == WrapperType::Struct) {

StructWrapper* structWrapper = static_cast<StructWrapper*>(wrappedValue);

return structWrapper->Data();

}

if (wrappedValue->Type() == WrapperType::Pointer) {

PointerWrapper* pw = static_cast<PointerWrapper*>(wrappedValue);

void* data = pw->Data();

return data;

}

return nullptr;

}

void Reference::RegisterToStringMethod(Local<Context> context,

Local<Object> prototype) {

Isolate* isolate = v8::Isolate::GetCurrent();

Local<FunctionTemplate> funcTemplate = FunctionTemplate::New(

isolate, [](const FunctionCallbackInfo<Value>& info) {

Isolate* isolate = info.GetIsolate();

BaseDataWrapper* wrapper =

tns::GetValueOrReport(isolate, info.This(), "Reference.toString");

if (wrapper == nullptr) {

if (tns::GetReleasedObjectPolicy() ==

tns::ReleasedObjectPolicy::kReport) {

info.GetReturnValue().Set(

tns::ToV8String(isolate, "<Reference: released>"));

}

return;

}

tns::Assert(wrapper->Type() == WrapperType::Reference, isolate);

ReferenceWrapper* refWrapper = static_cast<ReferenceWrapper*>(wrapper);

Persistent<Value>* value = refWrapper->Value();

char buffer[100];

if (value == nullptr) {

snprintf(buffer, 100, "<Reference: %p>", reinterpret_cast<void*>(0));

} else {

snprintf(buffer, 100, "<Reference: %p>", value);

}

Local<v8::String> result = tns::ToV8String(isolate, buffer);

info.GetReturnValue().Set(result);

});

Local<v8::Function> func;

tns::Assert(funcTemplate->GetFunction(context).ToLocal(&func), isolate);

bool success =

prototype->Set(context, tns::ToV8String(isolate, "toString"), func)

.FromMaybe(false);

tns::Assert(success, isolate);

}

Reference::DataPair Reference::GetDataPair(Local<Object> obj) {

Local<Context> context;

bool success =

obj->GetCreationContext(v8::Isolate::GetCurrent()).ToLocal(&context);

tns::Assert(success);

Isolate* isolate = v8::Isolate::GetCurrent();

BaseDataWrapper* wrapper =

tns::GetValueOrReport(isolate, obj, "Reference indexed access");

if (wrapper == nullptr) {

return DataPair(nullptr, nullptr, nullptr, 0);

}

tns::Assert(wrapper->Type() == WrapperType::Reference, isolate);

ReferenceWrapper* refWrapper = static_cast<ReferenceWrapper*>(wrapper);

BaseDataWrapper* typeWrapper = refWrapper->TypeWrapper();

size_t size = 0;

if (typeWrapper != nullptr) {

const TypeEncoding* typeEncoding = nullptr;

if (Reference::IsSupportedType(typeWrapper->Type())) {

switch (typeWrapper->Type()) {

case WrapperType::Primitive: {

PrimitiveDataWrapper* primitiveWrapper =

static_cast<PrimitiveDataWrapper*>(typeWrapper);

size = primitiveWrapper->Size();

typeEncoding = primitiveWrapper->TypeEncoding();

break;

}

case WrapperType::StructType: {

StructTypeWrapper* structTypeWrapper =

static_cast<StructTypeWrapper*>(refWrapper->TypeWrapper());

StructInfo structInfo = structTypeWrapper->StructInfo();

size = structInfo.FFIType()->size;

break;

}

default: {

break;

}

}

} else {

// TODO: Currently only PrimitiveDataWrappers and Structs are supported as

// type parameters Objective C class classes should also be handled

tns::Assert(false, isolate);

}

Local<Value> value = refWrapper->Value()->Get(isolate);

BaseDataWrapper* wrappedValue = tns::GetValue(isolate, value);

if (wrappedValue != nullptr &&

wrappedValue->Type() == WrapperType::Pointer) {

PointerWrapper* pw = static_cast<PointerWrapper*>(wrappedValue);

void* data = pw->Data();

DataPair pair(typeWrapper, typeEncoding, data, size);

return pair;

}

}

if (refWrapper->Encoding() != nullptr && refWrapper->Data() != nullptr) {

const TypeEncoding* typeEncoding = refWrapper->Encoding();

if (typeWrapper == nullptr) {

ffi_type* ffiType = FFICall::GetArgumentType(typeEncoding);

size = ffiType->size;

FFICall::DisposeFFIType(ffiType, typeEncoding);

}

DataPair pair(typeWrapper, typeEncoding, refWrapper->Data(), size);

return pair;

}

tns::Assert(false, isolate);

return DataPair(typeWrapper, nullptr, nullptr, size);

}

bool Reference::IsSupportedType(WrapperType type) {

return type == WrapperType::Primitive || type == WrapperType::StructType;

}

} // namespace tns