/*!
 * iOS SDK
 *
 * Tencent is pleased to support the open source community by making
 * Hippy available.
 *
 * Copyright (C) 2019 THL A29 Limited, a Tencent company.
 * All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#import "HippyJSExecutor.h"
#import "HippyJSExecutor+Internal.h"
#import "VFSUriHandler.h"
#import "HippyAssert.h"
#import "HippyBundleURLProvider.h"
#import "HippyDefines.h"
#import "HippyDevInfo.h"
#import "HippyDevMenu.h"
#import "HippyJSEnginesMapper.h"
#import "HippyOCTurboModule+Inner.h"
#import "HippyRedBox.h"
#import "HippyUtils.h"
#import "HippyTurboModuleManager.h"
#import "HippyLog.h"
#import "HippyUtils.h"
#import "HippyFootstoneUtils.h"
#import "NSObject+CtxValue.h"
#import "TypeConverter.h"
#import "HippyBridge+Private.h"
#import "HippyBridge+ModuleManage.h"

#include <cinttypes>
#include <memory>
#include <pthread.h>
#include <string>
#include <unordered_map>

#include "driver/engine.h"
#include "driver/napi/js_ctx.h"
#include "driver/napi/js_ctx_value.h"
#include "driver/napi/js_try_catch.h"
#include "driver/napi/callback_info.h"
#include "driver/vm/js_vm.h"
#include "driver/scope.h"
#include "driver/js_driver_utils.h"
#include "footstone/string_view.h"
#include "footstone/string_view_utils.h"
#include "footstone/task_runner.h"
#include "footstone/task.h"
#include "vfs/handler/uri_handler.h"

#ifdef ENABLE_INSPECTOR
#include "devtools/devtools_data_source.h"
#endif

#ifdef JS_JSC
#include "driver/napi/jsc/jsc_ctx.h"
#include "driver/napi/jsc/jsc_ctx_value.h"
#endif

#ifdef JS_HERMES
#include "driver/napi/hermes/hermes_ctx.h"
#include "driver/napi/hermes/hermes_ctx_value.h"
#endif


using string_view = footstone::stringview::string_view;
using StringViewUtils = footstone::stringview::StringViewUtils;
using SharedCtxPtr = std::shared_ptr<hippy::napi::Ctx>;
using WeakCtxPtr = std::weak_ptr<hippy::napi::Ctx>;
using SharedCtxValuePtr = std::shared_ptr<hippy::napi::CtxValue>;
using WeakCtxValuePtr = std::weak_ptr<hippy::napi::CtxValue>;


constexpr char kGlobalKey[] = "global";
constexpr char kHippyKey[] = "Hippy";
constexpr char kHippyNativeGlobalKey[] = "__HIPPYNATIVEGLOBAL__";
constexpr char kHippyRequireModuleConfigFuncKey[] = "nativeRequireModuleConfig";
constexpr char kHippyFlushQueueImmediateFuncKey[] = "nativeFlushQueueImmediate";
constexpr char kHippyGetTurboModule[] = "getTurboModule";


@interface HippyJSExecutor () {
    // The hippy scope
    std::shared_ptr<hippy::Scope> _pScope;
    
    // Whether js engine is inspectable, currently for jsc
    BOOL _isInspectable;
}

/// Whether JSExecutor has done setup.
@property (nonatomic, assign) BOOL ready;
/// Pending blocks to be executed on JS queue.
@property (nonatomic, strong) NSMutableArray<dispatch_block_t> *pendingCalls;;

@end


@implementation HippyJSExecutor

@synthesize pScope = _pScope;

- (void)setup {
    HippyBridge *bridge = self.bridge;
    const std::string engineType = bridge.usingHermesEngine ? hippy::VM::kJSEngineHermes : hippy::VM::kJSEngineJSC;
    auto engine = [[HippyJSEnginesMapper defaultInstance] createJSEngineResourceForKey:self.enginekey
                                                                            engineType:engineType
                                                                               isDebug:bridge.debugMode];
    const char *pName = [self.enginekey UTF8String] ?: "";
    auto scope = engine->GetEngine()->CreateScope(pName);
    
    // Assign pScope first, then register the callback
    _pScope = scope;
    
    __weak __typeof(self)weakSelf = self;
    if (!bridge.usingHermesEngine) {
        hippy::base::RegisterFunction taskEndCB = [weakSelf](void *) {
                __strong __typeof(weakSelf)strongSelf = weakSelf;
                if (strongSelf) {
                    handleJsExcepiton(strongSelf.pScope);
            }
        };
        scope->RegisterExtraCallback(hippy::kAsyncTaskEndKey, taskEndCB);
    }
    
    dispatch_semaphore_t scopeSemaphore = dispatch_semaphore_create(0);
    footstone::TimePoint startPoint = footstone::TimePoint::SystemNow();
    engine->GetEngine()->GetJsTaskRunner()->PostTask([weakSelf, scopeSemaphore, startPoint](){
        __strong __typeof(weakSelf)strongSelf = weakSelf;
        HippyBridge *bridge = strongSelf.bridge;
        if (!bridge) {
            return;
        }
        
        dispatch_semaphore_wait(scopeSemaphore, DISPATCH_TIME_FOREVER);
        auto scope = strongSelf.pScope;
        scope->CreateContext();
        auto context = scope->GetContext();
        auto global_object = context->GetGlobalObject();
            
#if defined(ENABLE_INSPECTOR) && defined(JS_HERMES)
        // setup debugger agent for hermes
        setupDebuggerAgent(bridge, context, weakSelf);
#endif /* defined(ENABLE_INSPECTOR) && defined(JS_HERMES) */
        
        
        // add `global` property to global object
        auto user_global_object_key = context->CreateString(kGlobalKey);
        context->SetProperty(global_object, user_global_object_key, global_object);
        
        // add `Hippy` property to global object
        auto hippy_key = context->CreateString(kHippyKey);
        context->SetProperty(global_object, hippy_key, context->CreateObject());
        
        // inject device info to `__HIPPYNATIVEGLOBAL__`
        [strongSelf injectDeviceInfoAsHippyNativeGlobal:bridge context:context globalObject:global_object];
        
        // register `nativeRequireModuleConfig` function
        [strongSelf registerRequiredModuleConfigFuncToJS:context globalObject:global_object scope:scope];
        
        // register `nativeFlushQueueImmediate` function
        [strongSelf registerFlushQueueImmediateFuncToJS:context globalObject:global_object scope:scope];
        
        // register `getTurboModule` function
        [strongSelf registerGetTurboModuleFuncToJS:context globalObject:global_object scope:scope];
        
        // call finish block
        if (strongSelf.contextCreatedBlock) {
            strongSelf.contextCreatedBlock();
        }
        scope->SyncInitialize();
        
        // performance record
        footstone::TimePoint endTime = footstone::TimePoint::SystemNow();
        auto entry = scope->GetPerformance()->PerformanceNavigation(hippy::kPerfNavigationHippyInit);
        if (entry) {
            entry->SetHippyJsEngineInitStart(startPoint);
            entry->SetHippyJsEngineInitEnd(endTime);
            entry->SetHippyNativeInitStart(strongSelf.bridge.startTime);
            entry->SetHippyNativeInitEnd(endTime);
        }
        
        // the last, execute pending blocks
        NSArray<dispatch_block_t> *pendingCalls;
        @synchronized (strongSelf) {
            strongSelf.ready = YES;
            pendingCalls = [strongSelf.pendingCalls copy];
            [strongSelf.pendingCalls removeAllObjects];
        }
        [pendingCalls enumerateObjectsUsingBlock:^(dispatch_block_t  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
            [strongSelf executeBlockOnJavaScriptQueue:obj];
        }];
    });
    dispatch_semaphore_signal(scopeSemaphore);
    
