V8ResourceImpl.cpp

#include "cpp-sdk/objects/IPlayer.h"
#include "cpp-sdk/objects/IVehicle.h"

#include "V8ResourceImpl.h"

#ifdef ALT_SERVER_API
    #include "CNodeResourceImpl.h"
    #include "CNodeScriptRuntime.h"
    #include "node.h"
#endif

#ifdef ALT_CLIENT_API
    #include "CV8ScriptRuntime.h"
#endif

using namespace alt;

extern V8Class v8Vector3, v8Vector2, v8RGBA, v8BaseObject, v8Quaternion;
bool V8ResourceImpl::Start()
{
    vector3Class.Reset(isolate, v8Vector3.JSValue(isolate, GetContext()));
    vector2Class.Reset(isolate, v8Vector2.JSValue(isolate, GetContext()));
    quaternionClass.Reset(isolate, v8Quaternion.JSValue(isolate, GetContext()));
    rgbaClass.Reset(isolate, v8RGBA.JSValue(isolate, GetContext()));
    baseObjectClass.Reset(isolate, v8BaseObject.JSValue(isolate, GetContext()));

    return true;
}

bool V8ResourceImpl::Stop()
{
    {
        for(auto& handler : localHandlers)
        {
            alt::CEvent::Type type = V8Helpers::EventHandler::GetTypeForEventName(handler.first);
            if(type != alt::CEvent::Type::NONE) IRuntimeEventHandler::Instance().EventHandlerRemoved(type);
        }
    }

    for(auto pair : timers)
    {
        delete pair.second;
    }
    timers.clear();
    for(auto ent : entities)
    {
        delete ent.second;
    }
    entities.clear();
    oldTimers.clear();
    resourceObjects.clear();
    nextTickCallbacks.clear();
    benchmarkTimers.clear();

    localHandlers.clear();
    remoteHandlers.clear();
    localGenericHandlers.clear();
    remoteGenericHandlers.clear();

    players.Reset();
    vehicles.Reset();
    vector3Class.Reset();
    vector2Class.Reset();
    quaternionClass.Reset();
    rgbaClass.Reset();
    baseObjectClass.Reset();
    objects.Reset();

    context.Reset();

    return true;
}

void V8ResourceImpl::OnTick()
{
    for(auto& nextTickCb : nextTickCallbacks) nextTickCb();
    nextTickCallbacks.clear();

    for(auto& id : oldTimers)
    {
        auto it = timers.find(id);
        if(it == timers.end())
            continue;

        auto timer = it->second;
        timers.erase(it);
        delete timer;
    }

    oldTimers.clear();

    for(auto& p : timers)
    {
        if(std::find(oldTimers.begin(), oldTimers.end(), p.first) != oldTimers.end()) continue;
        int64_t time = GetTime();
        if(!p.second->Update(time)) RemoveTimer(p.first);

        if(GetTime() - time > 50)
        {
            auto& location = p.second->GetLocation();

            Log::Warning << "Timer at " << location.GetFuncName() << " (" << resource->GetName() << ":" << location.GetFileName()
                         << ":" << location.GetLineNumber() << ") was too long " << (GetTime() - time) << "ms" << Log::Endl;
        }
    }

    for(auto it = localHandlers.begin(); it != localHandlers.end();)
    {
        if(it->second.removed) it = localHandlers.erase(it);
        else
            ++it;
    }

    for(auto it = remoteHandlers.begin(); it != remoteHandlers.end();)
    {
        if(it->second.removed) it = remoteHandlers.erase(it);
        else
            ++it;
    }

    for(auto it = localGenericHandlers.begin(); it != localGenericHandlers.end();)
    {
        if(it->removed) it = localGenericHandlers.erase(it);
        else
            ++it;
    }

    for(auto it = remoteGenericHandlers.begin(); it != remoteGenericHandlers.end();)
    {
        if(it->removed) it = remoteGenericHandlers.erase(it);
        else
            ++it;
    }

    for (auto it = awaitableRPCHandlers.rbegin(); it != awaitableRPCHandlers.rend(); ++it)
    {
        auto promise = it->Promise.Get(isolate);
        if (!promise->IsPromise())
        {
            awaitableRPCHandlers.erase(std::next(it).base());
            continue;
        }

        v8::Promise::PromiseState state = promise->State();
        if (state == v8::Promise::PromiseState::kFulfilled)
        {
            v8::Local<v8::Value> returnValue = promise->Result();

            // Retrieve returned error message when an error was returned
            std::string errorMessage;
            if (returnValue->IsNativeError())
            {
                v8::Local<v8::Value> exception = returnValue.As<v8::Value>();

                v8::String::Utf8Value messageValue(isolate, exception->ToString(isolate->GetCurrentContext()).ToLocalChecked());
                errorMessage = *messageValue;

                // Strip exception prefix
                if (size_t colonPos = errorMessage.find(':'); colonPos != std::string::npos)
                    errorMessage = errorMessage.substr(colonPos + 2);
            }

#ifdef ALT_SERVER_API
            alt::ICore::Instance().TriggerClientRPCAnswer(it->Player, it->AnswerId, V8Helpers::V8ToMValue(returnValue), errorMessage);
#else
            alt::ICore::Instance().TriggerServerRPCAnswer(it->AnswerId, V8Helpers::V8ToMValue(returnValue), errorMessage);
#endif
        }

        if (state == v8::Promise::PromiseState::kFulfilled || state == v8::Promise::PromiseState::kRejected)
            awaitableRPCHandlers.erase(std::next(it).base());
    }
}

