GreedMeter/Parser/API.lua

--[[
    GreedMeter - Parser / API
    Shared data plane: AddDamage/AddMiss/..., segments, combat lifecycle,
    GUID helpers. Chat and Nampower backends call Parser methods defined here.
]]

local OM = GreedMeter
local Parser = {}
GreedMeter.ParserNS = GreedMeter.ParserNS or {}
GreedMeter.ParserNS.Parser = Parser

-- Lua 5.0 allows only 32 upvalues per function. Keep shared helpers/state on
-- these tables so large functions (ParseMessage, etc.) close over ~1-2 upvalues.
local H = {} -- helper bag
local ST = {} -- fight/parser state bag
H.getPlayerName = function() return ST.playerName or UnitName("player") end
H.NormalizeName = function(n) return n end -- replaced after real NormalizeName exists

-- ============================================================
-- Data storage (per segment)
-- ============================================================

OM.data = {
    current = { players = {}, ccTargets = {}, startTime = 0, endTime = 0, label = "Current" },
    overall = { players = {}, ccTargets = {}, startTime = 0, endTime = 0, label = "Overall" },
    -- Last 2 fights of any kind (newest first)
    recentFights = {},
    -- Last 3 boss fights (newest first)
    bossFights = {},
}

local MAX_RECENT_FIGHTS = 3
local MAX_BOSS_FIGHTS = 5

-- Soft caps on per-player detail lists so overall / long sessions stay bounded.
-- Counts remain accurate; only the stored event history is trimmed (oldest first).
local MAX_DETAIL_LIST = 80   -- dispels / interrupts / ccBreaks / per-enemy CC applications
local MAX_DEATHS_LIST = 40

-- Per-fight enemy tracking for naming + boss detection (on ST for upvalue relief)
ST.fightEnemies = {}        -- [name] = damage dealt to them by group
ST.fightEnemyDeaths = {}    -- [name] = how many times this name died this fight
ST.fightDuplicateNames = {} -- [name] = true if name is not unique (pack trash)
ST.fightEnemyBossLike = {}  -- [name] = true if UnitLooksLikeBoss while hitting them
ST.fightIsBoss = false
ST.fightBossName = nil

-- ============================================================
-- Helpers
-- ============================================================

ST.playerName = nil
local playerName = nil -- mirrored; prefer ST.playerName in new code

-- Optional mode gates (Advanced Customization "Enabled" checkboxes).
-- Disabled modes skip storing metrics to save CPU/memory.
local function ModeEnabled(mode)
    local UI = GreedMeter and GreedMeter.UI
    if UI and UI.IsModeEnabled then
        return UI.IsModeEnabled(mode)
    end
    return true
end


-- Resolve "You" and SuperWoW-style pet ownership names
local function NormalizeName(name)
    if not name or name == "" then return nil end
    if type(name) ~= "string" then name = tostring(name) end
    -- Strip residual GUID/color codes if any slipped through
    name = string.gsub(name, "|c%x%x%x%x%x%x%x%x", "")
    name = string.gsub(name, "|r", "")
    name = string.gsub(name, "^%s+", "")
    name = string.gsub(name, "%s+$", "")
    if name == "" then return nil end
    if name == "you" or name == "You" or name == "YOU" then
        return ST.playerName or UnitName("player")
    end
    -- Reject combat-log keywords that bad pattern captures treat as "targets"
    local lower = string.lower(name)
    local BAD = {
        hit=true, hits=true, crit=true, crits=true,
        miss=true, misses=true, missed=true,
        dodge=true, dodges=true, parry=true, parries=true,
        block=true, blocks=true, blocked=true,
        resist=true, resists=true, resisted=true,
        glance=true, glancing=true, crush=true, crushing=true,
        absorb=true, absorbs=true, absorbed=true,
        by=true, from=true, ["for"]=true, with=true, to=true, ["on"]=true,
        you=true, your=true, attack=true, attacks=true,
        of=true, the=true, a=true, an=true, is=true, are=true,
        damage=true, healing=true, heal=true, heals=true, healed=true,
        performs=true, casts=true, gains=true, fades=true,
        suffers=true, afflicted=true, reflects=true, reflected=true,
        partial=true, falls=true, dies=true, slain=true,
        begins=true, able=true, unable=true,
    }
    if BAD[lower] then return nil end
    -- Single-character / pure-number captures are never unit names
    if string.len(name) <= 1 then return nil end
    if tonumber(name) then return nil end
    -- SuperWoW: "PetName (OwnerName)" or "Searing Totem (Shaman)"
    local _, _, pet, owner = string.find(name, "^(.+) %((.+)%)$")
    if pet and owner then
        if OM.SetPetOwner then
            OM:SetPetOwner(pet, owner)
        end
        -- Log already named the owner ("Bear (Alice)"). Use it so two
        -- default-named pets in the group are not collapsed onto one hunter.
        if OM.players and OM.players[owner] then
            return owner
        end
        return pet
    end
    return name
end


-- Exact match first, then substring (handles rank suffixes / variants).
-- Used by absorb / interrupt / dispel / CC spell tables.
H.NormalizeName = NormalizeName

local function SpellLookup(set, spell)
    if not spell or not set then return nil end
    local v = set[spell]
    if v ~= nil then return v end
    local name, val
    for name, val in pairs(set) do
        if string.find(spell, name, 1, true) then
            return val
        end
    end
    return nil
end

local function SpellInSet(set, spell)
    return SpellLookup(set, spell) ~= nil
end

-- Iterate player + party + raid unit tokens once.
local function ForEachGroupUnit(fn)
    if not fn then return end
    fn("player")
    local i
    for i = 1, 4 do
        fn("party" .. i)
    end
    if GetNumRaidMembers() > 0 then
        for i = 1, 40 do
            fn("raid" .. i)
        end
    end
end

-- ============================================================
-- SuperWoW helpers (preferred path when available)
-- ============================================================
local guidToName = {}
local nameToGuid = {}

local function SuperWoWAvailable()
    if OM and OM.HasSuperWoW then
        return OM:HasSuperWoW()
    end
    return (SUPERWOW_VERSION or SUPERWOW_STRING or SuperWoW) and true or false
end

local function CacheGuid(name, guid)
    if not name or name == "" or not guid or guid == "" then return end
    -- Never cache combat-log keywords / invalid captures (poisoned GUID maps
    -- showed up as Targets like "hit", "crits", "missed" when Nampower was on).
    name = NormalizeName(name)
    if not name then return end
    guidToName[guid] = name
    nameToGuid[name] = guid
end


-- Strip SuperWoW GUID tokens from a combat log line while caching them
-- Handles forms like: 0xF130..., player-..., and trailing GUID chunks
local function StripAndCacheGuids(msg)
    if not msg then return msg end
    local cleaned = msg
    -- Cache "Name 0xGUID" pairs before stripping (only 0x-prefixed GUIDs)
    local pos = 1
    while true do
        local s, e, name, guid = string.find(cleaned, "([%w'-]+)%s+(0[xX]%x+)", pos)
        if not s then break end
        if string.len(guid) >= 10 then
            CacheGuid(name, guid)
        end
        pos = e + 1
    end
    -- Remove only 0x-prefixed GUID tokens — never bare numbers (those are damage amounts)
    cleaned = string.gsub(cleaned, "%s*0[xX]%x%x%x%x%x%x%x%x+", "")
    return cleaned
end