#ifdef ENABLE_INSPECTOR
    [self executeAsyncBlockOnJavaScriptQueue:^{
        __strong __typeof(weakSelf)strongSelf = weakSelf;
        HippyBridge *bridge = strongSelf.bridge;
        if (!bridge) {
            return;
        }
        if (bridge && bridge.debugMode) {
            NSString *wsURL = [strongSelf completeWSURLWithBridge:bridge];
            auto scope = strongSelf->_pScope;
            if (wsURL.length > 0 && scope) {
                auto engine = scope->GetEngine().lock();
                if (!engine) {
                    return;
                }
                auto workerManager = std::make_shared<footstone::WorkerManager>(1);
            	auto devtools_data_source = std::make_shared<hippy::devtools::DevtoolsDataSource>();
		        devtools_data_source->CreateDevtoolsService([wsURL UTF8String], workerManager);
                if (bridge.usingHermesEngine) {
                    // InitDevTools will bind devtools_data_source to scope
                    hippy::JsDriverUtils::InitDevTools(scope, engine->GetVM(), devtools_data_source);
                } else {
                    scope->SetDevtoolsDataSource(devtools_data_source);
                }
            }
        }
    }];
#endif
}

- (instancetype)initWithEngineKey:(NSString *)engineKey bridge:(HippyBridge *)bridge {
    NSParameterAssert(engineKey.length > 0);
    if (self = [super init]) {
        _valid = YES;
        _ready = NO;
        _enginekey = engineKey;
        _bridge = bridge;
        _pendingCalls = [NSMutableArray array];
        HippyLogInfo(@"[Hippy_OC_Log][Life_Circle],HippyJSCExecutor Init %p, engineKey:%@", self, engineKey);
    }
    return self;
}

- (void)dealloc {
    HippyLogInfo(@"[Hippy_OC_Log][Life_Circle],HippyJSCExecutor dealloc %p", self);
    [self invalidate];
}

