CastTracker.lua

local _, ns = ...

local MAX_BOSS_UNITS = 5
local MAX_NAMEPLATE_UNITS = 40

local activeCards = {}
local cardsByCastBarID = {}
local currentCardByUnit = {}
local unitListeners = {}
local lifecycleFrame
local cachedTargetAbilities

local startEvents = {
    "UNIT_SPELLCAST_START",
    "UNIT_SPELLCAST_CHANNEL_START",
    "UNIT_SPELLCAST_EMPOWER_START",
}

local stopEvents = {
    "UNIT_SPELLCAST_STOP",
    "UNIT_SPELLCAST_FAILED",
    "UNIT_SPELLCAST_FAILED_QUIET",
    "UNIT_SPELLCAST_INTERRUPTED",
    "UNIT_SPELLCAST_CHANNEL_STOP",
    "UNIT_SPELLCAST_EMPOWER_STOP",
}

local isStartEvent = {
    UNIT_SPELLCAST_START = true,
    UNIT_SPELLCAST_CHANNEL_START = true,
    UNIT_SPELLCAST_EMPOWER_START = true,
}

local castBarIDInFifthArgument = {
    UNIT_SPELLCAST_INTERRUPTED = true,
    UNIT_SPELLCAST_CHANNEL_STOP = true,
}

local function IsNameplateUnit(unit)
    local index = string.match(unit, "^nameplate(%d+)$")
    index = tonumber(index)
    return index and index >= 1 and index <= MAX_NAMEPLATE_UNITS
end

local function IsBossUnit(unit)
    local index = string.match(unit, "^boss(%d+)$")
    index = tonumber(index)
    return index and index >= 1 and index <= MAX_BOSS_UNITS
end

local function IsEnabledUnit(unit)
    local db = ns.GetDatabase()
    if unit == "target" then
        return db.trackTarget
    elseif unit == "focus" then
        return db.trackFocus
    elseif IsBossUnit(unit) then
        return db.trackBosses
    elseif IsNameplateUnit(unit) then
        return db.trackNameplates
    end

    return false
end

local function IsHostileUnit(unit)
    local canAttack = UnitCanAttack("player", unit)
    if issecretvalue(canAttack) then
        return false
    end

    return canAttack == true
end