local function RefreshGuidCacheFromUnits()
    if not SuperWoWAvailable() then return end
    local function scan(unit)
        if not UnitExists(unit) then return end
        local name = UnitName(unit)
        local guid = nil
        if type(UnitGUID) == "function" then
            guid = UnitGUID(unit)
        else
            -- SuperWoW: UnitExists returns GUID as 2nd value
            local ok, g = UnitExists(unit)
            if ok and g and type(g) == "string" and string.len(g) > 4 then
                guid = g
            end
        end
        if name and guid then
            CacheGuid(name, guid)
        end
        -- Pet
        local petUnit = unit
        if unit == "player" then
            petUnit = "pet"
        else
            local _, _, idx = string.find(unit, "^raid(%d+)$")
            if idx then
                petUnit = "raidpet" .. idx
            else
                local _, _, pidx = string.find(unit, "^party(%d+)$")
                if pidx then
                    petUnit = "partypet" .. pidx
                else
                    petUnit = nil
                end
            end
        end
        if petUnit and UnitExists(petUnit) then
            local pname = UnitName(petUnit)
            local pguid = nil
            if type(UnitGUID) == "function" then
                pguid = UnitGUID(petUnit)
            end
            if pname and pguid then
                CacheGuid(pname, pguid)
            end
            -- Ownership: map pet name to owner for ResolveSource
            if pname and name then
                OM.heuristicPets = OM.heuristicPets or {}
                OM.heuristicPets[pname] = name
            end
        end
    end
    scan("player")
    local i
    for i = 1, 4 do scan("party" .. i) end
    for i = 1, 40 do scan("raid" .. i) end
end

local function EnsurePlayer(segment, name)
    if not name or name == "" then return nil end
    local p = segment.players[name]
    if p then
        -- Refresh class from roster when known
        if OM.players and OM.players[name] and OM.players[name].class then
            p.class = OM.players[name].class
        end
        return p
    end
    local class = nil
    if OM.players and OM.players[name] then
        class = OM.players[name].class
    end
    p = {
        damage = 0,
        healing = 0,
        overhealing = 0,
        rawHealing = 0,
        absorbs = 0,
        damageTaken = 0,
        dispels = { count = 0, list = {} },
        interrupts = { count = 0, list = {} },
        ccBreaks = { count = 0, list = {} },
        deaths = { count = 0, list = {} },
        damageTakenBy = {},
        damageTo = {},
        healingTo = {},
        damageSpells = {},
        healSpells = {},
        damageSpellDetails = {},
        healSpellDetails = {},
        threatCasts = {},  -- non-damaging threat apps (Sunder, Demo Shout, ...)
        class = class,
    }
    segment.players[name] = p
    return p
end

-- Find a unit token for a player name (needed for health deficit / overheal)
local function FindUnitByName(name)
    if not name then return nil end
    if UnitName("player") == name then return "player" end
    for i = 1, 4 do
        local u = "party"..i
        if UnitExists(u) and UnitName(u) == name then return u end
    end
    if GetNumRaidMembers() > 0 then
        for i = 1, 40 do
            local u = "raid"..i
            if UnitExists(u) and UnitName(u) == name then return u end
        end
    end
    if UnitExists("target") and UnitName("target") == name then return "target" end
    if UnitExists("targettarget") and UnitName("targettarget") == name then return "targettarget" end
    return nil
end

-- Compute effective heal vs overheal using the target's current deficit
local function SplitOverheal(targetName, amount)
    amount = tonumber(amount) or 0
    if amount <= 0 then return 0, 0 end

    targetName = NormalizeName(targetName)
    local unit = FindUnitByName(targetName)
    if not unit then
        -- Unknown unit: count full amount as effective (avoid under-counting)
        return amount, 0
    end

    local maxhp = UnitHealthMax(unit)
    local curhp = UnitHealth(unit)
    if not maxhp or maxhp <= 0 then
        return amount, 0
    end

    local deficit = maxhp - curhp
    if deficit < 0 then deficit = 0 end

    local effective = amount
    local over = 0
    if amount > deficit then
        effective = deficit
        over = amount - deficit
    end
    return effective, over
end

local function ResolveSource(name)
    name = NormalizeName(name)
    if not name then return nil end

    -- Already a group player
    if OM.players[name] then
        return name
    end

    -- Pet → owner (roster, heuristic, or orphan assignment)
    local owner = OM:ResolvePetOwner(name)
    if owner then
        return owner
    end

    return name
end

local function IsTracked(name)
    if not name then return false end
    if OM.players[name] then return true end
    -- Known pet names only (unit-token / roster). Never invent ownership here.
    if OM:GetPetOwner(name) then return true end
    return false
end

-- ============================================================
-- Absorb shield tracking
-- Credits absorbed damage as healing to the shield provider when known.
-- ============================================================

local ABSORB_SHIELDS = {
    ["Power Word: Shield"] = true,
    ["Ice Barrier"] = true,
    ["Mana Shield"] = true,
    ["Sacrifice"] = true,
    ["Frost Ward"] = true,
    ["Fire Ward"] = true,
}

-- ST.absorbAuras[targetName] = { [shieldName] = applicatorName }
ST.absorbAuras = {}
-- ST.recentAbsorbCaster[spellName] = { name = "Caster", time = GetTime() }
ST.recentAbsorbCaster = {}
-- ST.recentShieldByTarget[targetName] = { caster = "Caster", spell = "...", time = GetTime() }
ST.recentShieldByTarget = {}
local RECENT_CASTER_TIMEOUT = 8

local function IsAbsorbShield(spell)
    return SpellInSet(ABSORB_SHIELDS, spell)
end

local function NoteRecentAbsorbCaster(spell, caster, target)
    if not spell or not caster or not IsAbsorbShield(spell) then return end
    caster = NormalizeName(caster)
    ST.recentAbsorbCaster[spell] = {
        name = caster,
        time = GetTime(),
    }
    target = NormalizeName(target)
    if target then
        ST.recentShieldByTarget[target] = {
            caster = caster,
            spell = spell,
            time = GetTime(),
        }
    end
end

local function GetRecentAbsorbCaster(spell)
    if not spell then return nil end
    local entry = ST.recentAbsorbCaster[spell]
    if not entry then
        for s, e in pairs(ST.recentAbsorbCaster) do
            if string.find(spell, s, 1, true) or string.find(s, spell, 1, true) then
                entry = e
                break
            end
        end
    end
    if entry and (GetTime() - entry.time) <= RECENT_CASTER_TIMEOUT then
        return entry.name
    end
    return nil
end

local function SetAbsorbAura(target, spell, applicator)
    target = NormalizeName(target)
    applicator = NormalizeName(applicator)
    if not target or not spell or not applicator then return end
    if not ST.absorbAuras[target] then
        ST.absorbAuras[target] = {}
    end
    ST.absorbAuras[target][spell] = applicator
end

local function ClearAbsorbAura(target, spell)
    target = NormalizeName(target)
    if not target or not ST.absorbAuras[target] then return end
    if spell then
        for name, _ in pairs(ST.absorbAuras[target]) do
            if name == spell or string.find(name, spell, 1, true) or string.find(spell, name, 1, true) then
                ST.absorbAuras[target][name] = nil
            end
        end
        local empty = true
        for _ in pairs(ST.absorbAuras[target]) do empty = false break end
        if empty then ST.absorbAuras[target] = nil end
    else
        ST.absorbAuras[target] = nil
    end
end

local function GetAbsorbApplicator(buffedUnit)
    buffedUnit = NormalizeName(buffedUnit)
    if not buffedUnit or not ST.absorbAuras[buffedUnit] then return nil, nil end
    for spell, applicator in pairs(ST.absorbAuras[buffedUnit]) do
        if applicator then
            return applicator, spell
        end
    end
    return nil, nil
end

-- ============================================================
-- Recording API
-- ============================================================

-- True when in a dungeon/raid instance (IsInInstance on most 1.12 private servers)
local function PlayerInInstance()
    if type(IsInInstance) == "function" then
        local inInstance = IsInInstance()
        return inInstance and true or false
    end
    return false
end

-- Average max HP of group members (party/raid). Falls back to the player alone.
local function GetGroupAverageMaxHP()
    local total, count = 0, 0
    ForEachGroupUnit(function(unit)
        if UnitExists(unit) and UnitIsConnected(unit) then
            local hp = UnitHealthMax(unit)
            if hp and hp > 0 then
                total = total + hp
                count = count + 1
            end
        end
    end)
    if count == 0 then
        return UnitHealthMax("player") or 1
    end
    return total / count
end