- (void)invalidate {
    if (!self.isValid) {
        return;
    }
    _valid = NO;
    HippyLogInfo(@"[Hippy_OC_Log][Life_Circle],HippyJSCExecutor invalide %p", self);
    
#ifdef ENABLE_INSPECTOR
    auto devtools_data_source = self.pScope->GetDevtoolsDataSource();
    if (devtools_data_source) {
        HippyBridge *bridge = self.bridge; // Note: bridge may be nil
        bool reload = (bridge && bridge.invalidateReason == HippyInvalidateReasonReload) ? true : false;
        devtools_data_source->Destroy(reload);
    }
#endif /* ENABLE_INSPECTOR */

    self.pScope->WillExit();
    _pScope = nullptr;
    NSString *enginekey = self.enginekey;
    if (!enginekey) {
        return;
    }
    dispatch_async(dispatch_get_main_queue(), ^{
        auto engineRsc = [[HippyJSEnginesMapper defaultInstance] JSEngineResourceForKey:enginekey];
        [[HippyJSEnginesMapper defaultInstance] removeEngineResourceForKey:enginekey];
        dispatch_async(dispatch_get_main_queue(), ^{
            // Make a tiny delay to ensure the engine resource is released on the main thread
            HippyLogInfo(@"Remove EngineRsc, UseCount:%ld", engineRsc.use_count());
        });
    });
}


#pragma mark - Subprocedures of Setup

#if defined(ENABLE_INSPECTOR) && defined(JS_HERMES)
static void setupDebuggerAgent(HippyBridge *bridge, const std::shared_ptr<hippy::Ctx> &context, HippyJSExecutor *const __weak weakSelf) {
    if (bridge.debugMode && bridge.usingHermesEngine) {
        // Create cdp agent for hermes
        auto hermesCtx = std::static_pointer_cast<hippy::HermesCtx>(context);
        hermesCtx->SetupDebugAgent([weakSelf](facebook::hermes::debugger::RuntimeTask fn) {
            __strong __typeof(weakSelf)strongSelf = weakSelf;
            auto scope = strongSelf.pScope;
            if (scope && scope->GetTaskRunner() && scope->GetContext()) {
                auto hermes_ctx = std::static_pointer_cast<hippy::HermesCtx>(scope->GetContext());
                scope->GetTaskRunner()->PostTask(^{
                    fn(*hermes_ctx->GetRuntime());
                });
            }
        }, [weakSelf](const std::string &message) {
            // Process CDP response or event and send message back to the Chrome debugger
            // HippyLogTrace(@"To Debugger: %s\n", message.c_str());
            __strong __typeof(weakSelf)strongSelf = weakSelf;
            auto scope = strongSelf.pScope;
            if (scope) {
                auto devtoolsDataSource = scope->GetDevtoolsDataSource();
                if (devtoolsDataSource) {
                    devtoolsDataSource->GetNotificationCenter()->vm_response_notification->ResponseToFrontend(message);
                };
            }
        });
    }
}
#endif /* defined(ENABLE_INSPECTOR) && defined(JS_HERMES) */

- (void)injectDeviceInfoAsHippyNativeGlobal:(HippyBridge *)bridge 
                                    context:(const std::shared_ptr<hippy::Ctx> &)context
                               globalObject:(const std::shared_ptr<hippy::CtxValue> &)globalObject {
    NSMutableDictionary *deviceInfo = [NSMutableDictionary dictionaryWithDictionary:[bridge deviceInfo]];
    NSDictionary *debugInfo = @{@"Debug" : @{@"debugClientId" : [self getClientID]}};
    [deviceInfo addEntriesFromDictionary:debugInfo];
    
    auto key = context->CreateString(kHippyNativeGlobalKey);
    auto value = [deviceInfo convertToCtxValue:context];
    if (key && value) {
        context->SetProperty(globalObject, key, value);
    }
}

- (void)registerRequiredModuleConfigFuncToJS:(const std::shared_ptr<hippy::Ctx> &)context
                                globalObject:(const std::shared_ptr<hippy::CtxValue> &)globalObject
                                       scope:(const std::shared_ptr<hippy::Scope> &)scope {
    __weak __typeof(self)weakSelf = self;
    auto requireModuleConfigFunWrapper = std::make_unique<hippy::FunctionWrapper>([](hippy::CallbackInfo& info, void* data) {
        HippyJSExecutor *strongSelf = (__bridge HippyJSExecutor*)data;
        HippyBridge *bridge = strongSelf.bridge;
        if (!strongSelf.valid || !bridge || !strongSelf.pScope) {
            return;
        }
        
        const auto &context = strongSelf.pScope->GetContext();
        if (context->IsString(info[0])) {
            NSString *moduleName = ObjectFromCtxValue(context, info[0]);
            if (moduleName) {
                NSArray *result = [bridge configForModuleName:moduleName];
                info.GetReturnValue()->Set([HippyNullIfNil(result) convertToCtxValue:context]);
            }
        }
    }, (__bridge void*)weakSelf);
    auto requireModuleConfigFunction = context->CreateFunction(requireModuleConfigFunWrapper);
    scope->SaveFunctionWrapper(std::move(requireModuleConfigFunWrapper));
    context->SetProperty(globalObject, context->CreateString(kHippyRequireModuleConfigFuncKey), requireModuleConfigFunction);
}

