if (type(Require) ~= 'function') then
    loadstring(exports['nc_libraries']:extend('Extend'), 'Require')()
end

if type (EventManager) == 'table' then
    return EventManager
end

Require('Hash')

local isClient = isClient or isElement(localPlayer)
local _next = next;
local _type = type;
local _assert = assert;
local _inspect = inspect;
local isElement = isElement;
local table = table;
local unpack = unpack;
local hmac = hmac;
local tostring = tostring;

_G._addEventHandler = addEventHandler;
_G._removeEventHandler = removeEventHandler;
_G._getEventHandlers = getEventHandlers;
_G._addEvent = addEvent;
_G._addCommandHandler = addCommandHandler;
_G._removeCommandHandler = removeCommandHandler;
_G._triggerEvent = triggerEvent;
_G._triggerServerEvent = triggerServerEvent;
_G._triggerClientEvent = triggerClientEvent;
_G._triggerLatentClientEvent = triggerLatentClientEvent;

local _UPVALUE0 = 39273278327372;
local _UPVALUE1 = 32883273273282;

local EventManager = {}

EventManager.Events = {};
EventManager.Commands = {};
EventManager.GlobalEvents = {};

EventManager.GetKey = function(self)
    return tostring(_UPVALUE0 + _UPVALUE1 - 8328327)
end

EventManager.AddEvent = function (self, sEventName, bGlobal, bEncrypted)
    if _type(sEventName) ~= 'string' and _type(sEventName) ~= 'table' then
        return false, outputDebugString('Event name must be a string or a table got '.._type (sEventName), 4, 255, 0, 0)
    end

    if _type(sEventName) == 'table' then
        local Results = {}
        local Result = true;

        for i, v in next, sEventName, nil do
            Results[i] = self:AddEvent(v, bGlobal, bEncrypted)
        end

        for i, v in next, Results, nil do
            if not v then
                Result = false
                break
            end
        end

        return Result
    end

    if _type(bGlobal) ~= 'boolean' then
        bGlobal = false
    end

    if _type(bEncrypted) ~= 'boolean' then
        bEncrypted = true
    end

    if bGlobal then
        self.GlobalEvents[sEventName] = bEncrypted and hmac(sEventName, self:GetKey(), 'sha224') or sEventName

        sEventName = self.GlobalEvents[sEventName]
    end

    if not self.Events[sEventName] then
        self.Events[sEventName] = {}
    end

    return _addEvent(sEventName, bGlobal)
end

EventManager.GetEventHandlers = function (self, sEventName, pElementAttachedTo)
    if _type(sEventName) ~= 'string' then
        return false, outputDebugString('Event name must be a string', 4, 255, 0, 0)
    end

    if _type (pElementAttachedTo) ~= 'userdata' then
        return false
    end

    if not isElement(pElementAttachedTo) then
        return false
    end

    if not isClient and self.GlobalEvents[sEventName] then
        sEventName = self.GlobalEvents[sEventName]
    end
    
    return _getEventHandlers(sEventName, pElementAttachedTo) or {}
end

EventManager.IsEventHandlerAdded = function (self, sEventName, pElementAttachedTo, func)
    if _type (sEventName) ~= 'string' then
        return false, 'Event name must be a string'
    end

    if _type (func) ~= 'function' then
        return false, 'Function must be a function'
    end

    if _type (pElementAttachedTo) ~= 'userdata' or not isElement(pElementAttachedTo) then
        return false
    end

    if not isClient and self.GlobalEvents[sEventName] then
        sEventName = self.GlobalEvents[sEventName]
    end

    if self.Events[sEventName] and self.Events[sEventName][pElementAttachedTo] and self.Events[sEventName][pElementAttachedTo][func] then
        return true
    end

    local aAttachedFunctions = self:GetEventHandlers(sEventName, pElementAttachedTo)
    
    if _type(aAttachedFunctions) ~= 'table' then
        return false
    end

    if _next(aAttachedFunctions) == nil then
        return false;
    end

    for i, v in _next, aAttachedFunctions, nil do
        if (v == func) then
            return true
        end
    end

    return false
end