local function RefreshDisplay()
    if ns.editModeActive then
        return
    end

    local db = ns.GetDatabase()
    if not db.enabled then
        ns.HideSpellCards()
        return
    end

    local activeCount = #activeCards
    if activeCount > 0 then
        ns.ShowTimedSpellCards(activeCards, math.min(activeCount, db.maximumVisibleTooltips))
        return
    end

    if db.showTargetAbilities and cachedTargetAbilities then
        ns.ShowTargetSpellCards(
            cachedTargetAbilities,
            math.min(#cachedTargetAbilities, db.maximumVisibleTooltips)
        )
        return
    end

    ns.HideSpellCards()
end

local function CancelTimer(timer)
    if timer then
        timer:Cancel()
    end
end

local function RemoveCard(card, suppressRefresh)
    if not card.inQueue then
        return
    end

    card.inQueue = false
    CancelTimer(card.minimumTimer)
    card.minimumTimer = nil

    if card.castBarID ~= nil and cardsByCastBarID[card.castBarID] == card then
        cardsByCastBarID[card.castBarID] = nil
    end
    if currentCardByUnit[card.unit] == card then
        currentCardByUnit[card.unit] = nil
    end

    for index = #activeCards, 1, -1 do
        if activeCards[index] == card then
            table.remove(activeCards, index)
            break
        end
    end

    card.spellID = nil
    if not suppressRefresh then
        RefreshDisplay()
    end
end

local function TryExpireCard(card)
    if card.inQueue and card.castEnded and card.minimumElapsed then
        RemoveCard(card)
    end
end

local function ScheduleMinimumTimer(card)
    CancelTimer(card.minimumTimer)
    card.minimumTimer = nil

    local duration = ns.GetDatabase().minimumDisplayTime
    local remaining = duration - (GetTime() - card.startedAt)
    if remaining <= 0 then
        card.minimumElapsed = true
        TryExpireCard(card)
        return
    end

    card.minimumElapsed = false
    card.minimumTimer = C_Timer.NewTimer(remaining, function()
        card.minimumTimer = nil
        card.minimumElapsed = true
        TryExpireCard(card)
    end)
end

local function MarkCardEnded(card)
    if not card or not card.inQueue then
        return
    end

    card.castEnded = true
    if currentCardByUnit[card.unit] == card then
        currentCardByUnit[card.unit] = nil
    end
    TryExpireCard(card)
end

local function EnforceVisibleLimit()
    local limit = ns.GetDatabase().maximumVisibleTooltips
    while #activeCards > limit do
        RemoveCard(activeCards[#activeCards], true)
    end
end

local function AddCastCard(unit, spellID, castBarID)
    local db = ns.GetDatabase()
    if not db.enabled or not IsEnabledUnit(unit) or not IsHostileUnit(unit) then
        return
    end

    if castBarID ~= nil and cardsByCastBarID[castBarID] then
        return
    end

    MarkCardEnded(currentCardByUnit[unit])

    local card = {
        unit = unit,
        spellID = spellID,
        castBarID = castBarID,
        startedAt = GetTime(),
        castEnded = false,
        minimumElapsed = false,
        inQueue = true,
    }

    table.insert(activeCards, 1, card)
    currentCardByUnit[unit] = card
    if castBarID ~= nil then
        cardsByCastBarID[castBarID] = card
    end

    ScheduleMinimumTimer(card)
    EnforceVisibleLimit()
    RefreshDisplay()
end

local function EndCastCard(unit, castBarID)
    local card
    if castBarID ~= nil then
        card = cardsByCastBarID[castBarID]
    else
        card = currentCardByUnit[unit]
    end
    MarkCardEnded(card)
end

local function RemoveCardsForUnit(unit)
    for index = #activeCards, 1, -1 do
        local card = activeCards[index]
        if card.unit == unit then
            RemoveCard(card, true)
        end
    end
    currentCardByUnit[unit] = nil
    RefreshDisplay()
end

local function EndCurrentCardForUnit(unit)
    MarkCardEnded(currentCardByUnit[unit])
end

local function ClearAllCards()
    for index = #activeCards, 1, -1 do
        RemoveCard(activeCards[index], true)
    end

    wipe(cardsByCastBarID)
    wipe(currentCardByUnit)
    RefreshDisplay()
end

local function ResolveTargetAbilities()
    cachedTargetAbilities = nil

    local db = ns.GetDatabase()
    if not db.enabled or not db.showTargetAbilities then
        return
    end
    if not UnitExists("target") or not IsHostileUnit("target") then
        return
    end

    local creatureID = UnitCreatureID("target")
    if issecretvalue(creatureID) then
        return
    end
    if creatureID then
        cachedTargetAbilities = ns.TargetAbilityData[creatureID]
    end
end

local function HandleUnitEvent(unit, event, payloadUnit, castGUID, spellID, fourthArgument, fifthArgument, sixthArgument)
    if isStartEvent[event] then
        AddCastCard(unit, spellID, fourthArgument)
        return
    end

    local castBarID
    if event == "UNIT_SPELLCAST_EMPOWER_STOP" then
        castBarID = sixthArgument
    elseif castBarIDInFifthArgument[event] then
        castBarID = fifthArgument
    else
        castBarID = fourthArgument
    end
    EndCastCard(unit, castBarID)
end

local function CreateUnitListener(unit)
    local frame = CreateFrame("Frame")
    for _, event in ipairs(startEvents) do
        frame:RegisterUnitEvent(event, unit)
    end
    for _, event in ipairs(stopEvents) do
        frame:RegisterUnitEvent(event, unit)
    end

    frame:SetScript("OnEvent", function(_, event, ...)
        -- The payload unit, cast GUID, and spell ID may be secret. The known
        -- listener token is used instead, and only castBarID is correlated.
        HandleUnitEvent(unit, event, ...)
    end)
    unitListeners[#unitListeners + 1] = frame
end

local function OnLifecycleEvent(_, event, unit)
    if event == "PLAYER_TARGET_CHANGED" then
        EndCurrentCardForUnit("target")
        ResolveTargetAbilities()
        RefreshDisplay()
    elseif event == "PLAYER_FOCUS_CHANGED" then
        EndCurrentCardForUnit("focus")
    elseif event == "UNIT_NAME_UPDATE" then
        if not cachedTargetAbilities then
            ResolveTargetAbilities()
            RefreshDisplay()
        end
    elseif event == "NAME_PLATE_UNIT_REMOVED" then
        if not issecretvalue(unit) and type(unit) == "string" and IsNameplateUnit(unit) then
            RemoveCardsForUnit(unit)
        end
    elseif event == "INSTANCE_ENCOUNTER_ENGAGE_UNIT" then
        for index = 1, MAX_BOSS_UNITS do
            local bossUnit = "boss" .. index
            if not UnitExists(bossUnit) then
                RemoveCardsForUnit(bossUnit)
            end
        end
    elseif event == "PLAYER_ENTERING_WORLD" then
        cachedTargetAbilities = nil
        ClearAllCards()
        ResolveTargetAbilities()
        RefreshDisplay()
    end
end

function ns.InitializeCastTracker()
    CreateUnitListener("target")
    CreateUnitListener("focus")
    for index = 1, MAX_BOSS_UNITS do
        CreateUnitListener("boss" .. index)
    end
    for index = 1, MAX_NAMEPLATE_UNITS do
        CreateUnitListener("nameplate" .. index)
    end

    lifecycleFrame = CreateFrame("Frame")
    lifecycleFrame:RegisterEvent("PLAYER_TARGET_CHANGED")
    lifecycleFrame:RegisterEvent("PLAYER_FOCUS_CHANGED")
    lifecycleFrame:RegisterUnitEvent("UNIT_NAME_UPDATE", "target")
    lifecycleFrame:RegisterEvent("NAME_PLATE_UNIT_REMOVED")
    lifecycleFrame:RegisterEvent("INSTANCE_ENCOUNTER_ENGAGE_UNIT")
    lifecycleFrame:RegisterEvent("PLAYER_ENTERING_WORLD")
    lifecycleFrame:SetScript("OnEvent", OnLifecycleEvent)

    ResolveTargetAbilities()
    RefreshDisplay()
end

function ns.RefreshCastDisplay()
    RefreshDisplay()
end

function ns.OnSettingsChanged()
    ns.OnPartyDebuffSettingsChanged()

    local db = ns.GetDatabase()
    if not db.enabled then
        cachedTargetAbilities = nil
        ClearAllCards()
        return
    end

    for index = #activeCards, 1, -1 do
        local card = activeCards[index]
        if not IsEnabledUnit(card.unit) then
            RemoveCard(card, true)
        end
    end

    for index = #activeCards, 1, -1 do
        local card = activeCards[index]
        if card.inQueue then
            ScheduleMinimumTimer(card)
        end
    end

    EnforceVisibleLimit()
    if not db.showTargetAbilities then
        cachedTargetAbilities = nil
    elseif not cachedTargetAbilities then
        ResolveTargetAbilities()
    end
    RefreshDisplay()
end