spearhead/src/classes/spearhead_events.lua

local Logger = require("classes.util.Logger")
local Persistence = require("classes.persistence.Persistence")
local DcsUtil = require("classes.util.DcsUtil")

---@class SpearheadEvents
local SpearheadEvents = {}
do

    ---@type Logger
    local logger = nil

    ---@param logLevel LogLevel
    SpearheadEvents.Init = function(logLevel)
        logger = Logger.new("Events", logLevel)
    end

    local warn = function(text)
        if logger then
            logger:warn(text)
        end
    end

    local logError = function(text)
        if logger then logger:error(text) end
    end

    local logDebug = function(text)
        if logger then logger:debug(text) end
    end

    ---@class OnStageChangedListener
    ---@field OnStageNumberChanged fun(self:OnStageChangedListener, number:integer, laneIdentifier:string?)

    do -- STAGE NUMBER CHANGED
        ---@type Array<OnStageChangedListener>
        local OnStageNumberChangedListeners = {}
        ---@type Array<fun(number:integer, laneIdentifier:string?)>
        local OnStageNumberChangedHandlers = {}
        ---Add a stage zone number changed listener
        ---@param listener OnStageChangedListener object with function OnStageNumberChanged(self, number, stageLaneIdentifier)
        SpearheadEvents.AddStageNumberChangedListener = function(listener)
            if type(listener) ~= "table" or type(listener.OnStageNumberChanged) ~= "function" then
                warn("Event handler not of type table/object with function OnStageNumberChanged(self, number, stageLaneIdentifier)")
                return
            end
            table.insert(OnStageNumberChangedListeners, listener)
        end

        ---@class OnStageNumberChangeCompleteListener
        ---@field OnStageNumberChangeComplete fun(self:OnStageNumberChangeCompleteListener, number:integer, laneIdentifier:string?)

        ---@type Array<OnStageNumberChangeCompleteListener>
        local OnStageNumberChangeCompleteListeners = {}
        ---@param listener OnStageNumberChangeCompleteListener
        SpearheadEvents.AddStageNumberChangeCompleteListener = function(listener)
            if type(listener) ~= "table" or type(listener.OnStageNumberChangeComplete) ~= "function" then
                warn("Event handler not of type table/object with function OnStageNumberChangeComplete(self, number, laneIdentifier)")
                return
            end
            table.insert(OnStageNumberChangeCompleteListeners, listener)
        end

        ---@param newStageNumber number
        ---@param laneIdentifier string?
        SpearheadEvents.PublishStageNumberChanged = function(newStageNumber, laneIdentifier)
            pcall(function ()
                Persistence.SetActiveStage(laneIdentifier, newStageNumber)
            end)

            for _, callable in pairs(OnStageNumberChangedListeners) do
                local _, err = pcall(function()
                    callable:OnStageNumberChanged(newStageNumber, laneIdentifier)
                end)
                if err then
                    logError(err)
                end
            end

            for _, callable in pairs(OnStageNumberChangedHandlers) do
                local _, err = pcall(callable, newStageNumber, laneIdentifier)
                if err then
                    logError(err)
                end
            end

            for _, callable in pairs(OnStageNumberChangeCompleteListeners) do
                local _, err = pcall(function()
                    callable:OnStageNumberChangeComplete(newStageNumber, laneIdentifier)
                end)
                if err then
                    logError(err)
                end
            end

            Logger.new("Events", "INFO"):info("Published stage number changed to: " .. tostring(newStageNumber))
        end
    end

    ---@class OnWeaponFiredListener
    ---@field OnWeaponFired fun(self:OnWeaponFiredListener, unit:Unit?, weapon:Weapon?, target:Object?)

    ---@type Array<OnWeaponFiredListener>
    local onWeaponFiredListeners = {}

    ---comment
    ---@param weaponFiredListener OnWeaponFiredListener
    SpearheadEvents.AddWeaponFiredListener = function(weaponFiredListener)
        if type(weaponFiredListener) ~= "table" then
            warn("Event handler not of type table/object")
            return
        end

        table.insert(onWeaponFiredListeners, weaponFiredListener)
    end

    ---@param unit Unit
    ---@param weapon Weapon
    ---@param target Unit?
    local triggerWeaponFired = function(unit, weapon, target)
        for _, callable in pairs(onWeaponFiredListeners) do
            local _, err = pcall(function()
                callable:OnWeaponFired(unit, weapon, target)
            end)

            if err then
                logError(err)
            end
        end
    end

    ---@class OnLandEventListener
    ---@field OnUnitLanded fun(self:OnLandEventListener, initiatorUnit:Unit, airbase:Airbase)

    ---@type table<string,Array<OnLandEventListener>>
    local onLandEventListeners = {}
    ---Add an event listener to a specific unit
    ---@param unitName string to call when the unit lands
    ---@param landListener OnLandEventListener table with function OnUnitLanded(self, initiatorUnit, airbase)
    SpearheadEvents.addOnUnitLandEventListener = function(unitName, landListener)
        if type(landListener) ~= "table" then
            warn("Event handler not of type table/object")
            return
        end

        if onLandEventListeners[unitName] == nil then
            onLandEventListeners[unitName] = {}
        end
        table.insert(onLandEventListeners[unitName], landListener)
    end

    ---@class OnUnitLostListener
    ---@field OnUnitLost fun(self:OnUnitLostListener, unit:table)

    ---@type table<string,Array<OnUnitLostListener>>
    local OnUnitLostListeners = {}
    ---This listener gets fired for any event that can indicate a loss of a unit.
    ---Such as: Eject, Crash, Dead, Unit_Lost,
    ---@param unitName any
    ---@param unitLostListener OnUnitLostListener 
    SpearheadEvents.addOnUnitLostEventListener = function(unitName, unitLostListener)
        if type(unitLostListener) ~= "table" then
            warn("Unit lost Event listener not of type table/object")
            return
        end

        if OnUnitLostListeners[unitName] == nil then
            OnUnitLostListeners[unitName] = {}
        end

        table.insert(OnUnitLostListeners[unitName], unitLostListener)
    end

    do -- ON RTB

        ---@class OnGroupRTBListener
        ---@field OnGroupRTB fun(self:OnGroupRTBListener, groupName:string)

        ---@type table<string,Array<OnGroupRTBListener>>
        local OnGroupRTBListeners = {}
        ---Adds a function to the events listener that triggers when a group publishes themselves RTB.
        ---This is only available when a ROUTE is created via the Spearhead.RouteUtil
        ---@param groupName string the groupname to expect
        ---@param handlingObject table object with OnGroupRTB(self, groupName)
        SpearheadEvents.addOnGroupRTBListener = function(groupName, handlingObject)
            if type(handlingObject) ~= "table" then
                warn("Event handler not of type table/object")
                return
            end

            if OnGroupRTBListeners[groupName] == nil then
                OnGroupRTBListeners[groupName] = {}
            end

            table.insert(OnGroupRTBListeners[groupName], handlingObject)
        end

        ---Publish the Group to RTB
        ---@param groupName string
        SpearheadEvents.PublishRTB = function(groupName)
            if groupName ~= nil then
                if OnGroupRTBListeners[groupName] then
                    for _, callable in pairs(OnGroupRTBListeners[groupName]) do
                        local _, err = pcall(function()
                            callable:OnGroupRTB(groupName)
                        end)
                        if err then
                            logError(err)
                        end
                    end
                end
            end
        end

        ---@class OnGroupRTBInTenListener
        ---@field OnGroupRTBInTen fun(self:OnGroupRTBInTenListener, groupName:string)

        ---@type table<string,Array<OnGroupRTBInTenListener>>
        local OnGroupRTBInTenListeners = {}
        ---Adds a function to the events listener that triggers when a group publishes themselves RTB.
        ---This is only available when a ROUTE is created via the Spearhead.RouteUtil
        ---@param groupName string the groupname to expect
        ---@param handlingObject OnGroupRTBInTenListener object with OnGroupRTBInTen(self, groupName)
        SpearheadEvents.addOnGroupRTBInTenListener = function(groupName, handlingObject)
            if type(handlingObject) ~= "table" then
                warn("Event handler not of type table/object")
                return
            end

            if OnGroupRTBInTenListeners[groupName] == nil then
                OnGroupRTBInTenListeners[groupName] = {}
            end

            table.insert(OnGroupRTBInTenListeners[groupName], handlingObject)
        end

        ---Publish the Group is RTB
        ---@param groupName string
        SpearheadEvents.PublishRTBInTen = function(groupName)
            if groupName ~= nil then
                if OnGroupRTBInTenListeners[groupName] then
                    for _, callable in pairs(OnGroupRTBInTenListeners[groupName]) do
                        local _, err = pcall(function()
                            callable:OnGroupRTBInTen(groupName)
                        end)
                        if err then
                            logError(err)
                        end
                    end
                end
            end
        end
    end

    do -- ON Station

        ---@class OnGroupOnStationListener
        ---@field OnGroupOnStation fun(self:OnGroupOnStationListener, groupName:string)

        ---@type table<string,Array<OnGroupOnStationListener>>
        local OnGroupOnStationListeners = {}

        ---Adds a function to the events listener that triggers when a group publishes themselves RTB.
        ---This is only available when a ROUTE is created via the Spearhead.RouteUtil
        ---@param groupName string the groupname to expect
        ---@param handlingObject OnGroupOnStationListener object with OnGroupOnStation(self, groupName)
        SpearheadEvents.addOnGroupOnStationListener = function(groupName, handlingObject)
            if type(handlingObject) ~= "table" then
                warn("Event handler not of type table/object")
                return
            end

            if OnGroupOnStationListeners[groupName] == nil then
                OnGroupOnStationListeners[groupName] = {}
            end

            table.insert(OnGroupOnStationListeners[groupName], handlingObject)
        end

        ---Publish the Group to RTB
        ---@param groupName string
        SpearheadEvents.PublishOnStation = function(groupName)
            if groupName ~= nil then
                if OnGroupOnStationListeners[groupName] then
                    for _, callable in pairs(OnGroupOnStationListeners[groupName]) do
                        local _, err = pcall(function()
                            callable:OnGroupOnStation(groupName)
                        end)
                        if err then
                            logError(err)
                        end
                    end
                end
            end
        end
    end

    do -- PLAYER ENTER UNIT
        ---@class OnPlayerEnterUnitListener
        ---@field OnPlayerEntersUnit fun(self:OnPlayerEnterUnitListener, unit:Unit)

        ---@type Array<OnPlayerEnterUnitListener>
        local playerEnterUnitListeners = {}
        ---comment
        ---@param listener OnPlayerEnterUnitListener object with OnPlayerEntersUnit(self, unit)
        SpearheadEvents.AddOnPlayerEnterUnitListener = function(listener)
            if type(listener) ~= "table" then
                warn("Unit lost Event listener not of type table/object")
                return
            end
            table.insert(playerEnterUnitListeners, listener)
        end

        SpearheadEvents.TriggerPlayerEntersUnit = function(unit)
            if unit ~= nil then
                if playerEnterUnitListeners then
                    for _, callable in pairs(playerEnterUnitListeners) do
                        local _, err = pcall(function()
                            callable:OnPlayerEntersUnit(unit)
                        end)
                        if err then
                            logError(err)
                        end
                    end
                end
            end
        end
    end

    do -- Ejection events

        local unitEjectListeners = {}
        SpearheadEvents.AddOnUnitEjectedListener = function(listener)
            if type(listener) ~= "table" then
                warn("Unit lost Event listener not of type table/object")
                return
            end

            table.insert(unitEjectListeners, listener)
        end

    end

    local e = {}
    function e:onEvent(event)
        if event.id == world.event.S_EVENT_LAND or event.id == world.event.S_EVENT_RUNWAY_TOUCH then
            local unit = event.initiator --[[@as Unit]]
            local airbase = event.place --[[@as Airbase]]
            if unit ~= nil then
                local name = unit:getName()
                if onLandEventListeners[name] then
                    for _, callable in pairs(onLandEventListeners[name]) do
                        local _, err = pcall(function()
                            callable:OnUnitLanded(unit, airbase)
                        end)
                        if err then
                            logError(err)
                        end
                    end
                end
            end
        end

        if event.id == world.event.S_EVENT_DEAD or
            event.id == world.event.S_EVENT_CRASH or
            event.id == world.event.S_EVENT_EJECTION or
            event.id == world.event.S_EVENT_UNIT_LOST then
            local object = event.initiator --[[@as Unit]]

            if object and object.getName then
                logDebug("Receiving death event from: " .. object:getName())
            end

            if object and object.getName and OnUnitLostListeners[object:getName()] then
                for _, callable in pairs(OnUnitLostListeners[object:getName()]) do
                    local _, err = pcall(function()
                        callable:OnUnitLost(object)
                    end)

                    if err then
                        logError(err)
                    end
                end
            end
        end

        if event.id == world.event.S_EVENT_SHOT then

            local shooter = event.initiator --[[@as Unit]]
            local weapon = event.weapon --[[@as Weapon]]
            local target = event.target --[[@as Unit?]]
            triggerWeaponFired(shooter, weapon, target)

        end

        if event.id == world.event.S_EVENT_MISSION_END then
            Persistence.UpdateNow()
        end

        ---@type table<string, boolean>
        local AI_GROUPS = {}

        ---@param unit Unit
        ---@param _ any
        local function CheckAndTriggerSpawnAsync(unit, _)
            ---@param checkUnit Unit
            ---@return boolean, string?
            local function isPlayer(checkUnit)
                if checkUnit == nil then return false, "unit is nil" end
                if checkUnit.getGroup == nil then return false, 'no get group function in unit object, most likely static' end
                if Object.getCategory(checkUnit) ~= Object.Category.UNIT then
                    return false, "object is not a unit"
                end

                if checkUnit:isExist() ~= true then return false, "unit does not exist" end
                local group = checkUnit:getGroup()
                if group ~= nil then
                    if AI_GROUPS[group:getName()] == true then
                        return false
                    end

                    local players = DcsUtil.getAllPlayerUnits()
                    local unitName = checkUnit:getName()
                    for _, playerUnit in pairs(players) do
                        if playerUnit:getName() == unitName then
                            return true
                        end
                    end
                    AI_GROUPS[group:getName()] = true
                end
                return false, "unit is nil or does not exist"
            end

            if isPlayer(unit) == true then
                SpearheadEvents.TriggerPlayerEntersUnit(unit)
            end
        end

        if event.id == world.event.S_EVENT_BIRTH then
            timer.scheduleFunction(CheckAndTriggerSpawnAsync, event.initiator, timer.getTime() + 3)
        end
    end

    world.addEventHandler(e)
end

return SpearheadEvents