-- Average player level in the group (for level-gated elite checks)
local function GetGroupAverageLevel()
    local total, count = 0, 0
    ForEachGroupUnit(function(unit)
        if UnitExists(unit) and UnitIsConnected(unit) then
            local lvl = UnitLevel(unit)
            if lvl and lvl > 0 then
                total = total + lvl
                count = count + 1
            end
        end
    end)
    if count == 0 then return UnitLevel("player") or 1 end
    return total / count
end

local function IsUniqueEnemyName(name)
    if not name then return false end
    if ST.fightDuplicateNames[name] then return false end
    local deaths = ST.fightEnemyDeaths[name] or 0
    -- 2+ deaths of the same name = pack trash, not a unique boss
    if deaths >= 2 then return false end
    return true
end

local function MarkDuplicateName(name)
    if not name then return end
    ST.fightDuplicateNames[name] = true
    -- Clear boss flag for this name if set
    if ST.fightBossName == name then
        ST.fightIsBoss = false
        ST.fightBossName = nil
        -- Try to recover another unique boss candidate from enemies hit
        -- (left for combat-end / next elite hit)
    end
end

local function NoteEnemyDeath(name)
    name = NormalizeName(name)
    if not name or OM.players[name] then return end
    ST.fightEnemyDeaths[name] = (ST.fightEnemyDeaths[name] or 0) + 1
    if ST.fightEnemyDeaths[name] >= 2 then
        MarkDuplicateName(name)
    end
end

local function UnitLooksLikeBoss(unit)
    if not unit or not UnitExists(unit) then return false end
    if UnitIsFriend("player", unit) then return false end

    local unitName = UnitName(unit)
    -- Pack trash shares names; bosses are unique within the fight
    if unitName and not IsUniqueEnemyName(unitName) then
        return false
    end

    local classification = UnitClassification(unit)
    local level = UnitLevel(unit)

    -- Raid / outdoor world bosses
    if classification == "worldboss" then return true end
    -- Skull (??) — typical when the boss is well above the group
    if level == -1 then return true end

    -- Leveling dungeon bosses: elite/rareelite with a real level, inside an instance
    if classification == "elite" or classification == "rareelite" then
        if PlayerInInstance() then
            local enemyHP = UnitHealthMax(unit) or 0
            local avgHP = GetGroupAverageMaxHP()
            if avgHP < 1 then avgHP = 1 end
            local avgLevel = GetGroupAverageLevel()

            -- Tanky elite relative to the group's average HP
            if enemyHP >= avgHP * 4 then
                return true
            end
            -- Near group level + meaningful HP pool (covers early dungeon bosses)
            if level > 0 and level >= (avgLevel - 3) and enemyHP >= avgHP * 2.5 then
                return true
            end
            -- Rare elites in instances are almost always notable (if unique)
            if classification == "rareelite" then
                return true
            end
        end
    end

    return false
end

local function NoteEnemyHit(enemyName, amount)
    enemyName = NormalizeName(enemyName)
    if not enemyName or OM.players[enemyName] then return end
    amount = tonumber(amount) or 0
    ST.fightEnemies[enemyName] = (ST.fightEnemies[enemyName] or 0) + amount

    -- Never promote non-unique names to boss
    if not IsUniqueEnemyName(enemyName) then
        return
    end

    -- While the unit is still available, remember if it matches boss criteria
    local units = { "target", "targettarget", "pettarget", "mouseover" }
    local ui
    for ui = 1, table.getn(units) do
        local u = units[ui]
        if UnitExists(u) and UnitName(u) == enemyName and UnitLooksLikeBoss(u) then
            ST.fightEnemyBossLike[enemyName] = true
            ST.fightIsBoss = true
            ST.fightBossName = enemyName
            break
        end
    end
end

local function DeepCopyPlayerData(data)
    local p = {
        damage = data.damage or 0,
        healing = data.healing or 0,
        overhealing = data.overhealing or 0,
        rawHealing = data.rawHealing or 0,
        absorbs = data.absorbs or 0,
        damageTaken = data.damageTaken or 0,
        dispels = { count = 0, list = {} },
        interrupts = { count = 0, list = {} },
        ccBreaks = { count = 0, list = {} },
        deaths = { count = 0, list = {} },
        damageTakenBy = {},
        damageTo = {},
        healingTo = {},
        damageSpells = {},
        healSpells = {},
        damageSpellDetails = {},
        healSpellDetails = {},
        takenSpellDetails = {},
        class = data.class,
        dpsSum = data.dpsSum or 0,
        dpsSamples = data.dpsSamples or 0,
        hpsSum = data.hpsSum or 0,
        hpsSamples = data.hpsSamples or 0,
    }
    if data.damageTo then
        for k, v in pairs(data.damageTo) do
            p.damageTo[k] = v
        end
    end
    if data.healingTo then
        for k, v in pairs(data.healingTo) do
            p.healingTo[k] = v
        end
    end
    if data.dispels then
        p.dispels.count = data.dispels.count or 0
        p.dispels.targets = {}
        if data.dispels.list then
            for i = 1, table.getn(data.dispels.list) do local v = data.dispels.list[i]
                p.dispels.list[i] = v
            end
        end
        if data.dispels.targets then
            for k, v in pairs(data.dispels.targets) do
                p.dispels.targets[k] = v
            end
        end
    end
    if data.interrupts then
        p.interrupts.count = data.interrupts.count or 0
        if data.interrupts.list then
            for i = 1, table.getn(data.interrupts.list) do local v = data.interrupts.list[i]
                p.interrupts.list[i] = v
            end
        end
    end
    if data.ccBreaks then
        p.ccBreaks.count = data.ccBreaks.count or 0
        if data.ccBreaks.list then
            for i = 1, table.getn(data.ccBreaks.list) do local v = data.ccBreaks.list[i]
                if type(v) == "table" then
                    p.ccBreaks.list[i] = { spell = v.spell, target = v.target }
                else
                    p.ccBreaks.list[i] = v
                end
            end
        end
    end
    if data.deaths then
        p.deaths.count = data.deaths.count or 0
        if data.deaths.list then
            for i = 1, table.getn(data.deaths.list) do local v = data.deaths.list[i]
                if type(v) == "table" then
                    p.deaths.list[i] = { killer = v.killer, spell = v.spell, amount = v.amount }
                else
                    p.deaths.list[i] = v
                end
            end
        end
    end
    if data.damageTakenBy then
        for k, v in pairs(data.damageTakenBy) do
            p.damageTakenBy[k] = v
        end
    end
    if data.damageSpells then
        for k, v in pairs(data.damageSpells) do
            p.damageSpells[k] = v
        end
    end
    if data.threatCasts then
        p.threatCasts = {}
        for k, v in pairs(data.threatCasts) do
            p.threatCasts[k] = v
        end
    end
    if data.healSpells then
        for k, v in pairs(data.healSpells) do
            p.healSpells[k] = v
        end
    end
    if data.damageSpellDetails then
        local spell, d
        for spell, d in pairs(data.damageSpellDetails) do
            if type(d) == "table" then
                local copy = {
                    hits = d.hits or 0, crits = d.crits or 0,
                    misses = d.misses or 0, dodges = d.dodges or 0, parries = d.parries or 0,
                    blocks = d.blocks or 0, glances = d.glances or 0, crushes = d.crushes or 0,
                    resists = d.resists or 0, partials = d.partials or 0,
                    total = d.total or 0, count = d.count or 0,
                    min = d.min, max = d.max, overheal = d.overheal or 0, byTarget = {},
                }
                if d.byTarget then
                    local tn, td
                    for tn, td in pairs(d.byTarget) do
                        if type(td) == "table" then
                            copy.byTarget[tn] = {
                                hits = td.hits or 0, crits = td.crits or 0,
                                misses = td.misses or 0, dodges = td.dodges or 0, parries = td.parries or 0,
                                blocks = td.blocks or 0, glances = td.glances or 0, crushes = td.crushes or 0,
                                resists = td.resists or 0, partials = td.partials or 0,
                                total = td.total or 0, count = td.count or 0,
                                min = td.min, max = td.max,
                            }
                        end
                    end
                end
                p.damageSpellDetails[spell] = copy
            end
        end
    end
    if data.healSpellDetails then
        local spell, d
        for spell, d in pairs(data.healSpellDetails) do
            if type(d) == "table" then
                local copy = {
                    hits = d.hits or 0, crits = d.crits or 0,
                    misses = d.misses or 0, dodges = d.dodges or 0, parries = d.parries or 0,
                    blocks = d.blocks or 0, glances = d.glances or 0, crushes = d.crushes or 0,
                    resists = d.resists or 0, partials = d.partials or 0,
                    total = d.total or 0, count = d.count or 0,
                    min = d.min, max = d.max, overheal = d.overheal or 0, byTarget = {},
                }
                if d.byTarget then
                    local tn, td
                    for tn, td in pairs(d.byTarget) do
                        if type(td) == "table" then
                            copy.byTarget[tn] = {
                                hits = td.hits or 0, crits = td.crits or 0,
                                misses = td.misses or 0, dodges = td.dodges or 0, parries = td.parries or 0,
                                blocks = td.blocks or 0, glances = td.glances or 0, crushes = td.crushes or 0,
                                resists = td.resists or 0, partials = td.partials or 0,
                                total = td.total or 0, count = td.count or 0,
                                min = td.min, max = td.max,
                            }
                        end
                    end
                end
                p.healSpellDetails[spell] = copy
            end
        end
    end
    if data.takenSpellDetails then
        local spell, d
        if not p.takenSpellDetails then p.takenSpellDetails = {} end
        for spell, d in pairs(data.takenSpellDetails) do
            if type(d) == "table" then
                local copy = {
                    hits = d.hits or 0, crits = d.crits or 0,
                    misses = d.misses or 0, dodges = d.dodges or 0, parries = d.parries or 0,
                    blocks = d.blocks or 0, glances = d.glances or 0, crushes = d.crushes or 0,
                    resists = d.resists or 0, partials = d.partials or 0,
                    total = d.total or 0, count = d.count or 0,
                    min = d.min, max = d.max, overheal = d.overheal or 0, byTarget = {},
                }
                if d.byTarget then
                    local tn, td
                    for tn, td in pairs(d.byTarget) do
                        if type(td) == "table" then
                            copy.byTarget[tn] = {
                                hits = td.hits or 0, crits = td.crits or 0,
                                misses = td.misses or 0, dodges = td.dodges or 0, parries = td.parries or 0,
                                blocks = td.blocks or 0, glances = td.glances or 0, crushes = td.crushes or 0,
                                resists = td.resists or 0, partials = td.partials or 0,
                                total = td.total or 0, count = td.count or 0,
                                min = td.min, max = td.max,
                            }
                        end
                    end
                end
                p.takenSpellDetails[spell] = copy
            end
        end
    end
    return p
