/*
 * Tencent is pleased to support the open source community by making Puerts available.
 * Copyright (C) 2020 THL A29 Limited, a Tencent company.  All rights reserved.
 * Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
 * be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
 * which is part of this source code package.
 */

#include "StructWrapper.h"
#include "V8Utils.h"
#include "ObjectMapper.h"
#include "PathEscape.h"

namespace PUERTS_NAMESPACE
{
void FStructWrapper::AddExtensionMethods(const std::vector<UFunction*>& InExtensionMethods)
{
    ExtensionMethods.insert(ExtensionMethods.end(), InExtensionMethods.begin(), InExtensionMethods.end());
}

std::shared_ptr<FPropertyTranslator> FStructWrapper::GetPropertyTranslator(PropertyMacro* InProperty)
{
    auto Iter = PropertiesMap.Find(InProperty->GetFName());
    if (!Iter)
    {
        std::shared_ptr<FPropertyTranslator> PropertyTranslator = FPropertyTranslator::Create(InProperty);
        if (PropertyTranslator)
        {
            PropertiesMap.Add(InProperty->GetFName(), PropertyTranslator);
            Properties.push_back(PropertyTranslator);
        }
        return PropertyTranslator;
    }
    FPropertyTranslator::CreateOn(InProperty, Iter->get());
    return *Iter;
}

std::shared_ptr<FFunctionTranslator> FStructWrapper::GetMethodTranslator(UFunction* InFunction, bool IsExtension)
{
    auto Iter = MethodsMap.Find(InFunction->GetFName());
    if (!Iter)
    {
        std::shared_ptr<FFunctionTranslator> FunctionTranslator;
        if (IsExtension)
        {
            FunctionTranslator = std::make_shared<FExtensionMethodTranslator>(InFunction);
        }
        else
        {
            FunctionTranslator = std::make_shared<FFunctionTranslator>(InFunction, false);
        }
        MethodsMap.Add(InFunction->GetFName(), FunctionTranslator);
        return FunctionTranslator;
    }
    Iter->get()->Init(InFunction, false);
    return *Iter;
}

std::shared_ptr<FFunctionTranslator> FStructWrapper::GetFunctionTranslator(UFunction* InFunction)
{
    auto Iter = FunctionsMap.Find(InFunction->GetFName());
    if (!Iter)
    {
        auto FunctionTranslator = std::make_shared<FFunctionTranslator>(InFunction, false);
        FunctionsMap.Add(InFunction->GetFName(), FunctionTranslator);
        return FunctionTranslator;
    }
    Iter->get()->Init(InFunction, false);
    return *Iter;
}

void FStructWrapper::RefreshMethod(UFunction* InFunction)
{
    if (!InFunction->HasAnyFunctionFlags(FUNC_Static))
    {
        GetMethodTranslator(InFunction, false);
    }
}

MSVC_PRAGMA(warning(push))
MSVC_PRAGMA(warning(disable : 4191))
void FStructWrapper::InitTemplateProperties(
    v8::Isolate* Isolate, UStruct* InStruct, v8::Local<v8::FunctionTemplate> Template, bool IsReuseTemplate)
{
    auto ClassDefinition = FindClassByType(Struct.Get());
    TSet<FName> AddedProperties;
    if (ClassDefinition)
    {
        JSPropertyInfo* PropertyInfo = ClassDefinition->Properties;
        while (PropertyInfo && PropertyInfo->Name && PropertyInfo->Getter)
        {
            AddedProperties.Add(PropertyInfo->Name);
            if (!IsReuseTemplate)
            {
                v8::PropertyAttribute PropertyAttribute = v8::DontDelete;
                if (!PropertyInfo->Setter)
                    PropertyAttribute = (v8::PropertyAttribute)(PropertyAttribute | v8::ReadOnly);
                auto GetterData = PropertyInfo->GetterData
                                      ? static_cast<v8::Local<v8::Value>>(v8::External::New(Isolate, PropertyInfo->GetterData))
                                      : v8::Local<v8::Value>();

                auto SetterData = PropertyInfo->SetterData
                                      ? static_cast<v8::Local<v8::Value>>(v8::External::New(Isolate, PropertyInfo->SetterData))
                                      : v8::Local<v8::Value>();

                Template->PrototypeTemplate()->SetAccessorProperty(FV8Utils::InternalString(Isolate, PropertyInfo->Name),
                    PropertyInfo->Getter
                        ? v8::FunctionTemplate::New(Isolate, (v8::FunctionCallback) PropertyInfo->Getter, GetterData)
                        : v8::Local<v8::FunctionTemplate>(),
                    PropertyInfo->Setter
                        ? v8::FunctionTemplate::New(Isolate, (v8::FunctionCallback) PropertyInfo->Setter, SetterData)
                        : v8::Local<v8::FunctionTemplate>(),
                    PropertyAttribute);
            }
            ++PropertyInfo;
        }

        if (!IsReuseTemplate)
        {
            PropertyInfo = ClassDefinition->Variables;
            while (PropertyInfo && PropertyInfo->Name && PropertyInfo->Getter)
            {
                v8::PropertyAttribute PropertyAttribute = v8::DontDelete;
                if (!PropertyInfo->Setter)
                    PropertyAttribute = (v8::PropertyAttribute)(PropertyAttribute | v8::ReadOnly);
                auto GetterData = PropertyInfo->GetterData
                                      ? static_cast<v8::Local<v8::Value>>(v8::External::New(Isolate, PropertyInfo->GetterData))
                                      : v8::Local<v8::Value>();

                auto SetterData = PropertyInfo->SetterData
                                      ? static_cast<v8::Local<v8::Value>>(v8::External::New(Isolate, PropertyInfo->SetterData))
                                      : v8::Local<v8::Value>();

                Template->SetAccessorProperty(FV8Utils::InternalString(Isolate, PropertyInfo->Name),
                    PropertyInfo->Getter
                        ? v8::FunctionTemplate::New(Isolate, (v8::FunctionCallback) PropertyInfo->Getter, GetterData)
                        : v8::Local<v8::FunctionTemplate>(),
                    PropertyInfo->Setter
                        ? v8::FunctionTemplate::New(Isolate, (v8::FunctionCallback) PropertyInfo->Setter, SetterData)
                        : v8::Local<v8::FunctionTemplate>(),
                    PropertyAttribute);
                ++PropertyInfo;
            }
        }
    }
    for (TFieldIterator<PropertyMacro> PropertyIt(InStruct, EFieldIteratorFlags::ExcludeSuper); PropertyIt; ++PropertyIt)
    {
        PropertyMacro* Property = *PropertyIt;
        if (AddedProperties.Contains(Property->GetFName()))
        {
            continue;
        }

        auto PropertyTranslator = GetPropertyTranslator(Property);
        if (PropertyTranslator)
        {
            if (!IsReuseTemplate)
                PropertyTranslator->SetAccessor(Isolate, Template);
        }
        else
        {
            // UE_LOG(LogTemp, Warning, TEXT("%s:%s not supported"), *Property->GetOwnerStruct()->GetName(), *Property->GetName());
        }
    }
}

v8::Local<v8::FunctionTemplate> FStructWrapper::ToFunctionTemplate(v8::Isolate* Isolate, v8::FunctionCallback Construtor)
{
    auto ClassDefinition = FindClassByType(Struct.Get());
    bool IsReuseTemplate = false;
#if PUERTS_REUSE_STRUCTWRAPPER_FUNCTIONTEMPLATE
    IsReuseTemplate = true;
    if (CachedFunctionTemplate.IsEmpty())
    {
        IsReuseTemplate = false;
        auto Temp = v8::FunctionTemplate::New(Isolate, Construtor, v8::External::New(Isolate, this));
        Temp->InstanceTemplate()->SetInternalFieldCount(4);
        CachedFunctionTemplate.Reset(Isolate, Temp);
    }
    auto Result = CachedFunctionTemplate.Get(Isolate);
#else
    auto Result = v8::FunctionTemplate::New(
        Isolate, Construtor, v8::External::New(Isolate, this));    // 和class的区别就这里传的函数不一样，后续尽量重用
    Result->InstanceTemplate()->SetInternalFieldCount(4);
#endif

    TSet<FName> AddedMethods;
    TSet<FName> AddedFunctions;

    if (ClassDefinition)
    {
        ExternalInitialize = (V8InitializeFuncType) ClassDefinition->Initialize;
        ExternalFinalize = ClassDefinition->Finalize;
        JSFunctionInfo* FunctionInfo = ClassDefinition->Methods;
        while (FunctionInfo && FunctionInfo->Name && FunctionInfo->Callback)
        {
            AddedMethods.Add(FunctionInfo->Name);
            if (!IsReuseTemplate)
            {
#ifndef WITH_QUICKJS
                auto FastCallInfo = FunctionInfo->ReflectionInfo ? FunctionInfo->ReflectionInfo->FastCallInfo() : nullptr;
                if (FastCallInfo)
                {
                    Result->PrototypeTemplate()->Set(FV8Utils::InternalString(Isolate, FunctionInfo->Name),
                        v8::FunctionTemplate::New(Isolate, (v8::FunctionCallback) FunctionInfo->Callback,
                            FunctionInfo->Data ? static_cast<v8::Local<v8::Value>>(v8::External::New(Isolate, FunctionInfo->Data))
                                               : v8::Local<v8::Value>(),
                            v8::Local<v8::Signature>(), 0, v8::ConstructorBehavior::kThrow, v8::SideEffectType::kHasSideEffect,
                            FastCallInfo));
                }
                else
#endif
                {
                    Result->PrototypeTemplate()->Set(FV8Utils::InternalString(Isolate, FunctionInfo->Name),
                        v8::FunctionTemplate::New(Isolate, (v8::FunctionCallback) FunctionInfo->Callback,
                            FunctionInfo->Data ? static_cast<v8::Local<v8::Value>>(v8::External::New(Isolate, FunctionInfo->Data))
                                               : v8::Local<v8::Value>()));
                }
            }
            ++FunctionInfo;
        }
        FunctionInfo = ClassDefinition->Functions;
        while (FunctionInfo && FunctionInfo->Name && FunctionInfo->Callback)
        {
            AddedFunctions.Add(FunctionInfo->Name);
            if (!IsReuseTemplate)
            {
#ifndef WITH_QUICKJS
                auto FastCallInfo = FunctionInfo->ReflectionInfo ? FunctionInfo->ReflectionInfo->FastCallInfo() : nullptr;
                if (FastCallInfo)
                {
                    Result->Set(FV8Utils::InternalString(Isolate, FunctionInfo->Name),
                        v8::FunctionTemplate::New(Isolate, (v8::FunctionCallback) FunctionInfo->Callback,
                            FunctionInfo->Data ? static_cast<v8::Local<v8::Value>>(v8::External::New(Isolate, FunctionInfo->Data))
                                               : v8::Local<v8::Value>(),
                            v8::Local<v8::Signature>(), 0, v8::ConstructorBehavior::kThrow, v8::SideEffectType::kHasSideEffect,
                            FastCallInfo));
                }
                else
#endif
                {
                    Result->Set(FV8Utils::InternalString(Isolate, FunctionInfo->Name),
                        v8::FunctionTemplate::New(Isolate, (v8::FunctionCallback) FunctionInfo->Callback,
                            FunctionInfo->Data ? static_cast<v8::Local<v8::Value>>(v8::External::New(Isolate, FunctionInfo->Data))
                                               : v8::Local<v8::Value>()));
                }
            }
            ++FunctionInfo;
        }
    }

    InitTemplateProperties(Isolate, Struct.Get(), Result, IsReuseTemplate);

    if (const auto Class = Cast<UClass>(Struct.Get()))
    {
        for (TFieldIterator<UFunction> FuncIt(Class, EFieldIteratorFlags::ExcludeSuper); FuncIt; ++FuncIt)
        {
            UFunction* Function = *FuncIt;

            if ((Function->HasAnyFunctionFlags(FUNC_Static) && AddedFunctions.Contains(Function->GetFName())) ||
                (!Function->HasAnyFunctionFlags(FUNC_Static) && AddedMethods.Contains(Function->GetFName())))
            {
                // UE_LOG(LogTemp, Warning, TEXT("%s added"), *Function->GetName());
                continue;
            }

            FString FuncName = Function->GetName();
            auto Key = FV8Utils::InternalString(Isolate, FuncName);
#ifdef PUERTS_WITH_EDITOR_SUFFIX
            // 这里同时绑定带Suffix和不带Suffix的后缀是为了兼容现有的一些js写的代码(PuertsEditor)
            v8::Local<v8::String> AdditionalKey{};
            if (puerts::IsEditorOnlyUFunction(Function))
            {
                FString SuffixFuncName = FuncName + EditorOnlyPropertySuffix.GetData();
                AdditionalKey = FV8Utils::InternalString(Isolate, SuffixFuncName);
            }
#endif
            // 这里同时绑定带Suffix和不带Suffix的后缀是为了兼容现有的一些js写的代码(PuertsEditor)

            if (Function->HasAnyFunctionFlags(FUNC_Static))
            {
                auto FunctionTranslator = GetFunctionTranslator(Function);
                AddedFunctions.Add(Function->GetFName());
                if (!IsReuseTemplate)
                {
                    Result->Set(Key, FunctionTranslator->ToFunctionTemplate(Isolate));
#ifdef PUERTS_WITH_EDITOR_SUFFIX
                    if (!AdditionalKey.IsEmpty())
                    {
                        Result->Set(AdditionalKey, FunctionTranslator->ToFunctionTemplate(Isolate));
                    }
#endif
                }
            }
            else
            {
                auto FunctionTranslator = GetMethodTranslator(Function, false);
                AddedMethods.Add(Function->GetFName());
                if (!IsReuseTemplate)
                {
                    Result->PrototypeTemplate()->Set(Key, FunctionTranslator->ToFunctionTemplate(Isolate));
#ifdef PUERTS_WITH_EDITOR_SUFFIX
                    if (!AdditionalKey.IsEmpty())
                    {
                        Result->PrototypeTemplate()->Set(AdditionalKey, FunctionTranslator->ToFunctionTemplate(Isolate));
                    }
#endif
                }
            }
        }

        for (const FImplementedInterface& Interface : Class->Interfaces)
        {
            if (Interface.Class)
            {
                for (TFieldIterator<UFunction> ItfFuncIt(Interface.Class, EFieldIteratorFlags::ExcludeSuper); ItfFuncIt;
                     ++ItfFuncIt)
                {
                    UFunction* ItfFunction = *ItfFuncIt;
                    if (!ItfFunction->HasAnyFunctionFlags(FUNC_Static) && !AddedMethods.Contains(ItfFunction->GetFName()))
                    {
                        auto ItfFunctionTranslator = GetMethodTranslator(ItfFunction, false);
                        AddedMethods.Add(ItfFunction->GetFName());
                        if (!IsReuseTemplate)
                            Result->PrototypeTemplate()->Set(FV8Utils::InternalString(Isolate, ItfFunction->GetName()),
                                ItfFunctionTranslator->ToFunctionTemplate(Isolate));
                    }
                }
            }
        }
        if (!IsReuseTemplate)
        {
            Result->Set(FV8Utils::InternalString(Isolate, "Find"),
                v8::FunctionTemplate::New(Isolate, Find, v8::External::New(Isolate, this)));
            Result->Set(FV8Utils::InternalString(Isolate, "Load"),
                v8::FunctionTemplate::New(Isolate, Load, v8::External::New(Isolate, this)));
        }
    }

    for (auto Iter = ExtensionMethods.begin(); Iter != ExtensionMethods.end(); ++Iter)
    {
        UFunction* Function = *Iter;

        if (AddedMethods.Contains(Function->GetFName()))
        {
            continue;
        }

        auto FunctionTranslator = GetMethodTranslator(Function, true);

        AddedMethods.Add(Function->GetFName());
        if (!IsReuseTemplate)
        {
            auto Key = FV8Utils::InternalString(Isolate, Function->GetName());
            Result->PrototypeTemplate()->Set(Key, FunctionTranslator->ToFunctionTemplate(Isolate));
        }
    }

    if (!IsReuseTemplate)
        Result->Set(FV8Utils::InternalString(Isolate, "StaticClass"),
            v8::FunctionTemplate::New(Isolate, StaticClass, v8::External::New(Isolate, this)));

    if (!Struct->IsA<UClass>() && !IsReuseTemplate)
    {
        Result->Set(FV8Utils::InternalString(Isolate, "StaticStruct"),
            v8::FunctionTemplate::New(Isolate, StaticClass, v8::External::New(Isolate, this)));
    }

#ifndef WITH_QUICKJS
    if (!IsReuseTemplate)
        Result->InstanceTemplate()->SetHandler(v8::NamedPropertyHandlerConfiguration(
            [](v8::Local<v8::Name> Property, const v8::PropertyCallbackInfo<v8::Value>& Info)
            {
                if (Property->IsSymbol())
                    return;
                auto InnerIsolate = Info.GetIsolate();
                auto Context = InnerIsolate->GetCurrentContext();
                auto This = Info.This();
                FName RequiredFName(*FV8Utils::ToFString(Info.GetIsolate(), Property));
                auto FixedPropertyName = FV8Utils::ToV8String(InnerIsolate, RequiredFName);
                if (This->GetPrototype()->IsObject())
                {
                    auto Proto = This->GetPrototype().As<v8::Object>();
                    if (Proto->Has(Context, FixedPropertyName).FromMaybe(false))
                    {
                        Info.GetReturnValue().Set(This->Get(Context, FixedPropertyName).ToLocalChecked());
                        auto DescriptorVal = Proto->GetOwnPropertyDescriptor(Context, FixedPropertyName).ToLocalChecked();
                        while (!DescriptorVal->IsObject())
                        {
                            auto Parent = Proto->GetPrototype();
                            if (!Parent->IsObject())
                                break;
                            Proto = Parent.As<v8::Object>();
                            DescriptorVal = Proto->GetOwnPropertyDescriptor(Context, FixedPropertyName).ToLocalChecked();
                        }
                        if (DescriptorVal->IsObject())
                        {
                            auto Descriptor = DescriptorVal.As<v8::Object>();
                            auto Getter = Descriptor->Get(Context, FV8Utils::ToV8String(InnerIsolate, "get")).ToLocalChecked();
                            if (!Getter->IsFunction())
                            {
                                auto Value = Descriptor->Get(Context, FV8Utils::ToV8String(InnerIsolate, "value")).ToLocalChecked();
                                (void) (Proto->Set(Context, Property, Value));
                            }
                            else
                            {
                                Proto->SetAccessorProperty(Property, Getter.As<v8::Function>(),
                                    Descriptor->Get(Context, FV8Utils::ToV8String(InnerIsolate, "set"))
                                        .ToLocalChecked()
                                        .As<v8::Function>());
                            }
                        }
                    }
                }
            },
            [](v8::Local<v8::Name> Property, v8::Local<v8::Value> Value, const v8::PropertyCallbackInfo<v8::Value>& Info)
            {
                if (Property->IsSymbol())
                    return;
                auto InnerIsolate = Info.GetIsolate();
                auto Context = InnerIsolate->GetCurrentContext();
                auto This = Info.This();
                FName RequiredFName(*FV8Utils::ToFString(Info.GetIsolate(), Property));
                auto FixedPropertyName = FV8Utils::ToV8String(InnerIsolate, RequiredFName);
                if (This->GetPrototype()->IsObject())
                {
                    auto Proto = This->GetPrototype().As<v8::Object>();
                    if (Proto->Has(Context, FixedPropertyName).FromMaybe(false))
                    {
                        auto _UnUsed = This->Set(Context, FixedPropertyName, Value);
                        Info.GetReturnValue().Set(Value);
                        auto DescriptorVal = Proto->GetOwnPropertyDescriptor(Context, FixedPropertyName).ToLocalChecked();
                        while (!DescriptorVal->IsObject())
                        {
                            auto Parent = Proto->GetPrototype();
                            if (!Parent->IsObject())
                                break;
                            Proto = Parent.As<v8::Object>();
                            DescriptorVal = Proto->GetOwnPropertyDescriptor(Context, FixedPropertyName).ToLocalChecked();
                        }
                        if (DescriptorVal->IsObject())
                        {
                            auto Descriptor = DescriptorVal.As<v8::Object>();
                            // set first, mush set accessor of object
                            Proto->SetAccessorProperty(Property,
                                Descriptor->Get(Context, FV8Utils::ToV8String(InnerIsolate, "get"))
                                    .ToLocalChecked()
                                    .As<v8::Function>(),
                                Descriptor->Get(Context, FV8Utils::ToV8String(InnerIsolate, "set"))
                                    .ToLocalChecked()
                                    .As<v8::Function>());
                        }
                    }
                }
            },
            nullptr, nullptr, nullptr, v8::Local<v8::Value>(), v8::PropertyHandlerFlags::kNonMasking));
#endif

    return Result;
}
MSVC_PRAGMA(warning(pop))

void FStructWrapper::StaticClass(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
    v8::Isolate* Isolate = Info.GetIsolate();
    v8::Isolate::Scope IsolateScope(Isolate);
    v8::HandleScope HandleScope(Isolate);
    v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
    v8::Context::Scope ContextScope(Context);

    FStructWrapper* This = reinterpret_cast<FStructWrapper*>((v8::Local<v8::External>::Cast(Info.Data()))->Value());

    if (!This->Struct.IsValid())
    {
        FV8Utils::ThrowException(Isolate, "Associated UStruct had been GC");
        return;
    }

    auto Result =
        FV8Utils::IsolateData<IObjectMapper>(Isolate)->FindOrAdd(Isolate, Context, This->Struct->GetClass(), This->Struct.Get());
    Info.GetReturnValue().Set(Result);
}

void FStructWrapper::Find(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
    v8::Isolate* Isolate = Info.GetIsolate();
    v8::Isolate::Scope IsolateScope(Isolate);
    v8::HandleScope HandleScope(Isolate);
    v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
    v8::Context::Scope ContextScope(Context);

    FStructWrapper* This = reinterpret_cast<FStructWrapper*>((v8::Local<v8::External>::Cast(Info.Data()))->Value());

    if (!This->Struct.IsValid())
    {
        FV8Utils::ThrowException(Isolate, "Associated UStruct had been GC");
        return;
    }

    UClass* Class = Cast<UClass>(This->Struct);

    if (Class && Info.Length() >= 1 && Info[0]->IsString())
    {
        UObject* Object = nullptr;
        if (Info.Length() > 1)
        {
            UObject* Outer = FV8Utils::GetUObject(Context, Info[1]);
            Object = StaticFindObject(Class, Outer, *FV8Utils::ToFString(Isolate, Info[0]), false);
        }
        else
        {
#if (ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 1) || ENGINE_MAJOR_VERSION > 5
            Object = StaticFindFirstObject(Class, *FV8Utils::ToFString(Isolate, Info[0]));
#else
            Object = StaticFindObject(Class, ANY_PACKAGE, *FV8Utils::ToFString(Isolate, Info[0]), false);
#endif
        }

        if (Object)
        {
            auto Result = FV8Utils::IsolateData<IObjectMapper>(Isolate)->FindOrAdd(Isolate, Context, Object->GetClass(), Object);
            Info.GetReturnValue().Set(Result);
        }
        else
        {
            Info.GetReturnValue().Set(v8::Undefined(Isolate));
        }
    }
    else
    {
        FV8Utils::ThrowException(Isolate, "invalid argument");
    }
}

void FStructWrapper::Load(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
    v8::Isolate* Isolate = Info.GetIsolate();
    v8::Isolate::Scope IsolateScope(Isolate);
    v8::HandleScope HandleScope(Isolate);
    v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
    v8::Context::Scope ContextScope(Context);

    FStructWrapper* This = reinterpret_cast<FStructWrapper*>((v8::Local<v8::External>::Cast(Info.Data()))->Value());

    if (!This->Struct.IsValid())
    {
        FV8Utils::ThrowException(Isolate, "Associated UStruct had been GC");
        return;
    }

    UClass* Class = Cast<UClass>(This->Struct);

    if (Class && Info.Length() > 0 && Info[0]->IsString())
    {
        bool UnEscape = false;
        if (Info.Length() > 1)
        {
            UnEscape = Info[1]->BooleanValue(Isolate);
        }
        auto Path = FV8Utils::ToFString(Isolate, Info[0]);
        auto Object =
            StaticLoadObject(Class, nullptr, UnEscape ? *TypeScriptVariableNameToFilename(Path) : *Path, nullptr, LOAD_NoWarn);
        if (Object)
        {
            auto Result = FV8Utils::IsolateData<IObjectMapper>(Isolate)->FindOrAdd(Isolate, Context, Object->GetClass(), Object);
            Info.GetReturnValue().Set(Result);
        }
        else
        {
            Info.GetReturnValue().Set(v8::Undefined(Isolate));
        }
    }
    else
    {
        FV8Utils::ThrowException(Isolate, "invalid argument");
    }
}

void FScriptStructWrapper::New(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
    v8::Isolate* Isolate = Info.GetIsolate();
    v8::Isolate::Scope IsolateScope(Isolate);
    v8::HandleScope HandleScope(Isolate);
    v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
    v8::Context::Scope ContextScope(Context);

    FScriptStructWrapper* This = reinterpret_cast<FScriptStructWrapper*>((v8::Local<v8::External>::Cast(Info.Data()))->Value());
    if (!This->Struct.IsValid())
    {
        FV8Utils::ThrowException(Isolate, "Associated UStruct had been GC");
        return;
    }
    This->New(Isolate, Context, Info);
}

void FScriptStructWrapper::New(
    v8::Isolate* Isolate, v8::Local<v8::Context>& Context, const v8::FunctionCallbackInfo<v8::Value>& Info)
{
    if (Info.IsConstructCall())
    {
        auto Self = Info.This();
        void* Memory = nullptr;

        {
            if (ExternalInitialize)
            {
                Memory = ExternalInitialize(Info);
                if (!Memory)    // do not bind nullptr
                {
                    return;
                }
            }
            else
            {
                Memory = Alloc(static_cast<UScriptStruct*>(Struct.Get()));
                const int Count = Info.Length() < Properties.size() ? Info.Length() : Properties.size();
                for (int i = 0; i < Count; ++i)
                {
                    Properties[i]->JsToUEInContainer(Isolate, Context, Info[i], Memory, false);
                }
            }
        }
        FV8Utils::IsolateData<IObjectMapper>(Isolate)->BindStruct(this, Memory, Self, false);
    }
    else
    {
        FV8Utils::ThrowException(Isolate, "only call as Construct is supported!");
    }
}

void* FScriptStructWrapper::Alloc(UScriptStruct* InScriptStruct)
{
    void* ScriptStructMemory = new char[InScriptStruct->GetStructureSize()];
    InScriptStruct->InitializeStruct(ScriptStructMemory);
    return ScriptStructMemory;
}

void FScriptStructWrapper::Free(TWeakObjectPtr<UStruct> InStruct, pesapi_finalize InExternalFinalize, void* Ptr)
{
    if (InExternalFinalize)
    {
        InExternalFinalize(Ptr, nullptr, nullptr);
    }
    else
    {
        if (InStruct.IsValid())
            InStruct->DestroyStruct(Ptr);
        delete[] static_cast<char*>(Ptr);
    }
}

void FScriptStructWrapper::OnGarbageCollectedWithFree(const v8::WeakCallbackInfo<FScriptStructWrapper>& Data)
{
    FScriptStructWrapper* ScriptStructWrapper = Data.GetParameter();
    void* ScriptStructMemory = DataTransfer::MakeAddressWithHighPartOfTwo(Data.GetInternalField(0), Data.GetInternalField(1));
    FV8Utils::IsolateData<IObjectMapper>(Data.GetIsolate())->UnBindStruct(ScriptStructWrapper, ScriptStructMemory);
    Free(ScriptStructWrapper->Struct, ScriptStructWrapper->ExternalFinalize, ScriptStructMemory);
}

void FScriptStructWrapper::OnGarbageCollected(const v8::WeakCallbackInfo<FScriptStructWrapper>& Data)
{
    void* ScriptStructMemory = DataTransfer::MakeAddressWithHighPartOfTwo(Data.GetInternalField(0), Data.GetInternalField(1));
    FV8Utils::IsolateData<IObjectMapper>(Data.GetIsolate())->UnBindStruct(Data.GetParameter(), ScriptStructMemory);
}

void FClassWrapper::OnGarbageCollected(const v8::WeakCallbackInfo<UClass>& Data)
{
    FV8Utils::IsolateData<IObjectMapper>(Data.GetIsolate())
        ->UnBind(Data.GetParameter(), reinterpret_cast<UObject*>(DataTransfer::MakeAddressWithHighPartOfTwo(
                                          Data.GetInternalField(0), Data.GetInternalField(1))));
}

void FClassWrapper::New(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
    v8::Isolate* Isolate = Info.GetIsolate();
    v8::Isolate::Scope IsolateScope(Isolate);
    v8::HandleScope HandleScope(Isolate);
    v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
    v8::Context::Scope ContextScope(Context);

    FClassWrapper* This = reinterpret_cast<FClassWrapper*>((v8::Local<v8::External>::Cast(Info.Data()))->Value());
    if (!This->Struct.IsValid())
    {
        FV8Utils::ThrowException(Isolate, "Associated UStruct had been GC");
        return;
    }
    This->New(Isolate, Context, Info);
}

void FClassWrapper::New(v8::Isolate* Isolate, v8::Local<v8::Context>& Context, const v8::FunctionCallbackInfo<v8::Value>& Info)
{
    if (Info.IsConstructCall())
    {
        auto Self = Info.This();

        UObject* Object = nullptr;
        auto Class = static_cast<UClass*>(Struct.Get());

        {
            UObject* Outer = GetTransientPackage();
            FName Name = NAME_None;
            EObjectFlags ObjectFlags = RF_NoFlags;
            if (Info.Length() > 0)
            {
                Outer = FV8Utils::GetUObject(Context, Info[0]);
                if (FV8Utils::IsReleasedPtr(Outer))
                {
                    FV8Utils::ThrowException(Isolate, "passing a invalid object");
                    return;
                }
            }
            if (Info.Length() > 1)
            {
                Name = FName(*FV8Utils::ToFString(Isolate, Info[1]));
            }
            if (Info.Length() > 2)
            {
                ObjectFlags = (EObjectFlags) (Info[2]->Int32Value(Context).ToChecked());
            }
            Object = NewObject<UObject>(Outer, Class, Name, ObjectFlags);
        }

        FV8Utils::IsolateData<IObjectMapper>(Isolate)->Bind(this, Object, Self);
    }
    else
    {
        FV8Utils::ThrowException(Isolate, "only call as Construct is supported!");
    }
}
}    // namespace PUERTS_NAMESPACE