EventManager.AddEventHandler = function (self, sEventName, pElementAttachedTo, func, ...)
    _assert(_type(sEventName) == 'string' or _type(sEventName) == 'table', 'Event name must be a string or a table got '.._type (sEventName))
    _assert(_type(pElementAttachedTo) == 'userdata' and isElement(pElementAttachedTo), 'Element attached to must be a userdata and a valid element traceback: '..debug.traceback())
    if not _type(func) == 'function' then
        return false, iprint('Function must be a function got '.._type(func).. ' for event '..sEventName)
    end

    -- support for multiple events
    if _type(sEventName) == 'table' then
        local Results = {}
        local Result = true;
        
        for i, v in next, sEventName, nil do
            Results[i] = self:AddEventHandler(v, pElementAttachedTo, func, ...)
        end

        for i, v in next, Results, nil do
            if not v then
                Result = false
                break
            end
        end

        return Result
    end

    if self.GlobalEvents[sEventName] then
        sEventName = self.GlobalEvents[sEventName]
    end

    if self:IsEventHandlerAdded(sEventName, pElementAttachedTo, func) then
        return false, 'Event handler already added'
    end

    if _addEventHandler(sEventName, pElementAttachedTo, func, ...) then
        if not self.Events[sEventName] then
            self.Events[sEventName] = {}
        end

        if not self.Events[sEventName][pElementAttachedTo] then
            self.Events[sEventName][pElementAttachedTo] = {}
        end

        self.Events[sEventName][pElementAttachedTo][func] = true
        return true
    end
end

EventManager.RemoveEventHandler = function (self, sEventName, pElementAttachedTo, func)
    if not isClient and self.GlobalEvents[sEventName] then
        sEventName = self.GlobalEvents[sEventName]
    end

    if self:IsEventHandlerAdded(sEventName, pElementAttachedTo, func) then
        if self.Events[sEventName] and self.Events[sEventName][pElementAttachedTo] then
            if self.Events[sEventName][pElementAttachedTo][func] then
                self.Events[sEventName][pElementAttachedTo][func] = nil
            end

            if _next(self.Events[sEventName][pElementAttachedTo]) == nil then
                self.Events[sEventName][pElementAttachedTo] = nil
            end

            if _next(self.Events[sEventName]) == nil then
                self.Events[sEventName] = nil
            end
        end

        return _removeEventHandler(sEventName, pElementAttachedTo, func)
    end

    return false
end

-- used for remote events
EventManager.RegisterNetEvent = function (self, event, ...)
    _assert(_type(event) == 'string' or _type(event) == 'table', 'Event name must be a string or a table got '.._type (event))
    local args = {...}
    local bEncrypted, attach, func, propagate, priority;

    if type(args[1]) == 'boolean' then
        bEncrypted = args[1]

        table.remove(args, 1)

        attach, func, propagate, priority = unpack(args)

        args = nil;
    elseif #args > 0 then
        attach, func, propagate, priority = unpack(args)
        bEncrypted = true
    end
    
    if self:AddEvent(event, true, bEncrypted) then
        if isElement(attach) and type(func) == 'function' then
            if self:AddEventHandler(event, attach, func, propagate, priority) then
                return true
            end

            return true
        else
            return true
        end
    end

    return false
end

EventManager.RegisterLocalEvent = function (self, event, ...)
    _assert(_type(event) == 'string' or _type(event) == 'table', 'Event name must be a string or a table got '.._type (event))

    local args = {...}
    local bEncrypted, attach, func, propagate, priority;

    if _type(args[1]) == 'boolean' then
        bEncrypted = args[1]

        table.remove(args, 1)

        attach, func, propagate, priority = unpack(args)

        args = nil;
    elseif #args > 0 then
        attach, func, propagate, priority = unpack(args)
        bEncrypted = false
    end

    if self:AddEvent(event, false, bEncrypted) then
        if isElement(attach) and _type(func) == 'function' then
            if self:AddEventHandler(event, attach, func, propagate, priority) then
                return true
            end
        end

        return true
    end

    return false
end

EventManager.RegisterCommand = function (self, sCommandName, fFunction, bRestrict, bSensivite)
    assert(type (sCommandName) == 'string' or type (sCommandName) == 'table', 'Command name must be a string or a table got '..type (sCommandName))
    assert(type (fFunction) == 'function', 'Function must be a function got '..type (fFunction))

    if type (sCommandName) == 'string' then
        local Result = _addCommandHandler(sCommandName, fFunction, bRestrict, bSensivite);

        if Result then
            if not self.Commands[sCommandName] then
                self.Commands[sCommandName] = {}
            end

            if not self.Commands[sCommandName][fFunction] then
                self.Commands[sCommandName][fFunction] = true
            end
        end

        return Result;
    elseif type (sCommandName) == 'table' then
        local Results = {}

        for i, v in next, sCommandName, nil do
            Results[i] = self:RegisterCommand(v, fFunction, bRestrict, bSensivite)
        end

        local Result = true;

        for i, v in next, Results, nil do
            if not v then
                Result = false
                break
            end
        end

        return Result
    else
        return false, 'Command name must be a string or a table'
    end
end

EventManager.RemoveCommand = function (self, sCommandName, fFunction)
    local Result = _removeCommandHandler(sCommandName, fFunction);

    if Result then
        if self.Commands[sCommandName] and self.Commands[sCommandName][fFunction] then
            self.Commands[sCommandName][fFunction] = nil

            if _next(self.Commands[sCommandName]) == nil then
                self.Commands[sCommandName] = nil
            end
        end
    end

    return Result;