end


local function SnapshotSegment(seg)
    local players = {}
    if seg and seg.players then
        for name, data in pairs(seg.players) do
            players[name] = DeepCopyPlayerData(data)
        end
    end
    local ccTargets = {}
    if seg and seg.ccTargets then
        for enemy, data in pairs(seg.ccTargets) do
            local entry = { count = data.count or 0, duration = data.duration or 0, list = {} }
            if data.list then
                local i, v
                for i = 1, table.getn(data.list) do local v = data.list[i]
                    if type(v) == "table" then
                        entry.list[i] = { spell = v.spell, duration = v.duration }
                    end
                end
            end
            ccTargets[enemy] = entry
        end
    end
    return {
        players = players,
        ccTargets = ccTargets,
        startTime = seg and seg.startTime or 0,
        endTime = seg and seg.endTime or 0,
        label = seg and seg.label or "Fight",
        isBoss = seg and seg.isBoss or false,
        duration = seg and seg.duration or 0,
    }
end

-- At segment save: any damaged enemy that looked like a boss → boss segment
local function ResolveBossFromDamagedEnemies(seg)
    local totals = {}
    local name, dmg

    if ST.fightEnemies then
        for name, dmg in pairs(ST.fightEnemies) do
            totals[name] = (totals[name] or 0) + (dmg or 0)
        end
    end
    -- Also fold per-player damageTo (covers any path that skipped NoteEnemyHit)
    if seg and seg.players then
        local _, pdata
        for _, pdata in pairs(seg.players) do
            if pdata and pdata.damageTo then
                for name, dmg in pairs(pdata.damageTo) do
                    if name and not (OM.players and OM.players[name]) then
                        totals[name] = (totals[name] or 0) + (dmg or 0)
                    end
                end
            end
        end
    end

    local bestName, bestDmg = nil, -1
    local units = { "target", "targettarget", "pettarget", "mouseover" }
    for name, dmg in pairs(totals) do
        if IsUniqueEnemyName(name) then
            local bossLike = ST.fightEnemyBossLike and ST.fightEnemyBossLike[name]
            if not bossLike then
                local ui
                for ui = 1, table.getn(units) do
                    local u = units[ui]
                    if UnitExists(u) and UnitName(u) == name and UnitLooksLikeBoss(u) then
                        bossLike = true
                        if ST.fightEnemyBossLike then
                            ST.fightEnemyBossLike[name] = true
                        end
                        break
                    end
                end
            end
            if bossLike and dmg > bestDmg then
                bestDmg = dmg
                bestName = name
            end
        end
    end

    if bestName then
        ST.fightIsBoss = true
        ST.fightBossName = bestName
    else
        ST.fightIsBoss = false
        ST.fightBossName = nil
    end
end

local function PickFightLabel()
    if ST.fightBossName then
        return ST.fightBossName
    end
    local bestName, bestDmg = nil, -1
    for name, dmg in pairs(ST.fightEnemies) do
        if dmg > bestDmg then
            bestDmg = dmg
            bestName = name
        end
    end
    if bestName then return bestName end
    return "Fight"
end

local function PushFront(list, entry, maxCount)
    table.insert(list, 1, entry)
    while table.getn(list) > maxCount do
        table.remove(list)
    end
end

-- Append then drop oldest when over the soft cap (chronological history).
local function PushCapped(list, entry, maxCount)
    table.insert(list, entry)
    while table.getn(list) > maxCount do
        table.remove(list, 1)
    end
end

-- Last damage dealt TO a unit (for CC break attribution + death killing blow)
-- ST.lastHitOn[target] = { source, spell, amount, time }
ST.lastHitOn = {}

local function NoteLastHit(target, source, spell, amount)
    target = NormalizeName(target)
    source = NormalizeName(source)
    if not target then return end
    ST.lastHitOn[target] = {
        source = source or "Unknown",
        spell = spell or "Melee",
        amount = amount or 0,
        time = GetTime(),
    }
end

-- Stamp last combat activity on the current segment (for trailing-idle duration trim)
-- Begin a meter combat segment before the first event is stored (pre-REGEN hits).
local function EnsureInCombat()
    if OM and not OM.inCombat and OM.StartCombat then
        OM:StartCombat()
    end
end

local function NoteActivity()
    if OM.data and OM.data.current then
        local now = GetTime()
        OM.data.current.lastActivityTime = now
        local st = OM.data.current.startTime or 0
        if st <= 0 then
            OM.data.current.startTime = now
        end
        -- Overall session clock starts on first combat activity
        if OM.data.overall then
            local ost = OM.data.overall.startTime or 0
            if ost <= 0 then
                OM.data.overall.startTime = now
            end
            OM.data.overall.lastActivityTime = now
        end
    end
end

-- Abilities that generate threat with little or no damage component.
-- Counted from cast/perform combat-log lines for estimate use.
local THREAT_CAST_ABILITIES = {
    ["Sunder Armor"] = true,
    ["Demoralizing Shout"] = true,
    ["Demoralizing Roar"] = true,
    ["Faerie Fire"] = true,
    ["Faerie Fire (Feral)"] = true,
    ["Hamstring"] = true,
    -- Pet / minion high-threat abilities (1.12)
    ["Growl"] = true,          -- hunter pet
    ["Intimidation"] = true,   -- hunter BM talent (threat on pet)
    ["Torment"] = true,        -- voidwalker
    ["Suffering"] = true,      -- voidwalker AoE threat
}