- (void)registerFlushQueueImmediateFuncToJS:(const std::shared_ptr<hippy::Ctx> &)context
                               globalObject:(const std::shared_ptr<hippy::CtxValue> &)globalObject
                                      scope:(const std::shared_ptr<hippy::Scope> &)scope {
    __weak __typeof(self)weakSelf = self;
    auto nativeFlushQueueFunWrapper = std::make_unique<hippy::FunctionWrapper>([](hippy::CallbackInfo& info, void* data) {
        HippyJSExecutor *strongSelf = (__bridge HippyJSExecutor*)data;
        HippyBridge *bridge = strongSelf.bridge;
        if (!strongSelf.valid || !bridge || !strongSelf.pScope) {
            return;
        }
        
        const auto &context = strongSelf.pScope->GetContext();
        if (context->IsArray(info[0])) {
            NSArray *calls = ObjectFromCtxValue(context, info[0]);
            [bridge handleBuffer:calls batchEnded:NO];
        }
    }, (__bridge void*)weakSelf);
    auto nativeFlushQueueFunction = context->CreateFunction(nativeFlushQueueFunWrapper);
    scope->SaveFunctionWrapper(std::move(nativeFlushQueueFunWrapper));
    context->SetProperty(globalObject, context->CreateString(kHippyFlushQueueImmediateFuncKey), nativeFlushQueueFunction);
}

- (void)registerGetTurboModuleFuncToJS:(const std::shared_ptr<hippy::Ctx> &)context
                          globalObject:(const std::shared_ptr<hippy::CtxValue> &)globalObject
                                 scope:(const std::shared_ptr<hippy::Scope> &)scope {
    __weak __typeof(self)weakSelf = self;
    auto turbo_wrapper = std::make_unique<hippy::FunctionWrapper>([](hippy::CallbackInfo& info, void* data) {
        HippyJSExecutor *strongSelf = (__bridge HippyJSExecutor*)data;
        if (!strongSelf || !strongSelf.pScope) {
            return;
        }
        const auto &context = strongSelf.pScope->GetContext();
        if (context->IsString(info[0])) {
            NSString *name = ObjectFromCtxValue(context, info[0]);
            auto value = [strongSelf JSTurboObjectWithName:name];
            info.GetReturnValue()->Set(value);
        }
    }, (__bridge void*)weakSelf);
    auto turbo_function = context->CreateFunction(turbo_wrapper);
    scope->SaveFunctionWrapper(std::move(turbo_wrapper));
    context->SetProperty(globalObject, context->CreateString(kHippyGetTurboModule), turbo_function);
}


#pragma mark -

- (NSString *)getClientID {
    NSString *deviceName = [[UIDevice currentDevice] name];
    NSString *clientId = HippyMD5Hash([NSString stringWithFormat:@"%@%p", deviceName, self]);
    return clientId;
}

- (void)setUriLoader:(std::weak_ptr<hippy::vfs::UriLoader>)uriLoader {
    if (self.pScope->GetUriLoader().lock() != uriLoader.lock()) {
        self.pScope->SetUriLoader(uriLoader);
    }
}

- (void)setSandboxDirectory:(NSString *)directory {
    if (directory) {
        __weak HippyJSExecutor *weakSelf = self;
        [self executeBlockOnJavaScriptQueue:^{
            HippyJSExecutor *strongSelf = weakSelf;
            if (!strongSelf) {
                return;
            }
            HippyAssert(strongSelf.pScope, @"scope must not be null");
            HippyAssert(strongSelf.pScope->GetContext(), @"context must not be null");
            auto context = strongSelf.pScope->GetContext();
            auto global_object = context->GetGlobalObject();
            auto key = context->CreateString("__HIPPYCURDIR__");
            auto value = context->CreateString(NSStringToU8StringView(directory));
            context->SetProperty(global_object, key, value);
        }];
    }
}

