#include "UnmanagedType.h"
#include "NativeScriptException.h"
#include "Caches.h"
#include "Helpers.h"
#include "Interop.h"

using namespace v8;

namespace tns {

Local<Value> UnmanagedType::Create(Local<Context> context, UnmanagedTypeWrapper* wrapper) {
    Isolate* isolate = context->GetIsolate();
    auto cache = Caches::Get(isolate);
    if (cache->UnmanagedTypeCtorFunc.get() == nullptr) {
        Local<FunctionTemplate> ctorFuncTemplate = FunctionTemplate::New(isolate, ConstructorCallback);
        ctorFuncTemplate->SetClassName(tns::ToV8String(isolate, "Unmanaged"));
        Local<ObjectTemplate> proto = ctorFuncTemplate->PrototypeTemplate();

        Local<FunctionTemplate> takeUnretainedValueFuncTemplate = FunctionTemplate::New(isolate, UnmanagedType::TakeUnretainedValueCallback);
        Local<FunctionTemplate> takeRetainedValueFuncTemplate = FunctionTemplate::New(isolate, UnmanagedType::TakeRetainedValueCallback);
        proto->Set(tns::ToV8String(isolate, "takeUnretainedValue"), takeUnretainedValueFuncTemplate);
        proto->Set(tns::ToV8String(isolate, "takeRetainedValue"), takeRetainedValueFuncTemplate);

        Local<v8::Function> ctorFunc;
        bool success = ctorFuncTemplate->GetFunction(context).ToLocal(&ctorFunc);
        tns::Assert(success, isolate);
        
        cache->UnmanagedTypeCtorFunc = std::make_unique<Persistent<v8::Function>>(isolate, ctorFunc);
    }

    Local<External> ext = External::New(isolate, wrapper);

    Local<v8::Function> ctorFunc = cache->UnmanagedTypeCtorFunc->Get(isolate);
    Local<Value> result;
    Local<Value> args[] = { ext };
    bool success = ctorFunc->NewInstance(context, 1, args).ToLocal(&result);
    tns::Assert(success, isolate);

    return result;
}

void UnmanagedType::ConstructorCallback(const FunctionCallbackInfo<Value>& info) {
    Local<External> ext = info[0].As<External>();
    UnmanagedTypeWrapper* wrapper = static_cast<UnmanagedTypeWrapper*>(ext->Value());
    tns::SetValue(info.GetIsolate(), info.This(), wrapper);
}

void UnmanagedType::TakeUnretainedValueCallback(const FunctionCallbackInfo<Value>& info) {
    try {
        info.GetReturnValue().Set(UnmanagedType::TakeValue(info, false));
    } catch (NativeScriptException& ex) {
        ex.ReThrowToV8(info.GetIsolate());
    }
}

void UnmanagedType::TakeRetainedValueCallback(const FunctionCallbackInfo<Value>& info) {
    try {
        info.GetReturnValue().Set(UnmanagedType::TakeValue(info, true));
    } catch (NativeScriptException& ex) {
        ex.ReThrowToV8(info.GetIsolate());
    }
}

Local<Value> UnmanagedType::TakeValue(const FunctionCallbackInfo<Value>& info, bool retained) {
    Isolate* isolate = info.GetIsolate();
    Local<Context> context = isolate->GetCurrentContext();

    BaseDataWrapper* baseWrapper = tns::GetValue(isolate, info.This());
    UnmanagedTypeWrapper* wrapper = static_cast<UnmanagedTypeWrapper*>(baseWrapper);
    
    if (wrapper->ValueTaken()) {
        throw NativeScriptException("Unmanaged value has already been consumed.");
    }

    uint8_t* data = wrapper->Data();
    const TypeEncoding* typeEncoding = wrapper->TypeEncoding();

    BaseCall call((uint8_t*)&data);
    Local<Value> result = Interop::GetResult(context, typeEncoding, &call, false);

    if (retained) {
        id value = static_cast<id>((void*)data);
        [value release];
    }

    return result;
}

}