local function IsThreatCastAbility(spell)
    if not spell then return false end
    if THREAT_CAST_ABILITIES[spell] then return true end
    local k
    for k in pairs(THREAT_CAST_ABILITIES) do
        if string.find(spell, k, 1, true) then
            return true
        end
    end
    return false
end

function Parser:AddThreatCast(source, spell)
    if not source or not spell then return end
    if not IsThreatCastAbility(spell) then return end
    source = ResolveSource(source)
    if not source then return end
    if not IsTracked(source) and not (OM.players and OM.players[source]) then return end

    local function apply(seg)
        if not seg then return end
        local p = EnsurePlayer(seg, source)
        if not p then return end
        if not p.threatCasts then p.threatCasts = {} end
        p.threatCasts[spell] = (p.threatCasts[spell] or 0) + 1
    end
    apply(OM.data and OM.data.current)
    apply(OM.data and OM.data.overall)
end

local function EmptyOutcomeBucket()
    return {
        hits = 0, crits = 0, misses = 0, dodges = 0, parries = 0,
        blocks = 0, glances = 0, crushes = 0,
        resists = 0, partials = 0,
        total = 0, overheal = 0, count = 0, min = nil, max = nil,
    }
end

local function ApplyOutcomeToBucket(s, amount, hitType, partialFlag, isTaken)
    if not s then return end
    -- isTaken: when false/nil, dodge+parry also increment misses so damage-done
    -- detail "Miss" column includes them. Taken mode keeps separate columns.
    if hitType == "miss" then
        s.misses = (s.misses or 0) + 1
        return
    elseif hitType == "dodge" then
        s.dodges = (s.dodges or 0) + 1
        if not isTaken then
            s.misses = (s.misses or 0) + 1
        end
        return
    elseif hitType == "parry" then
        s.parries = (s.parries or 0) + 1
        if not isTaken then
            s.misses = (s.misses or 0) + 1
        end
        return
    elseif hitType == "block" then
        -- Full avoid block (attack was blocked with no damage line)
        s.blocks = (s.blocks or 0) + 1
        return
    elseif hitType == "resist" then
        s.resists = (s.resists or 0) + 1
        return
    elseif hitType == "crit" then
        s.crits = (s.crits or 0) + 1
    elseif hitType == "glance" then
        s.glances = (s.glances or 0) + 1
    elseif hitType == "crush" then
        s.crushes = (s.crushes or 0) + 1
    else
        s.hits = (s.hits or 0) + 1
    end
    if partialFlag then
        s.partials = (s.partials or 0) + 1
    end
    amount = tonumber(amount) or 0
    if amount > 0 then
        s.total = (s.total or 0) + amount
        s.count = (s.count or 0) + 1
        if s.min == nil or amount < s.min then s.min = amount end
        if s.max == nil or amount > s.max then s.max = amount end
    end
end

local function NoteSpellOutcome(p, spell, amount, hitType, isHeal, target, partialFlag, isTaken, overhealAmount)
    if not p or not spell or spell == "" then return end
    hitType = hitType or "hit"
    overhealAmount = tonumber(overhealAmount) or 0
    local bagName
    if isTaken then
        bagName = "takenSpellDetails"
    elseif isHeal then
        bagName = "healSpellDetails"
    else
        bagName = "damageSpellDetails"
    end
    if not p[bagName] then p[bagName] = {} end
    local s = p[bagName][spell]
    if not s then
        s = EmptyOutcomeBucket()
        s.byTarget = {}
        p[bagName][spell] = s
    end
    if not s.byTarget then s.byTarget = {} end
    ApplyOutcomeToBucket(s, amount, hitType, partialFlag, isTaken)
    if overhealAmount > 0 then
        s.overheal = (s.overheal or 0) + overhealAmount
    end
    if target and target ~= "" then
        local ts = s.byTarget[target]
        if not ts then
            ts = EmptyOutcomeBucket()
            s.byTarget[target] = ts
        end
        ApplyOutcomeToBucket(ts, amount, hitType, partialFlag, isTaken)
        if overhealAmount > 0 then
            ts.overheal = (ts.overheal or 0) + overhealAmount
        end
    end
end

function Parser:AddDamage(source, amount, spell, target, hitType, partialFlag, isPeriodic)
    EnsureInCombat()
    local isPet = false
    local rawSource = source
    if rawSource and string.find(rawSource, " %(.+%)$") then
        isPet = true
    end
    local rawName = rawSource and NormalizeName(rawSource) or rawSource
    local isTotem = rawName and OM.IsTotemName and OM:IsTotemName(rawName)
    if rawName and rawName ~= "You" and rawName ~= "you" then
        if OM.GetPetOwner and OM:GetPetOwner(rawName) then
            isPet = true
        elseif OM.heuristicPets and OM.heuristicPets[rawName] then
            isPet = true
        end
    end
    if isTotem and (not spell or spell == "" or spell == "Attack" or spell == "Auto Attack") then
        spell = rawName
    end

    source = ResolveSource(source)
    -- Pets always attribute to their owner on the meter (never their own bar).
    -- mergePetDamage only controls tooltip spell breakdown (one line vs per-ability).
    if source and OM.GetPetOwner then
        local owner = OM:GetPetOwner(source)
        if owner then
            isPet = true
            source = owner
        end
    end
    if not source or not amount or amount <= 0 then return end
    -- Only record damage from tracked group members (pets resolve to owners above)
    if not OM.players[source] then
        return
    end

    if isPet and not isTotem then
        if OM.GetSetting and OM:GetSetting("mergePetDamage") then
            spell = "Pet: Damage"
        else
            if not spell or spell == "" then
                spell = "Auto Attack"
            end
            if string.sub(spell, 1, 5) ~= "Pet: " then
                spell = "Pet: " .. spell
            end
        end
    end

    target = NormalizeName(target)

    if ModeEnabled("damage") then
        local p = EnsurePlayer(OM.data.current, source)
        if p then
            p.damage = p.damage + amount
            if spell then
                p.damageSpells[spell] = (p.damageSpells[spell] or 0) + amount
                NoteSpellOutcome(p, spell, amount, hitType or "hit", false, target, partialFlag)
            end
            if target then
                p.damageTo[target] = (p.damageTo[target] or 0) + amount
                NoteLastHit(target, source, spell, amount)
                if not OM.players[target] then
                    NoteEnemyHit(target, amount)
                end
            end
        end

        local o = EnsurePlayer(OM.data.overall, source)
        if o then
            o.damage = o.damage + amount
            if spell then
                o.damageSpells[spell] = (o.damageSpells[spell] or 0) + amount
                NoteSpellOutcome(o, spell, amount, hitType or "hit", false, target, partialFlag)
            end
            if target then
                o.damageTo[target] = (o.damageTo[target] or 0) + amount
            end
        end
    elseif target then
        -- Still track last-hit for death tooltips even when damage mode is off
        NoteLastHit(target, source, spell, amount)
    end
    -- Interrupt abilities: combat log rarely reports "interrupted X"; count uses instead
    if ModeEnabled("interrupts") and spell and Parser.IsInterruptAbility and Parser.IsInterruptAbility(spell) then
        Parser:AddInterrupt(source, spell)
    end
    -- Breakable CC: first damage to a CC'd target credits the breaker
    if ModeEnabled("ccbreak") and target and Parser.NoteBreakableCCDamage then
        Parser.NoteBreakableCCDamage(target, source, spell)
    end
    NoteActivity()
end