void V8ResourceImpl::BindEntity(v8::Local<v8::Object> val, alt::IBaseObject* handle)
{
    V8Class* entityClass = V8Entity::GetClass(handle);
    if(!entityClass)
    {
        Log::Error << "Failed to bind entity: Type " << (int)handle->GetType() << " has no class" << Log::Endl;
        return;
    }
    V8Entity* ent = new V8Entity(GetContext(), entityClass, val, handle);
    entities.insert({ handle, ent });
}

v8::Local<v8::Value> V8ResourceImpl::GetBaseObjectOrNull(alt::IBaseObject* handle)
{
    if(handle == nullptr || handle->IsRemoved())
        return v8::Null(isolate);

    V8Entity* entity = GetOrCreateEntity(handle);
    if (entity)
        return entity->GetJSVal(isolate);

    return v8::Null(isolate);
}

v8::Local<v8::Value> V8ResourceImpl::CreateVector3(alt::Vector3f vec)
{
    std::vector<v8::Local<v8::Value>> args{ V8Helpers::JSValue(vec[0]), V8Helpers::JSValue(vec[1]), V8Helpers::JSValue(vec[2]) };

    return v8Vector3.CreateInstance(isolate, GetContext(), args);
}

v8::Local<v8::Value> V8ResourceImpl::CreateVector2(alt::Vector2f vec)
{
    std::vector<v8::Local<v8::Value>> args{ V8Helpers::JSValue(vec[0]), V8Helpers::JSValue(vec[1]) };

    return v8Vector2.CreateInstance(isolate, GetContext(), args);
}

v8::Local<v8::Value> V8ResourceImpl::CreateQuaternion(alt::Quaternion quat)
{
    std::vector<v8::Local<v8::Value>> args{ V8Helpers::JSValue(quat.x), V8Helpers::JSValue(quat.y), V8Helpers::JSValue(quat.z), V8Helpers::JSValue(quat.w) };

    return v8Quaternion.CreateInstance(isolate, GetContext(), args);
}

v8::Local<v8::Value> V8ResourceImpl::CreateRGBA(alt::RGBA rgba)
{
    std::vector<v8::Local<v8::Value>> args{ V8Helpers::JSValue(rgba.r), V8Helpers::JSValue(rgba.g), V8Helpers::JSValue(rgba.b), V8Helpers::JSValue(rgba.a) };

    return V8Helpers::New(isolate, GetContext(), rgbaClass.Get(isolate), args);
}

//bool V8ResourceImpl::IsVector3(v8::Local<v8::Value> val)
//{
//    bool result = false;
//    val->InstanceOf(GetContext(), vector3Class.Get(isolate)).To(&result);
//    return result;
//}
//
//bool V8ResourceImpl::IsVector2(v8::Local<v8::Value> val)
//{
//    bool result = false;
//    val->InstanceOf(GetContext(), vector2Class.Get(isolate)).To(&result);
//    return result;
//}
//
//bool V8ResourceImpl::IsQuaternion(v8::Local<v8::Value> val)
//{
//    bool result = false;
//    val->InstanceOf(GetContext(), quaternionClass.Get(isolate)).To(&result);
//    return result;
//}
//
//bool V8ResourceImpl::IsRGBA(v8::Local<v8::Value> val)
//{
//    bool result = false;
//    val->InstanceOf(GetContext(), rgbaClass.Get(isolate)).To(&result);
//    return result;
//}
//
//bool V8ResourceImpl::IsBaseObject(v8::Local<v8::Value> val)
//{
//    bool result = false;
//    val->InstanceOf(GetContext(), baseObjectClass.Get(isolate)).To(&result);
//    return result;
//}

