---@type Tinkr, Bastion
local Tinkr, Bastion = ...

-- Create an EventManager class
---@class EventManager
---@field frame Frame
---@field events table<string, { [number]: fun(...) }>
---@field eventHandlers table<string, { [number]: fun(...) }>
---@field wowEventHandlers table<string, { [number]: fun(...) }>
---@field selfCombatEventHandlers table<string, { [number]: fun(...) }>
---@field CombatEventHandlers table<string, { [number]: fun(...) }>
local EventManager = {
    events = {},
    eventHandlers = {},
    wowEventHandlers = {},
    selfCombatEventHandlers = {},
    CombatEventHandlers = {},
    frame = nil,
}
EventManager.__index = EventManager

-- Constructor
---@return EventManager
function EventManager:New()
    local self = setmetatable({}, EventManager)
    self.events = {}
    self.eventHandlers = {}
    self.wowEventHandlers = {}
    self.selfCombatEventHandlers = {}
    self.CombatEventHandlers = {}

    -- Frame for wow events
    self.frame = CreateFrame("Frame")

    self.frame:SetScript("OnEvent", function(f, event, ...)
        if self.wowEventHandlers[event] then
            for _, callback in ipairs(self.wowEventHandlers[event]) do
                callback(...)
            end
        end
    end)

    self:RegisterWoWEvent("COMBAT_LOG_EVENT_UNFILTERED", function()
        self:CLEUHandler(CombatLogGetCurrentEventInfo())
    end)

    return self
end

-- Register an event
---@param event string
---@param handler fun(...)
---@return nil
function EventManager:RegisterEvent(event, handler)
    if not self.events[event] then
        self.events[event] = {}
    end

    table.insert(self.events[event], handler)
end

-- Register a wow event
---@param event string | string[]
---@param handler fun(...)
---@return nil
function EventManager:RegisterWoWEvent(event, handler)
    if type(event) == "table" then
        for _, e in ipairs(event) do
            if not self.wowEventHandlers[e] then
                self.wowEventHandlers[e] = {}
                self.frame:RegisterEvent(e)
            end

            table.insert(self.wowEventHandlers[e], handler)
        end
    else
        if not self.wowEventHandlers[event] then
            self.wowEventHandlers[event] = {}
            self.frame:RegisterEvent(event)
        end

        table.insert(self.wowEventHandlers[event], handler)
    end
end

-- Trigger an event
---@param event string
---@param ... any
---@return nil
function EventManager:TriggerEvent(event, ...)
    if self.events[event] then
        for _, handler in pairs(self.events[event]) do
            handler(...)
        end
    end
end

---@param subevent string | string[]
---@param handler fun(...)
function EventManager:RegisterSelfCombatEvent(subevent, handler)
    if type(subevent) == "string" then
        subevent = { subevent }
    end
    for _, e in ipairs(subevent) do
        if not self.selfCombatEventHandlers[e] then
            self.selfCombatEventHandlers[e] = {}
        end

        table.insert(self.selfCombatEventHandlers[e], handler)
    end
end

---@param subevent string | string[]
---@param handler fun(...)
function EventManager:RegisterCombatEvent(subevent, handler)
    if type(subevent) == "string" then
        subevent = { subevent }
    end
    for _, e in ipairs(subevent) do
        if not self.CombatEventHandlers[e] then
            self.CombatEventHandlers[e] = {}
        end

        table.insert(self.CombatEventHandlers[e], handler)
    end
end

---@param timestamp number
---@param subevent string
---@param ... any
function EventManager:CLEUHandler(timestamp, subevent, ...)
    if self.selfCombatEventHandlers[subevent] and select(2, ...) == UnitGUID("player") then
        for _, callback in ipairs(self.selfCombatEventHandlers[subevent]) do
            callback(timestamp, subevent, ...)
        end
    end
    if self.CombatEventHandlers[subevent] then
        for _, callback in ipairs(self.CombatEventHandlers[subevent]) do
            callback(timestamp, subevent, ...)
        end
    end
end

return EventManager