-- amount = full heal from the log
-- healing field stores EFFECTIVE healing (amount - overheal)
-- overhealing tracked separately for later tooltip %
function Parser:AddMiss(source, spell, target, avoidType)
    EnsureInCombat()
    -- avoidType: "miss" (default), "dodge", "parry", "block"
    -- Outbound avoids (swing/spell avoided by the target).
    if not ModeEnabled("damage") then return end
    local me = ST.playerName or UnitName("player")
    if source == "You" or source == "you" or source == nil or source == "" then
        source = me
    end
    source = ResolveSource(source) or source or me
    if not source or source == "" then
        source = me
    end
    if not source then return end
    -- Always accept the local player (case-insensitive); group members via roster
    local sourceOK = false
    if me and string.lower(tostring(source)) == string.lower(tostring(me)) then
        source = me
        sourceOK = true
    elseif OM.players and OM.players[source] then
        sourceOK = true
    elseif IsTracked and IsTracked(source) then
        sourceOK = true
    end
    if not sourceOK then return end
    spell = spell or "Auto Attack"
    target = NormalizeName(target)
    avoidType = avoidType or "miss"
    local function apply(seg)
        if not seg then return end
        local p = EnsurePlayer(seg, source)
        if p then
            NoteSpellOutcome(p, spell, 0, avoidType, false, target, false)
        end
    end
    apply(OM.data.current)
    apply(OM.data.overall)
    NoteActivity()
end

function Parser:AddBlock(source, spell, target)
    EnsureInCombat()
    source = ResolveSource(source)
    if not source then return end
    if not OM.players[source] and not IsTracked(source) then return end
    spell = spell or "Auto Attack"
    target = NormalizeName(target)
    local function apply(seg)
        if not seg then return end
        local p = EnsurePlayer(seg, source)
        if p then
            NoteSpellOutcome(p, spell, 0, "block", false, target, false)
        end
    end
    apply(OM.data and OM.data.current)
    apply(OM.data and OM.data.overall)
end

function Parser:AddResist(source, spell, target)
    EnsureInCombat()
    source = ResolveSource(source)
    if not source then return end
    if not OM.players[source] and not IsTracked(source) then return end
    spell = spell or "Unknown"
    target = NormalizeName(target)
    local function apply(seg)
        if not seg then return end
        local p = EnsurePlayer(seg, source)
        if p then
            NoteSpellOutcome(p, spell, 0, "resist", false, target, false)
        end
    end
    apply(OM.data and OM.data.current)
    apply(OM.data and OM.data.overall)
end

function Parser:AddHealing(source, amount, spell, isAbsorb, target, hitType)
    EnsureInCombat()
    if not ModeEnabled("healing") then return end
    local rawName = source and NormalizeName(source) or source
    if rawName and OM.IsTotemName and OM:IsTotemName(rawName) then
        if not spell or spell == "" then
            spell = rawName
        end
    end
    source = ResolveSource(source)
    if not source or not amount or amount <= 0 then return end
    if not IsTracked(source) and not OM.players[source] then return end

    local effective, over = amount, 0

    if isAbsorb then
        -- Absorbs are always fully "effective" (damage prevented)
        effective, over = amount, 0
    else
        effective, over = SplitOverheal(target, amount)
    end

    local healTarget = NormalizeName(target)

    local function apply(seg)
        local p = EnsurePlayer(seg, source)
        if not p then return end
        p.rawHealing = (p.rawHealing or 0) + amount
        p.overhealing = (p.overhealing or 0) + over
        local credited = isAbsorb and amount or effective
        if isAbsorb then
            p.absorbs = (p.absorbs or 0) + amount
            p.healing = (p.healing or 0) + amount -- absorbs add to effective total
        else
            p.healing = (p.healing or 0) + effective
        end
        if spell then
            p.healSpells[spell] = (p.healSpells[spell] or 0) + credited
            NoteSpellOutcome(p, spell, credited, hitType or "hit", true, healTarget, false, nil, over)
        end
        if healTarget and credited > 0 then
            p.healingTo[healTarget] = (p.healingTo[healTarget] or 0) + credited
        end
    end

    apply(OM.data.current)
    apply(OM.data.overall)
    NoteActivity()
end

function Parser:AddDamageTaken(target, amount, source, spell, hitType, partialFlag, isPeriodic)
    EnsureInCombat()
    if not ModeEnabled("taken") then return end
    target = NormalizeName(target)
    amount = tonumber(amount) or 0
    if not target or amount <= 0 then return end
    if not OM.players[target] then return end -- only track damage taken by the group

    source = NormalizeName(source) or "Unknown"
    spell = spell or "Auto Attack"
    hitType = hitType or "hit"
    NoteLastHit(target, source, spell, amount)

    local function apply(seg)
        if not seg then return end
        local p = EnsurePlayer(seg, target)
        if not p then return end
        p.damageTaken = (p.damageTaken or 0) + amount
        if not p.damageTakenBy then p.damageTakenBy = {} end
        p.damageTakenBy[source] = (p.damageTakenBy[source] or 0) + amount
        -- byTarget on taken details = attacker name
        NoteSpellOutcome(p, spell, amount, hitType, false, source, partialFlag, true)
    end
    apply(OM.data and OM.data.current)
    apply(OM.data and OM.data.overall)
    -- DoT ticks still count for meters, but must not keep the segment alive
    if not isPeriodic then
        NoteActivity()
    end
end

-- Incoming avoid (enemy missed / dodge-parry-block): no damage amount
function Parser:AddTakenAvoid(target, spell, source, avoidType)
    EnsureInCombat()
    if not ModeEnabled("taken") then return end
    target = NormalizeName(target)
    if not target or not OM.players[target] then return end
    source = NormalizeName(source) or "Unknown"
    spell = spell or "Auto Attack"
    avoidType = avoidType or "miss"
    local function apply(seg)
        if not seg then return end
        local p = EnsurePlayer(seg, target)
        if p then
            NoteSpellOutcome(p, spell, 0, avoidType, false, source, false, true)
        end
    end
    apply(OM.data and OM.data.current)
    apply(OM.data and OM.data.overall)
    NoteActivity()
end

function Parser:AddDispel(source, what, target)
    if not ModeEnabled("dispels") then return end
    source = ResolveSource(source)
    if not source then return end
    -- Prefer group members
    if not IsTracked(source) and not OM.players[source] then return end
    what = what or "Unknown"
    target = NormalizeName(target)

    local function apply(seg)
        local p = EnsurePlayer(seg, source)
        if not p then return end
        p.dispels.count = p.dispels.count + 1
        PushCapped(p.dispels.list, what, MAX_DETAIL_LIST)
        if not p.dispels.targets then
            p.dispels.targets = {}
        end
        if target and target ~= "" then
            p.dispels.targets[target] = (p.dispels.targets[target] or 0) + 1
        end
    end
    apply(OM.data.current)
    apply(OM.data.overall)
end

function Parser:AddInterrupt(source, what)
    if not ModeEnabled("interrupts") then return end
    source = ResolveSource(source)
    if not source then return end
    if not IsTracked(source) and not OM.players[source] then return end
    local p = EnsurePlayer(OM.data.current, source)
    if p then
        p.interrupts.count = p.interrupts.count + 1
        PushCapped(p.interrupts.list, what or "Unknown", MAX_DETAIL_LIST)
    end
    local o = EnsurePlayer(OM.data.overall, source)
    if o then
        o.interrupts.count = o.interrupts.count + 1
        PushCapped(o.interrupts.list, what or "Unknown", MAX_DETAIL_LIST)
    end
end

-- ============================================================
-- CC tracking (enemy-centric) + breakable CC breaks (player-centric)
-- Combat log usually says "Enemy is afflicted by Sap" with no caster.
-- Lists enemies that were CC'd and estimates full duration.
-- Breakable CCs (Sap/Gouge/Blind/Poly/Frost Trap): first damage to the
-- target after the CC is applied credits the breaker.
-- ============================================================

-- Breakable (damage-breakable) hard CCs
local BREAKABLE_CC = {
    ["Sap"] = true,
    ["Gouge"] = true,
    ["Blind"] = true,
    ["Polymorph"] = true,
    ["Polymorph: Pig"] = true,
    ["Polymorph: Turtle"] = true,
    ["Freezing Trap Effect"] = true,
    ["Freezing Trap"] = true,
    ["Hibernate"] = true,
    ["Shackle Undead"] = true,
    ["Wyvern Sting"] = true,
    ["Seduction"] = true,
    ["Scare Beast"] = true,
}