- (SharedCtxValuePtr)JSTurboObjectWithName:(NSString *)name {
    // create HostObject by name
    HippyBridge *bridge = self.bridge;
    HippyOCTurboModule *turboModule = [bridge turboModuleWithName:name];
    auto scope = self.pScope;
    auto context = scope->GetContext();
    if (!turboModule) {
        return context->CreateNull();
    }

    // create jsProxy
    std::string turbo_name([name UTF8String]);
    if (scope->HasTurboInstance(turbo_name)) {
        return scope->GetTurboInstance(turbo_name);
    }
    
    CFTypeRef retainedTurboModule = CFBridgingRetain(turboModule);
    auto wrapper = std::make_unique<hippy::FunctionWrapper>([](hippy::CallbackInfo& info, void* data) {
        auto name = info[0];
        if (!name) {
            CFRelease(data);
            return;
        }
        HippyOCTurboModule *turbo = (__bridge HippyOCTurboModule*)data;
        auto turbo_wrapper = std::make_unique<TurboWrapper>(turbo, info[0]);
        auto func_wrapper = std::make_unique<hippy::FunctionWrapper>([](hippy::CallbackInfo& info, void* data) {
            std::vector<std::shared_ptr<hippy::CtxValue>> argv;
            for (size_t i = 0; i < info.Length(); ++i) {
                argv.push_back(info[i]);
            }
        std::any slot_any = info.GetSlot();
        auto any_pointer = std::any_cast<void*>(&slot_any);
        auto scope_wrapper = reinterpret_cast<hippy::ScopeWrapper*>(static_cast<void *>(*any_pointer));
            auto scope = scope_wrapper->scope.lock();
            FOOTSTONE_CHECK(scope);
            auto turbo_wrapper = reinterpret_cast<TurboWrapper*>(data);
            HippyOCTurboModule *turbo = turbo_wrapper->module;
            auto name = turbo_wrapper->name;
            auto result = [turbo invokeOCMethod:scope->GetContext() this_val:name args:argv.data() count:argv.size()];
            info.GetReturnValue()->Set(result);
        }, turbo_wrapper.get());
        [turbo saveTurboWrapper:name turbo:std::move(turbo_wrapper)];
      std::any slot_any = info.GetSlot();
      auto any_pointer = std::any_cast<void*>(&slot_any);
      auto scope_wrapper = reinterpret_cast<hippy::ScopeWrapper*>(static_cast<void *>(*any_pointer));
        auto scope = scope_wrapper->scope.lock();
        FOOTSTONE_CHECK(scope);
        auto func = scope->GetContext()->CreateFunction(func_wrapper);
        scope->SaveFunctionWrapper(std::move(func_wrapper));
        info.GetReturnValue()->Set(func);
        CFRelease(data);
    }, (void *)retainedTurboModule);
    
#ifdef JS_HERMES
    // Save function wrapper
    if (bridge.usingHermesEngine) {
        auto proxy = scope->GetContext()->DefineProxy(nullptr);
        auto handler = scope->GetContext()->DefineProxyHandler(wrapper);
        auto proxy_ctx = std::static_pointer_cast<hippy::driver::napi::HermesCtxValue>(proxy);
        auto handler_ctx = std::static_pointer_cast<hippy::driver::napi::HermesCtxValue>(handler);
        auto& runtime = std::static_pointer_cast<hippy::driver::napi::HermesCtx>(scope->GetContext())->GetRuntime();
        auto constructor = proxy_ctx->GetValue(runtime).asObject(*runtime).asFunction(*runtime);
        auto instance = constructor.callAsConstructor(*runtime, { handler_ctx->GetValue(runtime) });
        auto obj = std::make_shared<hippy::driver::napi::HermesCtxValue>(*runtime, instance);
        scope->SaveFunctionWrapper(std::move(wrapper));
        scope->SetTurboInstance(turbo_name, obj);
        return obj;
    } else {
      auto obj = scope->GetContext()->DefineProxy(wrapper);
      scope->SaveFunctionWrapper(std::move(wrapper));
      scope->SetTurboInstance(turbo_name, obj);
      return obj;
    }
#else
  auto obj = scope->GetContext()->DefineProxy(wrapper);
  scope->SaveFunctionWrapper(std::move(wrapper));
  scope->SetTurboInstance(turbo_name, obj);
  return obj;
#endif /* JS_HERMES */
}

- (void)setContextName:(NSString *)contextName {
#ifdef JS_JSC
#ifdef JS_HERMES
    // SetContextName not support Hermes now
    if (self.bridge.usingHermesEngine) {
        return;
    }
#endif /* JS_HERMES */
    if (!contextName) {
        return;
    }
    __weak __typeof(self)weakSelf = self;
    [self executeBlockOnJavaScriptQueue:^{
        __strong __typeof(weakSelf)strongSelf = weakSelf;
        if (!strongSelf || !strongSelf.pScope || !strongSelf.pScope->isValid()) {
            return;
        }
        SharedCtxPtr context = strongSelf.pScope->GetContext();
        if (!context) {
            return;
        }
        auto tryCatch = hippy::TryCatch::CreateTryCatchScope(true, context);
        auto jscContext = std::static_pointer_cast<hippy::napi::JSCCtx>(context);
        NSString *finalName = [NSString stringWithFormat:@"HippyContext: %@", contextName];
        jscContext->SetName((__bridge CFStringRef)finalName);
        if (tryCatch->HasCaught()) {
            HippyLogError(@"Exception while setting Context Name!");
        }
    }];
#endif //JS_JSC
}