void V8ResourceImpl::OnCreateBaseObject(alt::IBaseObject* handle)
{
    if(!handle)
    {
        Log::Error << "OnCreateBaseObject called with invalid handle" << Log::Endl;
        return;
    }

    NotifyPoolUpdate(handle);
}

void V8ResourceImpl::OnRemoveBaseObject(alt::IBaseObject* handle)
{
    NotifyPoolUpdate(handle);

    v8::Locker locker(isolate);
    v8::Isolate::Scope isolateScope(isolate);
    v8::HandleScope handleScope(isolate);
    v8::Context::Scope scope(GetContext());

    V8Entity* ent = GetEntity(handle);
    if(!ent) return;

    auto entityType = handle->GetType();
    if(entityType == alt::IBaseObject::Type::PLAYER || entityType == alt::IBaseObject::Type::LOCAL_PLAYER || entityType == alt::IBaseObject::Type::VEHICLE || entityType == alt::IBaseObject::Type::PED || entityType == alt::IBaseObject::Type::OBJECT)
    {
        std::vector<V8Helpers::EventCallback*> handlers = GetLocalHandlers("removeEntity");
        std::vector<v8::Local<v8::Value>> args{ ent->GetJSVal(isolate) };
        InvokeEventHandlers(nullptr, handlers, args);
    }

    entities.erase(handle);
    ent->GetJSVal(isolate)->SetInternalField(static_cast<int>(V8Class::InternalFields::BASE_OBJECT), v8::Null(isolate));
    delete ent;
}

void V8ResourceImpl::NotifyPoolUpdate(alt::IBaseObject* ent)
{
    switch(ent->GetType())
    {
        case alt::IBaseObject::Type::PLAYER: playerPoolDirty = true; break;
        case alt::IBaseObject::Type::VEHICLE:
        case alt::IBaseObject::Type::LOCAL_VEHICLE: vehiclePoolDirty = true; break;
        case alt::IBaseObject::Type::LOCAL_OBJECT:
            objectPoolDirty = true;
            weaponObjectPoolDirty = true;
            break;
    }
}

v8::Local<v8::Array> V8ResourceImpl::GetAllPlayers()
{
    if(playerPoolDirty)
    {
        playerPoolDirty = false;

        std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::PLAYER);
        v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

        for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

        players.Reset(isolate, jsAll);
        jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
        return jsAll;
    }

    return players.Get(isolate);
}

v8::Local<v8::Array> V8ResourceImpl::GetAllVehicles()
{
    if(vehiclePoolDirty)
    {
        vehiclePoolDirty = false;

        std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::VEHICLE);
        v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

        for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

        vehicles.Reset(isolate, jsAll);
        jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
        return jsAll;
    }
    return vehicles.Get(isolate);
}

v8::Local<v8::Array> V8ResourceImpl::GetAllBlips()
{
    std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::BLIP);
    v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

    for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

    jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
    return jsAll;
}

v8::Local<v8::Array> V8ResourceImpl::GetAllAudioOutputs()
{
    std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::AUDIO_OUTPUT);
    v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

    for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

    jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
    return jsAll;
}

v8::Local<v8::Array> V8ResourceImpl::GetAllVirtualEntityGroups()
{
    std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::VIRTUAL_ENTITY_GROUP);
    v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

    for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

    jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
    return jsAll;
}

v8::Local<v8::Array> V8ResourceImpl::GetAllVirtualEntities()
{
    std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::VIRTUAL_ENTITY);
    v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

    for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

    jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
    return jsAll;
}

v8::Local<v8::Array> V8ResourceImpl::GetAllCheckpoints()
{
    std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::CHECKPOINT);
    v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

    for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

    jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
    return jsAll;
}

v8::Local<v8::Array> V8ResourceImpl::GetAllPeds()
{
    std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::PED);
    v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

    for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

    jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
    return jsAll;
}

v8::Local<v8::Array> V8ResourceImpl::GetAllMarkers()
{
    std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::MARKER);
    v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

    for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

    jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
    return jsAll;
}

v8::Local<v8::Array> V8ResourceImpl::GetAllColshapes()
{
    std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::COLSHAPE);
    v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

    for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

    jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
    return jsAll;
}