-- activeBreakable[target] = { spell = "...", time = GetTime() }
local activeBreakable = {}

local function IsBreakableCC(spell)
    return SpellInSet(BREAKABLE_CC, spell)
end

local function EnsureCCTargets(seg)
    if not seg.ccTargets then
        seg.ccTargets = {}
    end
    return seg.ccTargets
end

local function EnsureCCTargetEntry(seg, enemy)
    local t = EnsureCCTargets(seg)
    if not t[enemy] then
        t[enemy] = { count = 0, duration = 0, list = {} }
    end
    return t[enemy]
end

-- Record that an enemy was CC'd (no caster required). Duration = estimate.
function Parser:AddEnemyCC(spell, target, maxDuration)
    if not ModeEnabled("cc") then return end
    target = NormalizeName(target)
    if not target or target == "" then return end
    -- Do not track the player's group as CC targets in this mode
    if OM.players and OM.players[target] then return end
    -- Guard against combat-log fragment targets ("on", "with", etc.)
    if string.len(target) < 3 then return end

    spell = spell or "Unknown"
    -- Reject fragment spell names
    local sl = string.lower(spell)
    if sl == "on" or sl == "with" or sl == "by" or sl == "from" or string.len(spell) < 3 then
        return
    end
    maxDuration = tonumber(maxDuration) or 0
    if maxDuration < 0 then maxDuration = 0 end

    local function apply(seg)
        local e = EnsureCCTargetEntry(seg, target)
        e.count = e.count + 1
        e.duration = (e.duration or 0) + maxDuration
        PushCapped(e.list, { spell = spell, duration = maxDuration }, MAX_DETAIL_LIST)
    end
    apply(OM.data.current)
    apply(OM.data.overall)

    if IsBreakableCC(spell) then
        activeBreakable[target] = { spell = spell, time = GetTime() }
    end
end

-- First damage to a breakable-CC'd target → credit the breaker
local function NoteBreakableCCDamage(target, source, spell)
    target = NormalizeName(target)
    if not target then return end
    local entry = activeBreakable[target]
    if not entry then return end
    -- Ignore tiny window noise right as CC is applied
    if entry.time and (GetTime() - entry.time) < 0.15 then return end
    activeBreakable[target] = nil
    Parser:AddCCBreak(source, entry.spell, target)
end
Parser.NoteBreakableCCDamage = NoteBreakableCCDamage

function Parser:FinishCC(target, spell)
    target = NormalizeName(target)
    if target then
        activeBreakable[target] = nil
    end
end

function Parser:FlushActiveCCs()
    activeBreakable = {}
end

function Parser:AddCCBreak(breaker, ccSpell, target)
    if not ModeEnabled("ccbreak") then return end
    breaker = ResolveSource(breaker)
    if not breaker then return end
    if not IsTracked(breaker) and not OM.players[breaker] then return end
    ccSpell = ccSpell or "CC"
    target = NormalizeName(target) or "?"

    local p = EnsurePlayer(OM.data.current, breaker)
    if p then
        p.ccBreaks.count = p.ccBreaks.count + 1
        PushCapped(p.ccBreaks.list, { spell = ccSpell, target = target }, MAX_DETAIL_LIST)
    end
    local o = EnsurePlayer(OM.data.overall, breaker)
    if o then
        o.ccBreaks.count = o.ccBreaks.count + 1
        PushCapped(o.ccBreaks.list, { spell = ccSpell, target = target }, MAX_DETAIL_LIST)
    end
end


function Parser:AddDeath(name, lastHit)
    if not ModeEnabled("deaths") then return end
    name = NormalizeName(name)
    if not name then return end
    if not OM.players[name] and name ~= (playerName or UnitName("player")) then
        return
    end

    local killer, spell, amount = "?", "?", 0
    if type(lastHit) == "table" then
        killer = lastHit.source or lastHit.killer or "?"
        spell = lastHit.spell or "?"
        amount = tonumber(lastHit.amount) or 0
    end

    local function apply(seg)
        local p = EnsurePlayer(seg, name)
        if not p then return end
        p.deaths.count = (p.deaths.count or 0) + 1
        if not p.deaths.list then p.deaths.list = {} end
        PushCapped(p.deaths.list, {
            killer = killer,
            spell = spell,
            amount = amount,
        }, MAX_DEATHS_LIST)
    end
    apply(OM.data.current)
    apply(OM.data.overall)
end

-- ============================================================

H.EnsurePlayer = EnsurePlayer
H.IsUniqueEnemyName = IsUniqueEnemyName
H.UnitLooksLikeBoss = UnitLooksLikeBoss
H.PickFightLabel = PickFightLabel
H.PushFront = PushFront
H.SnapshotSegment = SnapshotSegment
H.DeepCopyPlayerData = DeepCopyPlayerData
H.MAX_RECENT_FIGHTS = MAX_RECENT_FIGHTS
H.MAX_BOSS_FIGHTS = MAX_BOSS_FIGHTS
H.NoteLastHit = NoteLastHit
H.NoteActivity = NoteActivity
H.EnsureInCombat = EnsureInCombat
H.ModeEnabled = ModeEnabled
H.ST = ST
H.OM = OM
H.Parser = Parser
H.getPlayerName = function() return ST.playerName or UnitName("player") end
H.NormalizeName = NormalizeName
H.ResolveSource = ResolveSource
H.NoteEnemyHit = NoteEnemyHit
H.ResolveBossFromDamagedEnemies = ResolveBossFromDamagedEnemies

-- ClearDispelBuffers is defined in Backend_Chat; resolve at call time
H.ClearDispelBuffers = function()
    local NS = GreedMeter.ParserNS
    if NS and NS.ClearDispelBuffers then
        NS.ClearDispelBuffers()
    end
end

function Parser:OnCombatStart()
    local P = H.Parser
    local S = H.ST
    local O = H.OM
    P:FlushActiveCCs()
    S.lastHitOn = {}
    S.fightEnemies = {}
    S.fightEnemyDeaths = {}
    S.fightDuplicateNames = {}
    S.fightEnemyBossLike = {}
    S.fightIsBoss = false
    S.fightBossName = nil
    H.ClearDispelBuffers()
    S.recentHarmfulAuras = {}

    -- Always start Current empty. Keeping the previous players table to catch
    -- pre-pull hits was too aggressive (late combat-log lines after REGEN_ENABLED
    -- set lastActivityTime past endTime, so the next fight reused the old totals).
    -- Opening-hit timing is handled by backdating startTime on the first event
    -- after combat starts (see NoteActivity / first damage).
    local now = GetTime()
    O.data.current = {
        players = {},
        ccTargets = {},
        startTime = now,
        endTime = 0,
        label = "Current",
        isBoss = false,
        duration = 0,
        lastActivityTime = nil,
    }
end