- (void)setInspecable:(BOOL)inspectable {
#ifdef JS_HERMES
    // judge js engine type
    if (self.bridge.usingHermesEngine) {
        return;
    }
#endif /* JS_HERMES */
    
#ifdef JS_JSC
    _isInspectable = inspectable;
#if defined(__IPHONE_16_4) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_16_4
    if (@available(iOS 16.4, *)) {
        WeakCtxPtr weak_ctx = self.pScope->GetContext();
        [self executeBlockOnJavaScriptQueue:^{
            SharedCtxPtr context = weak_ctx.lock();
            if (!context) {
                return;
            }
            auto jsc_context = std::static_pointer_cast<hippy::napi::JSCCtx>(context);
            JSGlobalContextRef contextRef = jsc_context->context_;
            JSGlobalContextSetInspectable(contextRef, inspectable);
        }];
    }
#endif //defined(__IPHONE_16_4) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_16_4
#endif //JS_JSC
}

- (void)updateNativeInfoToHippyGlobalObject:(NSDictionary *)updatedInfoDict {
    if (updatedInfoDict.count <= 0){
        return;
    }
    __weak __typeof(self)weakSelf = self;
    [self executeBlockOnJavaScriptQueue:^{
        __strong __typeof(weakSelf)strongSelf = weakSelf;
        if (!strongSelf || !strongSelf.isValid || nullptr == strongSelf.pScope) {
            return;
        }
        [strongSelf addInfoToGlobalObject:updatedInfoDict.copy];
    }];
}

- (void)addInfoToGlobalObject:(NSDictionary*)addInfoDict{
    string_view str(kHippyNativeGlobalKey);
    auto context = self.pScope->GetContext();
    auto global_object = context->GetGlobalObject();
    auto hippy_native_object_key = context->CreateString(str);
    auto hippy_native_object_value = context->GetProperty(global_object, hippy_native_object_key);
    HippyAssert(hippy_native_object_value, @"__HIPPYNATIVEGLOBAL__ must not be null");
    if (!context->IsNullOrUndefined(hippy_native_object_value)) {
        for (NSString *key in addInfoDict) {
            id value = addInfoDict[key];
            string_view key_string = NSStringToU8StringView(key);
            auto ctx_value = [value convertToCtxValue:context];
            context->SetProperty(hippy_native_object_value, context->CreateString(key_string), ctx_value, hippy::napi::PropertyAttribute::None);
        }
    }
}

- (void)flushedQueue:(HippyJavaScriptCallback)onComplete {
    [self _executeJSCall:@"flushedQueue" arguments:@[] callback:onComplete];
}

- (void)_callFunctionOnModule:(NSString *)module
                       method:(NSString *)method
                    arguments:(NSArray *)args
                     callback:(HippyJavaScriptCallback)onComplete {
    static NSString *bridgeMethod = @"callFunctionReturnFlushedQueue";
    [self _executeJSCall:bridgeMethod arguments:@[module, method, args] callback:onComplete];
}

- (void)callFunctionOnModule:(NSString *)module method:(NSString *)method arguments:(NSArray *)args callback:(HippyJavaScriptCallback)onComplete {
    [self _callFunctionOnModule:module method:method arguments:args callback:onComplete];
}

- (void)invokeCallbackID:(NSNumber *)cbID arguments:(NSArray *)args callback:(HippyJavaScriptCallback)onComplete {
    [self _executeJSCall:@"invokeCallbackAndReturnFlushedQueue" arguments:@[cbID, args] callback:onComplete];
}

- (void)_executeJSCall:(NSString *)method
             arguments:(NSArray *)arguments
              callback:(HippyJavaScriptCallback)onComplete {
    HippyAssert(onComplete != nil, @"onComplete block should not be nil");
    __weak HippyJSExecutor *weakSelf = self;
    [self executeBlockOnJavaScriptQueue:^{
        HippyJSExecutor *strongSelf = weakSelf;
        if (!strongSelf || !strongSelf.isValid || nullptr == strongSelf.pScope) {
            return;
        }
        @try {
            HippyBridge *bridge = [strongSelf bridge];
            NSString *moduleName = [bridge moduleName];
            NSError *executeError = nil;
            id objcValue = nil;
            auto context = strongSelf.pScope->GetContext();
            auto global_object = context->GetGlobalObject();
            auto bridge_key = context->CreateString("__hpBatchedBridge");
            auto batchedbridge_value = context->GetProperty(global_object, bridge_key);
            SharedCtxValuePtr resultValue = nullptr;
            string_view exception;
            if (batchedbridge_value) {
                string_view methodName = NSStringToU8StringView(method);
                SharedCtxValuePtr method_value = context->GetProperty(batchedbridge_value, methodName);
                if (method_value) {
                    if (context->IsFunction(method_value)) {
                        std::vector<SharedCtxValuePtr> function_params(arguments.count);
                        for (NSUInteger i = 0; i < arguments.count; i++) {
                            id obj = arguments[i];
                            function_params[i] = [obj convertToCtxValue:context];
                        }
                        auto tryCatch = hippy::TryCatch::CreateTryCatchScope(true, context);
                        resultValue = context->CallFunction(method_value, context->GetGlobalObject(), arguments.count, function_params.data());
                        if (tryCatch->HasCaught()) {
                            exception = tryCatch->GetExceptionMessage();
                        }
                    } else {
                        NSString *errMsg = [NSString stringWithFormat:@"%@ is not a function", method];
                        executeError = HippyErrorWithMessageAndModuleName(errMsg, moduleName);
                    }
                } else {
                    NSString *errMsg = [NSString stringWithFormat:@"property/function %@ not found in __hpBatchedBridge", method];
                    executeError = HippyErrorWithMessageAndModuleName(errMsg, moduleName);
                }
            } else {
                executeError = HippyErrorWithMessageAndModuleName(@"__hpBatchedBridge not found", moduleName);
            }
            if (!StringViewUtils::IsEmpty(exception) || executeError) {
                if (!StringViewUtils::IsEmpty(exception)) {
                    NSString *string = StringViewToNSString(exception);
                    executeError = HippyErrorWithMessageAndModuleName(string, moduleName);
                }
            } else if (resultValue) {
                objcValue = ObjectFromCtxValue(context, resultValue);
            }
            onComplete(objcValue, executeError);
        } @catch (NSException *exception) {
            NSString *moduleName = strongSelf.bridge.moduleName?:@"unknown";
            NSMutableDictionary *userInfo = [exception.userInfo mutableCopy]?:[NSMutableDictionary dictionary];
            [userInfo setObject:moduleName forKey:HippyFatalModuleName];
            [userInfo setObject:arguments?:[NSArray array] forKey:@"arguments"];
            NSException *reportException = [NSException exceptionWithName:exception.name reason:exception.reason userInfo:userInfo];
            HippyHandleException(reportException);
        }
    }];
}