#ifdef ALT_SERVER_API
v8::Local<v8::Array> V8ResourceImpl::GetAllConnectionInfos()
{
    std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::CONNECTION_INFO);
    v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

    for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

    jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
    return jsAll;
}
#endif

#ifdef ALT_CLIENT_API
v8::Local<v8::Array> V8ResourceImpl::GetAllLocalObjects()
{
    if(objectPoolDirty)
    {
        objectPoolDirty = false;

        std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::LOCAL_OBJECT);
        v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

        for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

        objects.Reset(isolate, jsAll);
        jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
        return jsAll;
    }
    return objects.Get(isolate);
}

v8::Local<v8::Array> V8ResourceImpl::GetAllWeaponObjects()
{
    if(weaponObjectPoolDirty)
    {
        weaponObjectPoolDirty = false;

        std::vector<ILocalObject*> all = ICore::Instance().GetWeaponObjects();
        v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

        for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

        weaponObjects.Reset(isolate, jsAll);
        jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
        return jsAll;
    }
    return weaponObjects.Get(isolate);
}
#endif

v8::Local<v8::Array> V8ResourceImpl::GetAllObjects()
{
    std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::OBJECT);
    v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

    for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

    jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
    return jsAll;
}

v8::Local<v8::Array> V8ResourceImpl::GetAllTextLabels()
{
    std::vector<IBaseObject*> all = ICore::Instance().GetBaseObjects(alt::IBaseObject::Type::TEXT_LABEL);
    v8::Local<v8::Array> jsAll = v8::Array::New(isolate, all.size());

    for(uint32_t i = 0; i < all.size(); ++i) jsAll->Set(GetContext(), i, GetBaseObjectOrNull(all[i]));

    jsAll->SetIntegrityLevel(GetContext(), v8::IntegrityLevel::kFrozen);
    return jsAll;
}

std::vector<V8Helpers::EventCallback*> V8ResourceImpl::GetLocalHandlers(const std::string& name)
{
    std::vector<V8Helpers::EventCallback*> handlers;
    auto range = localHandlers.equal_range(name);

    for(auto it = range.first; it != range.second; ++it) handlers.push_back(&it->second);

    return handlers;
}

std::vector<V8Helpers::EventCallback*> V8ResourceImpl::GetRemoteHandlers(const std::string& name)
{
    std::vector<V8Helpers::EventCallback*> handlers;
    auto range = remoteHandlers.equal_range(name);

    for(auto it = range.first; it != range.second; ++it) handlers.push_back(&it->second);

    return handlers;
}

std::vector<V8Helpers::EventCallback*> V8ResourceImpl::GetGenericHandlers(bool local)
{
    std::vector<V8Helpers::EventCallback*> handlers;
    if(local)
        for(auto& it : localGenericHandlers) handlers.push_back(&it);
    else
        for(auto& it : remoteGenericHandlers) handlers.push_back(&it);
    return handlers;
}

extern V8Class v8Resource;
v8::Local<v8::Object> V8ResourceImpl::GetOrCreateResourceObject(alt::IResource* resource)
{
    // If already created return instance
    if(resourceObjects.count(resource) != 0) return resourceObjects.at(resource).Get(isolate);

    // Create instance
    v8::Local<v8::Object> obj = v8Resource.CreateInstance(GetContext());
    V8Helpers::SetObjectClass(isolate, obj, V8Class::ObjectClass::RESOURCE);
    obj->SetInternalField(static_cast<int>(V8Class::InternalFields::RESOURCE), v8::External::New(isolate, resource));

    resourceObjects.insert({ resource, V8Helpers::CPersistent<v8::Object>(isolate, obj) });
    return obj;
}

void V8ResourceImpl::DeleteResourceObject(alt::IResource* resource)
{
    if(resourceObjects.count(resource) == 0) return;
    v8::Local<v8::Object> obj = resourceObjects.at(resource).Get(isolate);
    obj->SetInternalField(static_cast<int>(V8Class::InternalFields::RESOURCE), v8::Null(isolate));
    resourceObjects.erase(resource);
}