end


EventManager.TriggerEvent = function (self, sEventName, ...)
    sEventName = hmac(sEventName, self:GetKey(), 'sha224') or sEventName

    return _triggerEvent(sEventName, ...)
end

EventManager.TriggerServerEvent = function (self, sEventName, ...)
    sEventName = hmac(sEventName, self:GetKey(), 'sha224') or sEventName

    return _triggerServerEvent(sEventName, ...);
end

EventManager.TriggerClientEvent = function (self, vTarget, sEventName, ...)
    if _type(vTarget) == 'userdata' and isElement(vTarget) then
        sEventName = hmac(sEventName, self:GetKey(), 'sha224')

        return _triggerClientEvent(vTarget, sEventName, ...)
    elseif _type(vTarget) == 'table' and _next(vTarget) ~= nil then
        local OneValid;

        sEventName = hmac(sEventName, self:GetKey(), 'sha224')

        for i = 1, #vTarget do
            local Element = vTarget[i]

            if isElement(Element) then

                _triggerClientEvent(Element, sEventName, ...)

                if not OneValid then
                    OneValid = true
                end
            end
        end

        if OneValid then
            return true
        end
    elseif _type(vTarget) == 'string' then
        sEventName = vTarget

        sEventName = hmac(sEventName, self:GetKey(), 'sha224')

        return _triggerClientEvent(vTarget, sEventName, ...)
    end

    return false;
end

EventManager.TriggerLatentClientEvent = function(self, vTarget, sEventName, iBandwidth, bPersist, ...)
    iBandwidth = tonumber(iBandwidth) or 5000
    bPersist = bPersist == true

    if _type(vTarget) == 'userdata' and isElement(vTarget) then
        sEventName = hmac(sEventName, self:GetKey(), 'sha224')

        return _triggerLatentClientEvent(vTarget, sEventName, iBandwidth, bPersist, ...)
    elseif _type(vTarget) == 'table' and _next(vTarget) ~= nil then
        local OneValid

        sEventName = hmac(sEventName, self:GetKey(), 'sha224')

        for i = 1, #vTarget do
            local Element = vTarget[i]

            if isElement(Element) then
                _triggerLatentClientEvent(Element, sEventName, iBandwidth, bPersist, ...)

                if not OneValid then
                    OneValid = true
                end
            end
        end

        if OneValid then
            return true
        end
    elseif _type(vTarget) == 'string' then
        sEventName = vTarget
        sEventName = hmac(sEventName, self:GetKey(), 'sha224')

        return _triggerLatentClientEvent(vTarget, sEventName, iBandwidth, bPersist, ...)
    end

    return false
end

_G.triggerEvent = function (...) return EventManager:TriggerEvent(...) end _G.TriggerEvent = triggerEvent;

_G.triggerServerEvent = function (...) return EventManager:TriggerServerEvent(...) end _G.TriggerServerEvent = triggerServerEvent;

_G.triggerClientEvent = function (...) return EventManager:TriggerClientEvent(...) end _G.TriggerClientEvent = triggerClientEvent;

_G.triggerLatentClientEvent = function (...) return EventManager:TriggerLatentClientEvent(...) end _G.TriggerLatentClientEvent = triggerLatentClientEvent;

_G.addEventHandler = function (...) return EventManager:AddEventHandler(...) end _G.AddEventHandler = addEventHandler _G.AddPluginHandler = addEventHandler;

_G.removeEventHandler = function (...) return EventManager:RemoveEventHandler(...) end _G.RemoveEventHandler = removeEventHandler;

_G.getEventHandlers = function (...) return EventManager:GetEventHandlers(...) end _G.GetEventHandlers = getEventHandlers;

_G.addEvent = function (...) return EventManager:AddEvent(...) end _G.AddEvent = addEvent;

_G.registerCommand = function (...) return EventManager:RegisterCommand(...) end _G.RegisterCommand = registerCommand _G.addCommandHandler = registerCommand;

_G.removeCommand = function (...) return EventManager:RemoveCommand(...) end _G.RemoveCommand = removeCommand;

_G.registerNetEvent = function (...) return EventManager:RegisterNetEvent(...) end _G.RegisterNetEvent = registerNetEvent;

_G.registerLocalEvent = function (...) return EventManager:RegisterLocalEvent(...) end _G.RegisterLocalEvent = registerLocalEvent;

_G.isEventHandlerAdded = function (...) return EventManager:IsEventHandlerAdded(...) end _G.IsEventHandlerAdded = isEventHandlerAdded;

_G.EventManager = EventManager;

return EventManager;