- (void)executeApplicationScript:(NSData *)script sourceURL:(NSURL *)sourceURL onComplete:(HippyJavaScriptCallback)onComplete {
    HippyAssertParam(script);
    HippyAssertParam(sourceURL);
    __weak HippyJSExecutor* weakSelf = self;
    [self executeBlockOnJavaScriptQueue:^{
        HippyJSExecutor *strongSelf = weakSelf;
        if (!strongSelf || !strongSelf.isValid) {
            onComplete(nil, HippyErrorWithMessageAndModuleName(@"jsexecutor is not invalid", strongSelf.bridge.moduleName));
            return;
        }
        NSError *error = nil;
        auto entry = strongSelf.pScope->GetPerformance()->PerformanceNavigation(hippy::kPerfNavigationHippyInit);
        string_view url = [[sourceURL absoluteString] UTF8String]?:"";
        entry->BundleInfoOfUrl(url).execute_source_start_ = footstone::TimePoint::SystemNow();
        id result = executeApplicationScript(script,
                                             sourceURL,
                                             strongSelf.pScope->GetContext(),
                                             &error);
        entry->BundleInfoOfUrl(url).execute_source_end_ = footstone::TimePoint::SystemNow();
        if (onComplete) {
            onComplete(result, error);
        }
    }];
}

static NSError *executeApplicationScript(NSData *script, 
                                         NSURL *sourceURL,
                                         SharedCtxPtr context,
                                         __strong NSError **error) {
    const char *scriptBytes = reinterpret_cast<const char *>([script bytes]);
    string_view view = string_view::new_from_utf8(scriptBytes, [script length]);
    string_view fileName = NSStringToU16StringView([sourceURL absoluteString]);
    string_view errorMsg;
    
    auto tryCatch = hippy::TryCatch::CreateTryCatchScope(true, context);
    SharedCtxValuePtr result = context->RunScript(view, fileName);
    if (tryCatch->HasCaught()) {
        errorMsg = std::move(tryCatch->GetExceptionMessage());
    }
    
    *error = !StringViewUtils::IsEmpty(errorMsg) ? [NSError errorWithDomain:HippyErrorDomain code:2 userInfo:@{
        NSLocalizedDescriptionKey: StringViewToNSString(errorMsg)}] : nil;
    id objcResult = ObjectFromCtxValue(context, result);
    return objcResult;
}

- (void)executeBlockOnJavaScriptQueue:(dispatch_block_t)block {
    @synchronized (self) {
        if (!self.ready) {
            [self.pendingCalls addObject:block];
            return;
        }
    }
    auto engineRsc = [[HippyJSEnginesMapper defaultInstance] JSEngineResourceForKey:self.enginekey];
    if (!engineRsc) {
        return;
    }
    auto engine = engineRsc->GetEngine();
    if (engine) {
        auto runner = engine->GetJsTaskRunner();
        if (footstone::Worker::IsTaskRunning() && runner == footstone::runner::TaskRunner::GetCurrentTaskRunner()) {
            block();
        } else if (runner) {
            runner->PostTask(block);
        }
    }
}

- (void)executeAsyncBlockOnJavaScriptQueue:(dispatch_block_t)block {
    @synchronized (self) {
        if (!self.ready) {
            [self.pendingCalls addObject:block];
            return;
        }
    }
    auto engineRsc = [[HippyJSEnginesMapper defaultInstance] JSEngineResourceForKey:self.enginekey];
    if (!engineRsc) {
        return;
    }
    auto engine = engineRsc->GetEngine();
    if (engine) {
        auto runner = engine->GetJsTaskRunner();
        if (runner) {
            runner->PostTask(block);
        }
    }
}