void V8ResourceImpl::InvokeEventHandlers(const alt::CEvent* ev, const std::vector<V8Helpers::EventCallback*>& handlers, std::vector<v8::Local<v8::Value>>& args, bool waitForPromiseResolve)
{
    for(auto handler : handlers)
    {
        if(handler->removed) continue;
        int64_t time = GetTime();

        V8Helpers::TryCatch(
          [&]
          {
              v8::MaybeLocal<v8::Value> retn = V8Helpers::CallFunctionWithTimeout(handler->fn.Get(isolate), GetContext(), args);
              if(retn.IsEmpty()) return false;

              v8::Local<v8::Value> returnValue = retn.ToLocalChecked();
              if(ev && returnValue->IsFalse() && ev->IsCancellable()) static_cast<const alt::CCancellableEvent*>(ev)->Cancel();
              else if(ev && ev->GetType() == alt::CEvent::Type::WEAPON_DAMAGE_EVENT && returnValue->IsNumber())
                  static_cast<alt::CWeaponDamageEvent*>(const_cast<alt::CEvent*>(ev))->SetDamageValue((uint32_t)returnValue->NumberValue(GetContext()).ToChecked());
              // todo: add this once a generic Cancel() with string as arg has been added to the sdk
              // else if(ev && returnValue->IsString())
              //    ev->Cancel(*v8::String::Utf8Value(isolate, returnValue));

              // Wait until the returned promise has been resolved, by continously forcing the event loop to run,
              // until the promise is resolved.
              if(waitForPromiseResolve && returnValue->IsPromise())
              {
                  v8::Local<v8::Promise> promise = returnValue.As<v8::Promise>();
                  while(true)
                  {
                      v8::Promise::PromiseState state = promise->State();
                      if(state == v8::Promise::PromiseState::kPending)
                      {
#ifdef ALT_CLIENT_API
                          CV8ScriptRuntime::Instance().OnTick();
#endif
#ifdef ALT_SERVER_API
                          CNodeScriptRuntime::Instance().OnTick();
#endif
                          // Run event loop
                          OnTick();
                      }
                      else if(state == v8::Promise::PromiseState::kFulfilled)
                      {
                          v8::Local<v8::Value> value = promise->Result();
                          if(value->IsFalse() && ev->IsCancellable()) static_cast<const alt::CCancellableEvent*>(ev)->Cancel();
                          break;
                      }
                      else if(state == v8::Promise::PromiseState::kRejected)
                      {
                          // todo: we should probably do something with the rejection here
                          break;
                      }
                  }
              }

              return true;
          });

        if (GetTime() - time > 50 && !waitForPromiseResolve)
        {
            Log::Warning << "Event handler at " << handler->location.GetFuncName() << " (" << resource->GetName() << ":" << handler->location.GetFileName() << ":"
                         << handler->location.GetLineNumber()
                         << ") was too long " << (GetTime() - time) << "ms" << Log::Endl;
        }

        if(handler->once) handler->removed = true;
    }
}

void V8ResourceImpl::PrintHealth()
{
    Log::Info << "Resource health: " << resource->GetName() << Log::Endl;
    Log::Info << " - Entities: " << entities.size() << Log::Endl;
    Log::Info << " - Timers: " << timers.size() << Log::Endl;
    Log::Info << " - Timer benchmarks: " << benchmarkTimers.size() << Log::Endl;

#ifdef ALT_SERVER_API
    Log::Info << " - Vehicle passengers: " << vehiclePassengers.size() << Log::Endl;
#endif  //  ALT_SERVER_API    
}

// Internal script globals
static void SetLogFunction(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    V8_GET_ISOLATE_CONTEXT_RESOURCE();
    V8_CHECK_ARGS_LEN(1);

    v8::Local<v8::Value> function = info[0];
    if(!function->IsFunction()) return;
    resource->SetLogFunction(function.As<v8::Function>());
}

// Types:
// 0 = normal
// 1 = warning
// 2 = error
static void PrintLog(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    V8_GET_ISOLATE_CONTEXT_RESOURCE();
    V8_CHECK_ARGS_LEN_MIN(1);

    V8_ARG_TO_INT32(1, type);
    std::stringstream stream;
    for(size_t i = 1; i < info.Length(); i++)
    {
        std::string arg = *v8::String::Utf8Value(isolate, info[i]);
        stream << arg;
        if(i != info.Length() - 1) stream << " ";
    }
    switch(type)
    {
        case 0:
        {
            alt::ICore::Instance().LogColored(Log::LOG_PREFIX, stream.str(), resource->GetResource());
            break;
        }
        case 1:
        {
            alt::ICore::Instance().LogWarning(Log::LOG_PREFIX, stream.str(), resource->GetResource());
            break;
        }
        case 2:
        {
            alt::ICore::Instance().LogError(Log::LOG_PREFIX, stream.str(), resource->GetResource());
            break;
        }
    }
}

static std::string extraBootstrapFile;