function Parser:OnCombatEnd(duration)
    local P = H.Parser
    local O = H.OM
    local S = H.ST
    local EnsurePlayer = H.EnsurePlayer
    local IsUniqueEnemyName = H.IsUniqueEnemyName
    local UnitLooksLikeBoss = H.UnitLooksLikeBoss
    local PickFightLabel = H.PickFightLabel
    local SnapshotSegment = H.SnapshotSegment
    local PushFront = H.PushFront
    local MAX_RECENT_FIGHTS = H.MAX_RECENT_FIGHTS
    local MAX_BOSS_FIGHTS = H.MAX_BOSS_FIGHTS

    P:FlushActiveCCs()

    local now = GetTime()
    local startT = O.data.current.startTime or 0
    duration = duration or ((startT > 0) and (now - startT) or 0)

    local lastAct = O.data.current.lastActivityTime
    if startT > 0 and lastAct and lastAct >= startT then
        local trimmed = lastAct - startT
        if trimmed > 0 and (duration <= 0 or trimmed < duration) then
            duration = trimmed
        end
    end
    if duration < 0 then duration = 0 end
    O.data.current.duration = duration
    -- Freeze endTime to last activity so the UI does not keep ticking
    if lastAct and lastAct >= startT then
        O.data.current.endTime = lastAct
    else
        O.data.current.endTime = now
    end

    if duration > 0 and O.data.current.players then
        -- Never divide by sub-second durations for overall rate averages
        local rateDur = duration
        if rateDur < 1 then rateDur = 1 end
        local name, pdata
        for name, pdata in pairs(O.data.current.players) do
            local o = EnsurePlayer(O.data.overall, name)
            if o then
                local dmg = pdata.damage or 0
                local heal = pdata.healing or 0
                if dmg > 0 then
                    o.dpsSum = (o.dpsSum or 0) + (dmg / rateDur)
                    o.dpsSamples = (o.dpsSamples or 0) + 1
                end
                if heal > 0 then
                    o.hpsSum = (o.hpsSum or 0) + (heal / rateDur)
                    o.hpsSamples = (o.hpsSamples or 0) + 1
                end
            end
        end
        O.data.overall.duration = (O.data.overall.duration or 0) + duration
        if not O.data.overall.startTime or O.data.overall.startTime == 0 then
            O.data.overall.startTime = startT
        end
        O.data.overall.endTime = now
    end

    -- Boss segment = any unique enemy damaged this fight that matched boss criteria
    if H.ResolveBossFromDamagedEnemies then
        H.ResolveBossFromDamagedEnemies(O.data.current)
    else
        ResolveBossFromDamagedEnemies(O.data.current)
    end
    -- Sync into S (OnCombatEnd uses S alias of ST)
    S.fightIsBoss = ST.fightIsBoss
    S.fightBossName = ST.fightBossName

    if S.fightBossName and not IsUniqueEnemyName(S.fightBossName) then
        S.fightIsBoss = false
        S.fightBossName = nil
        ST.fightIsBoss = false
        ST.fightBossName = nil
    end

    local label = PickFightLabel()
    O.data.current.label = label
    O.data.current.isBoss = S.fightIsBoss and true or false

    local hasData = false
    for _, _ in pairs(O.data.current.players) do
        hasData = true
        break
    end

    if hasData and duration >= 0.5 then
        local snap = SnapshotSegment(O.data.current)
        PushFront(O.data.recentFights, snap, MAX_RECENT_FIGHTS)
        if snap.isBoss then
            PushFront(O.data.bossFights, snap, MAX_BOSS_FIGHTS)
        end
    end
end

function Parser:OnReset()
    local P = H.Parser or Parser
    local O = H.OM or OM
    local S = H.ST or ST
    if not S then S = {} ; H.ST = S end
    if P and P.FlushActiveCCs then P:FlushActiveCCs() end
    S.lastHitOn = {}
    if H.ClearDispelBuffers then H.ClearDispelBuffers() end
    O.data.current = { players = {}, ccTargets = {}, startTime = 0, endTime = 0, label = "Current", isBoss = false, duration = 0 }
    O.data.overall = { players = {}, ccTargets = {}, startTime = 0, endTime = 0, label = "Overall", isBoss = false, duration = 0 }
    O.data.recentFights = {}
    O.data.bossFights = {}
    O.data.paused = nil
    O.meterPaused = false
    S.fightEnemies = {}
    S.fightEnemyDeaths = {}
    S.fightDuplicateNames = {}
    S.fightEnemyBossLike = {}
    S.fightIsBoss = false
    S.fightBossName = nil
    S.recentAbsorbCaster = {}
    S.recentShieldByTarget = {}
    S.recentAbsorbCredits = {}
    S.absorbAuras = {}
end

-- Resolve a UI segment key to a data table
-- Keys: "current", "overall", "recent1", "recent2", "boss1", "boss2", "boss3"
function Parser:CreatePausedSnapshot()
    if not OM.data or not OM.data.current then return end
    local src = OM.data.current
    local snap = SnapshotSegment(src)
    -- Freeze duration at the moment of pause
    local dur = 0
    if src.duration and src.duration > 0 then
        dur = src.duration
    else
        local startT = src.startTime or 0
        if startT > 0 then
            local last = src.lastActivityTime
            if last and last > startT then
                dur = last - startT
            else
                dur = GetTime() - startT
            end
        end
    end
    if dur < 0 then dur = 0 end
    snap.duration = dur
    snap.startTime = src.startTime or 0
    snap.endTime = GetTime()
    snap.lastActivityTime = src.lastActivityTime
    snap.label = "Paused"
    snap.isBoss = src.isBoss and true or false
    OM.data.paused = snap
end

function Parser:GetSegment(key)
    if not key or key == "current" then
        return OM.data.current
    elseif key == "overall" then
        return OM.data.overall
    elseif key == "paused" then
        return OM.data.paused
    end
    local _, _, kind, idx = string.find(key, "^(%a+)(%d+)$")
    idx = tonumber(idx)
    if kind == "recent" and idx and OM.data.recentFights[idx] then
        return OM.data.recentFights[idx]
    end
    if kind == "boss" and idx and OM.data.bossFights[idx] then
        return OM.data.bossFights[idx]
    end
    return nil
end

function Parser:OnRosterUpdate()
    playerName = UnitName("player"); ST.playerName = playerName
end

-- ============================================================
-- Register with Core
-- ============================================================


-- ============================================================
-- Cross-file exports (Lua 5.0 has no shared locals between files)
-- ============================================================
local NS = GreedMeter.ParserNS
NS.Parser = Parser
NS.H = H
NS.ST = ST

NS.ModeEnabled = ModeEnabled
NS.IsAbsorbShield = IsAbsorbShield
NS.NoteRecentAbsorbCaster = NoteRecentAbsorbCaster
NS.GetRecentAbsorbCaster = GetRecentAbsorbCaster
NS.SetAbsorbAura = SetAbsorbAura
NS.ClearAbsorbAura = ClearAbsorbAura
NS.GetAbsorbApplicator = GetAbsorbApplicator
NS.RECENT_CASTER_TIMEOUT = RECENT_CASTER_TIMEOUT

NS.SpellInSet = SpellInSet
NS.SpellLookup = SpellLookup
NS.PushCapped = PushCapped
NS.ForEachGroupUnit = ForEachGroupUnit
NS.FindUnitByName = FindUnitByName
NS.SplitOverheal = SplitOverheal
NS.MarkDuplicateName = MarkDuplicateName
NS.NoteEnemyDeath = NoteEnemyDeath
NS.NoteEnemyHit = NoteEnemyHit
NS.UnitLooksLikeBoss = UnitLooksLikeBoss
NS.GetGroupAverageMaxHP = GetGroupAverageMaxHP
NS.EmptyOutcomeBucket = EmptyOutcomeBucket
NS.NoteSpellOutcome = NoteSpellOutcome
NS.NoteLastHit = NoteLastHit

NS.NormalizeName = NormalizeName
NS.EnsurePlayer = EnsurePlayer
NS.ResolveSource = ResolveSource
NS.IsTracked = IsTracked
NS.SuperWoWAvailable = SuperWoWAvailable
NS.CacheGuid = CacheGuid
NS.StripAndCacheGuids = StripAndCacheGuids
NS.RefreshGuidCacheFromUnits = RefreshGuidCacheFromUnits
NS.NoteActivity = NoteActivity
NS.DeepCopyPlayerData = DeepCopyPlayerData
NS.SnapshotSegment = SnapshotSegment
NS.PickFightLabel = PickFightLabel
NS.PushFront = PushFront
NS.ClearDispelBuffers = ClearDispelBuffers
NS.IsUniqueEnemyName = IsUniqueEnemyName
NS.guidToName = guidToName
NS.nameToGuid = nameToGuid

function Parser:CacheGuid(name, guid)
    CacheGuid(name, guid)
end

function Parser:NameFromGuid(guid)
    if not guid or guid == "" then return nil end
    return guidToName[guid]
end

OM:RegisterModule("Parser", Parser)