local registeredCallbacks = {}
local pendingExecutions = {}
local resourceName = GetCurrentResourceName()

print(('[%s] DevX RPC v0.4.1 aktiv.'):format(resourceName))

local function callbackEventName(name)
    return ('devx_core:server:callback:%s:%s'):format(resourceName, name)
end

local function responseEventName()
    return ('devx_core:client:callback:%s'):format(resourceName)
end

local function sendResult(requestSource, requestId, result)
    TriggerClientEvent(responseEventName(), requestSource, requestId, result)
end

function DevXRegisterCallback(name, handler)
    assert(type(name) == 'string' and name:match('^[%w_%-]+:[%w_%-]+$'),
        'Callbackname ist ungültig.')
    assert(type(handler) == 'function', 'Callbackhandler muss eine Funktion sein.')
    assert(not registeredCallbacks[name], ('Callback %s wurde doppelt registriert.'):format(name))

    registeredCallbacks[name] = true
    local eventName = callbackEventName(name)

    RegisterNetEvent(eventName)
    AddEventHandler(eventName, function(requestId, payload)
        local requestSource = source

        if type(requestId) ~= 'string' or #requestId > 160 or type(payload) ~= 'table' then
            sendResult(requestSource, tostring(requestId or ''), {
                ok = false,
                error = 'Ungültige Serveranfrage.'
            })
            return
        end

        local executionKey = ('%s:%s'):format(requestSource, requestId)
        if pendingExecutions[executionKey] then
            sendResult(requestSource, requestId, {
                ok = false,
                error = 'Diese Serveranfrage wird bereits verarbeitet.'
            })
            return
        end

        pendingExecutions[executionKey] = true
        local completed = false

        local function finish(result)
            if completed then return end
            completed = true
            pendingExecutions[executionKey] = nil

            if result == nil then result = { ok = true } end
            sendResult(requestSource, requestId, result)
        end

        print(('[%s] RPC empfangen: %s von Spieler %s.'):format(resourceName, name, requestSource))

        SetTimeout(20000, function()
            if completed then return end
            print(('[%s] RPC %s für Spieler %s hat nach 20 Sekunden nicht geantwortet.'):format(
                resourceName, name, requestSource
            ))
            finish({
                ok = false,
                error = ('Serververarbeitung für %s abgelaufen. Prüfe die txAdmin-Konsole.'):format(name)
            })
        end)

        CreateThread(function()
            local result = handler(requestSource, payload)
            finish(result)
        end)
    end)
end