static void RegisterExtraBootstrapFile(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    V8_GET_ISOLATE_CONTEXT_RESOURCE();
    V8_CHECK_ARGS_LEN(1);

    V8_ARG_TO_STRING(1, filePath);

    auto path = alt::ICore::Instance().Resolve(resource->GetResource(), filePath, "");
    V8_CHECK(path.pkg, "Invalid file");

    alt::IPackage::File* file = path.pkg->OpenFile(path.fileName);
    V8_CHECK(file, "File does not exist");

    std::string data(path.pkg->GetFileSize(file), 0);
    path.pkg->ReadFile(file, data.data(), data.size());
    path.pkg->CloseFile(file);

    extraBootstrapFile = data;
}

#ifdef ALT_CLIENT_API
static void RegisterCefExtraBootstrapFile(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    V8_GET_ISOLATE_CONTEXT_RESOURCE();
    V8_CHECK_ARGS_LEN(1);

    V8_ARG_TO_STRING(1, filePath);

    auto path = alt::ICore::Instance().Resolve(resource->GetResource(), filePath, "");
    V8_CHECK(path.pkg, "Invalid file");

    alt::IPackage::File* file = path.pkg->OpenFile(path.fileName);
    V8_CHECK(file, "File does not exist");

    std::string data(path.pkg->GetFileSize(file), 0);
    path.pkg->ReadFile(file, data.data(), data.size());
    path.pkg->CloseFile(file);

    alt::ICore::Instance().InternalAddCefBootstrap(data);
}
#endif

static void GetExtraBootstrapFile(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    V8_GET_ISOLATE();
    V8_RETURN_STRING(extraBootstrapFile);
}

void V8ResourceImpl::SetupScriptGlobals()
{
    v8::Local<v8::Context> ctx = context.Get(isolate);

    ctx->Global()->Set(ctx, V8Helpers::JSValue("__setLogFunction"), v8::Function::New(ctx, &::SetLogFunction).ToLocalChecked());
    ctx->Global()->Set(ctx, V8Helpers::JSValue("__printLog"), v8::Function::New(ctx, &::PrintLog).ToLocalChecked());
    ctx->Global()->Set(ctx, V8Helpers::JSValue("__registerExtraBootstrapFile"), v8::Function::New(ctx, &::RegisterExtraBootstrapFile).ToLocalChecked());
    ctx->Global()->Set(ctx, V8Helpers::JSValue("__getExtraBootstrapFile"), v8::Function::New(ctx, &::GetExtraBootstrapFile).ToLocalChecked());

#ifdef ALT_CLIENT_API
    ctx->Global()->Set(ctx, V8Helpers::JSValue("__registerCefExtraBootstrapFile"), v8::Function::New(ctx, &::RegisterCefExtraBootstrapFile).ToLocalChecked());
#endif
}

alt::MValue V8ResourceImpl::FunctionImpl::Call(alt::MValueArgs args) const
{
    if(!resource->GetResource()->IsStarted())
    {
        Log::Error << "Tried to call function on resource " << resource->GetResource()->GetName() << " while the resource is stopped" << Log::Endl;
        return alt::ICore::Instance().CreateMValueNone();
    }
    v8::Isolate* isolate = resource->GetIsolate();

    v8::Locker locker(isolate);
    v8::Isolate::Scope isolateScope(isolate);
    v8::HandleScope handleScope(isolate);

    v8::Local<v8::Context> ctx = resource->GetContext();
    v8::Context::Scope scope(ctx);

#ifdef ALT_SERVER_API
    CNodeResourceImpl* nodeRes = static_cast<CNodeResourceImpl*>(resource);
    V8_CHECK_RETN(nodeRes->IsEnvStarted(), "Tried to call exported function of invalid resource", alt::ICore::Instance().CreateMValueNone());
    node::CallbackScope callbackScope(isolate, nodeRes->GetAsyncResource(), nodeRes->GetAsyncContext());
#endif  // ALT_SERVER_API

    std::vector<v8::Local<v8::Value>> v8Args;
    V8Helpers::MValueArgsToV8(args, v8Args);

    alt::MValue res;
    V8Helpers::TryCatch(
      [&]
      {
          v8::MaybeLocal<v8::Value> _res = V8Helpers::CallFunctionWithTimeout(function.Get(isolate), resource->GetContext(), v8Args);

          if(_res.IsEmpty()) return false;

          res = V8Helpers::V8ToMValue(_res.ToLocalChecked());
          return true;
      });

    if(!res) res = alt::ICore::Instance().CreateMValueNone();

    return res;
}