- (void)injectObjectSync:(NSObject *)value asGlobalObjectNamed:(NSString *)objectName callback:(HippyJavaScriptCallback)onComplete {
    if (!objectName || !value) {
        if (onComplete) {
            NSError *error = HippyErrorWithMessage(@"Inject param invalid");
            onComplete(@(NO), error);
        }
        return;
    }
    if (!self.isValid || !self.pScope) {
        return;
    }
    auto context = self.pScope->GetContext();
    auto tryCatch = hippy::TryCatch::CreateTryCatchScope(true, context);
    auto globalObject = context->GetGlobalObject();
    auto nameKey = context->CreateString(objectName.UTF8String);
    auto ctxValue = [value convertToCtxValue:context];
    if (nameKey && ctxValue) {
        context->SetProperty(globalObject, nameKey, [value convertToCtxValue:context]);
    } else {
        HippyLogError(@"Convert Error while inject:%@ for:%@", value, objectName);
    }
    if (tryCatch && tryCatch->HasCaught()) {
        NSString *errorMsg = StringViewToNSString(tryCatch->GetExceptionMessage());
        NSError *error = HippyErrorWithMessage(errorMsg);
        if (onComplete) {
            onComplete(@(NO), error);
        } else {
            HippyLogError(@"Error(%@) while inject:%@ for:%@", errorMsg, value, objectName);
        }
    } else if (onComplete) {
        onComplete(@(YES), nil);
    }
}

- (void)injectObjectAsync:(NSObject *)value asGlobalObjectNamed:(NSString *)objectName callback:(HippyJavaScriptCallback)onComplete {
    __weak __typeof(self)weakSelf = self;
    [self executeBlockOnJavaScriptQueue:^{
        __strong __typeof(weakSelf)strongSelf = weakSelf;
        if (!strongSelf || !strongSelf.isValid) {
            return;
        }
        [strongSelf injectObjectSync:value asGlobalObjectNamed:objectName callback:onComplete];
    }];
}

- (NSString *)completeWSURLWithBridge:(HippyBridge *)bridge {
    if ([bridge.delegate respondsToSelector:@selector(shouldStartInspector:)] &&
        [bridge.delegate shouldStartInspector:bridge] == NO) {
        return @"";
    }
    HippyDevInfo *devInfo = [[HippyDevInfo alloc] init];
    if ([bridge.delegate respondsToSelector:@selector(inspectorSourceURLForBridge:)]) {
        NSURL *debugURL = [bridge.delegate inspectorSourceURLForBridge:bridge];
        devInfo.scheme = [debugURL scheme];
        devInfo.ipAddress = [debugURL host];
        devInfo.port = [NSString stringWithFormat:@"%@", [debugURL port]];
        devInfo.versionId = [HippyBundleURLProvider parseVersionId:[debugURL path]];
        [devInfo parseWsURLWithURLQuery:[debugURL query]];
    } else {
        HippyBundleURLProvider *bundleURLProvider = [HippyBundleURLProvider sharedInstance];
        devInfo.scheme = bundleURLProvider.scheme;
        devInfo.ipAddress = bundleURLProvider.localhostIP;
        devInfo.port = bundleURLProvider.localhostPort;
        devInfo.versionId = bundleURLProvider.versionId;
        devInfo.wsURL = bundleURLProvider.wsURL;
    }
    return [devInfo assembleFullWSURLWithClientId:[self getClientID]
                                      contextName:bridge.contextName
                                   isHermesEngine:bridge.usingHermesEngine];
}


#pragma mark - Exception Handle

static void handleJsExcepiton(std::shared_ptr<hippy::Scope> scope) {
    if (!scope) {
        return;
    }
#ifdef JS_JSC
    auto context = std::dynamic_pointer_cast<hippy::napi::JSCCtx>(scope->GetContext());
    if (!context) {
        HippyLogError(@"[Hippy_OC_Log][HippyJSExecutor], handleJsExcepiton: scope context is not JSCCtx type!");
        return;
    }
    auto exception = std::dynamic_pointer_cast<hippy::napi::JSCCtxValue>(context->GetException());
    if (exception) {
        // if native does not handled, rethrow to js
        if (!context->IsExceptionHandled()) {
            constexpr char kHippyExceptionEventName[] = "uncaughtException";
            hippy::vm::VM::HandleException(context, kHippyExceptionEventName, exception);
        }
        string_view exceptionStrView = context->GetExceptionMessage(exception);
        auto errU8Str = StringViewUtils::ConvertEncoding(exceptionStrView, string_view::Encoding::Utf8).utf8_value();
        std::string errStr = StringViewUtils::ToStdString(errU8Str);
        NSError *error = HippyErrorWithMessage([NSString stringWithUTF8String:errStr.c_str()]);
        HippyFatal(error);
        context->SetException(nullptr);
        context->SetExceptionHandled(true);
    }
#endif /* JS_JSC */
}


@end