SupportMeter.lua

--[[---------------------------------------------------------------------------
    SupportMeter - retail-Augmentation-style support attribution for the
    Wind Stormbringer's Aerodynamics on Ascension (3.3.5).

    Model: while YOUR Aerodynamics buff is on a raid member, every damage
    event they produce is partially yours:
        attributed = damage x share x buffValue / (pool + buffValue)
    The event's DAMAGE SCHOOL picks the pool: physical -> their attack
    power, magic -> their spell power. Pools come from /sm inspect (gear
    scan of nearby raiders, same method the logs website uses), manual
    overrides, or defaults.

    /sm            - toggle window
    /sm inspect    - gear-scan party/raid members for their SP/AP pools
    /sm value N    - set your Aerodynamics value (auto-read from spellbook)
    /sm share X    - power-scaling share for spells (default 0.45)
    /sm mshare X   - power-scaling share for melee/physical (default 0.55)
    /sm pool Name sp|ap N - manual pool override
    /sm reset      - reset session totals
-----------------------------------------------------------------------------]]

local TAG = "|cff00ccffSupportMeter|r: "

---------------------------------------------------------------------------
-- 3.3.5 widget backfills
---------------------------------------------------------------------------
local function ExtendWidget(widget)
    local mt = getmetatable(widget)
    local idx = mt and mt.__index
    if type(idx) ~= "table" then return end
    if not idx.SetShown then
        idx.SetShown = function(self, shown)
            if shown then self:Show() else self:Hide() end
        end
    end
    if not idx.SetSize and idx.SetWidth then
        idx.SetSize = function(self, w, h)
            self:SetWidth(w)
            self:SetHeight(h)
        end
    end
    if idx.SetTexture and not idx.SetColorTexture then
        idx.SetColorTexture = function(self, r, g, b, a)
            self:SetTexture(r, g, b, a)
        end
    end
end
do
    local holder = CreateFrame("Frame")
    ExtendWidget(holder)
    ExtendWidget(CreateFrame("Button"))
    ExtendWidget(holder:CreateTexture())
    ExtendWidget(holder:CreateFontString())
end

local db

---------------------------------------------------------------------------
-- state
---------------------------------------------------------------------------
local band = bit.band
local AFFIL_MINE = COMBATLOG_OBJECT_AFFILIATION_MINE or 0x1
local buffed = {}            -- [destGUID] = destName, while MY buff is on them
local buffedAt = {}          -- [destGUID] = time of last apply/refresh (expiry watchdog)
local lastValueRead = 0
local lastReadSpellId
local dmgMix = {}            -- [name] = {phys, magic} observed damage, infers highest stat
local detailsData = {}       -- [detailsCombatNumber] = { [name] = attributed } (SV-backed)
local segTotals = {}         -- [detailsCombatNumber] = summed attributed (SV-backed)
local myRows = {}            -- [detailsCombatNumber] = OUR buff spell row (never in shared data)
local injApplied = {}        -- [combatNumber] = { me = amount, byName = {name=amount} }
local maxCombatId = 0
local procActive = {}        -- [name] = { [procBuffName] = true } (CLEU-tracked)
local totals = {}            -- [name] = attributed damage (session)
local fightTotals = {}       -- [name] = attributed damage (current/last fight)
local sessionAttr = 0
local fightAttr = 0
local inCombat = false
local fightStart = 0
local fightDur = 0
local playerGUID, playerName

local gui
local RefreshGUI
local RefreshDebug           -- assigned in the debug-window section
local dbgWin, CreateDebugWindow
local audit                  -- current-fight audit data
local auditLog = {}          -- newest-first report strings of finished fights
local spellsSeen = {}        -- [spellId or 0] = {n, d, t} session ledger of observed spells

local function Round(n) return math.floor(n + 0.5) end

local function Fmt(n)
    if n >= 1000000 then return ("%.2fM"):format(n / 1000000) end
    if n >= 1000 then return ("%.1fK"):format(n / 1000) end
    return tostring(Round(n))
end

---------------------------------------------------------------------------
-- pools
---------------------------------------------------------------------------
local levels = {}            -- [name] = unit level (group roster cache)

local function GetPool(name, isPhysical)
    local p = db.pools[name]
    -- exact stats (their own SupportMeter told us) are full totals: as-is
    if p and p.exact then
        local v = isPhysical and p.ap or p.sp
        if v and v > 0 then return v end
    end
    -- gear scans are FLOORS (no base stats): add the base-stat bonus and
    -- never drop below the fallback - raw scan values over-credit badly.
    -- base/fallback assume level 60; scale them for lower-level players
    local f = 1
    local lvl = levels[name]
    if lvl and lvl > 0 and lvl < 60 then f = lvl / 60 end
    local scanned = p and (isPhysical and p.ap or p.sp) or 0
    local pool = scanned + (isPhysical and db.baseAP or db.baseSP) * f
    local floorPool = (isPhysical and db.defaults.ap or db.defaults.sp) * f
    if pool < floorPool then pool = floorPool end
    local procs = procActive[name]
    if procs then
        local key = isPhysical and "ap" or "sp"
        for buff in pairs(procs) do
            local def = db.procs and db.procs[buff]
            if def and def[key] then pool = pool + def[key] end
        end
    end
    return pool
end

local function UpdateRosterLevels()
    wipe(levels)
    local n = GetNumRaidMembers()
    if n > 0 then
        for i = 1, n do
            local u = "raid" .. i
            local nm = UnitName(u)
            if nm then levels[nm] = UnitLevel(u) end
        end
    else
        for i = 1, GetNumPartyMembers() do
            local u = "party" .. i
            local nm = UnitName(u)
            if nm then levels[nm] = UnitLevel(u) end
        end
    end
end

---------------------------------------------------------------------------
-- pet -> owner map: the buff lands on the PLAYER and a fraction of the
-- buffed stat flows to their pet (inheritance), so pet damage is credited
-- through the owner's buff window at a reduced effective value
---------------------------------------------------------------------------
local petOwner = {}          -- [petGUID] = { g = ownerGUID, n = ownerName }

local function UpdatePetMap()
    wipe(petOwner)
    local function add(petUnit, ownerUnit)
        if UnitExists(petUnit) then
            local pg = UnitGUID(petUnit)
            local og = UnitGUID(ownerUnit)
            local on = UnitName(ownerUnit)
            if pg and og and on then petOwner[pg] = { g = og, n = on } end
        end
    end
    local n = GetNumRaidMembers()
    if n > 0 then
        for i = 1, n do add("raidpet" .. i, "raid" .. i) end
    else
        for i = 1, GetNumPartyMembers() do add("partypet" .. i, "party" .. i) end
    end
end

---------------------------------------------------------------------------
-- my Aerodynamics value: read from my own spellbook tooltip
---------------------------------------------------------------------------
local scanTip = CreateFrame("GameTooltip", "SupportMeterScanTip", nil, "GameTooltipTemplate")
scanTip:SetOwner(UIParent, "ANCHOR_NONE")

local function AutoReadBuffValue()
    -- the 3.3.5 spellbook lists EVERY rank as its own entry - scan them
    -- all and keep the highest value (= the max rank)
    local getName = GetSpellName or GetSpellBookItemName
    local best
    local i = 1
    while true do
        local name = getName(i, "spell")
        if not name then break end
        if name == db.buffName then
            scanTip:ClearLines()
            scanTip:SetOwner(UIParent, "ANCHOR_NONE")
            scanTip:SetSpell(i, "spell")
            for l = 1, 8 do
                local line = _G["SupportMeterScanTipTextLeft" .. l]
                local t = line and line:GetText()
                local v = t and t:match("power by (%d+)")
                if v then
                    v = tonumber(v)
                    if not best or v > best then best = v end
                    break
                end
            end
        end
        i = i + 1
        if i > 1024 then break end
    end
    return best
end

-- support buffs known to share the exclusive raid-power stack group;
-- used to auto-detect which one THIS character provides
local KNOWN_BUFFS = {
    "Aerodynamics", "Battle Screech", "Flourishing Growth",
    "Song of Steel", "Splash Zone", "Heartbreak",
}
local KNOWN_SET = {}
for _, n in ipairs(KNOWN_BUFFS) do KNOWN_SET[n] = true end

local function FindSupportBuffInSpellbook()
    local getName = GetSpellName or GetSpellBookItemName
    local i = 1
    while true do
        local name = getName(i, "spell")
        if not name then break end
        for _, buff in ipairs(KNOWN_BUFFS) do
            if name == buff then return buff end
        end
        i = i + 1
        if i > 1024 then break end
    end
end

-- read the buff's actual granted value off a LIVE aura on a group member -
-- handles buffs that scale with the caster's stats (Battle Screech/Agi,
-- Fleshcrafter/SP): the aura tooltip carries the applied number
local function ReadValueFromUnitAura(unit)
    for i = 1, 40 do
        local name = UnitBuff(unit, i)
        if not name then break end
        if name == db.buffName then
            scanTip:ClearLines()
            scanTip:SetOwner(UIParent, "ANCHOR_NONE")
            scanTip:SetUnitBuff(unit, i)
            for l = 1, 8 do
                local line = _G["SupportMeterScanTipTextLeft" .. l]
                local t = line and line:GetText()
                local v = t and t:match("power by (%d+)")
                if v then return tonumber(v) end
            end
            break
        end
    end
end

local function UnitTokenForName(name)
    if name == playerName then return "player" end
    local n = GetNumRaidMembers()
    if n > 0 then
        for i = 1, n do
            if UnitName("raid" .. i) == name then return "raid" .. i end
        end
    else
        for i = 1, GetNumPartyMembers() do
            if UnitName("party" .. i) == name then return "party" .. i end
        end
    end
end

---------------------------------------------------------------------------
-- attribution
---------------------------------------------------------------------------
local COEF_DB = _G.SUPPORTMETER_COEFS or {}
local COEF_NAMES = _G.SUPPORTMETER_COEF_NAMES or {}

local function Attribute(srcGUID, srcName, amount, school, spellName, spellId, isRanged, petO)
    if not amount or amount <= 0 then return end
    -- pet damage rides its OWNER's buff window (inherited stats)
    local guid = petO and petO.g or srcGUID
    local benef = buffed[guid]
    if not benef then return end

    -- expiry watchdog: if we never saw the REMOVED (out of log range),
    -- the window still dies when the buff duration has passed
    local t0 = buffedAt[guid]
    if db.buffDur > 0 and (not t0 or GetTime() - t0 > db.buffDur) then
        if audit and audit.win[guid] and t0 then
            local nm = buffed[guid]
            if nm then
                audit.up[nm] = (audit.up[nm] or 0)
                    + math.max(0, (t0 + db.buffDur) - audit.win[guid])
            end
            audit.win[guid] = nil
        end
        buffed[guid] = nil
        buffedAt[guid] = nil
        return
    end
    local key = petO and petO.n or srcName or benef

    -- record their damage mix (fallback for inferring their highest stat);
    -- pet hits stay OUT of the mix - a melee pet would misclassify a caster
    local isPhysical = (school == 1)
    local m = dmgMix[key]
    if not m then m = { phys = 0, magic = 0 } dmgMix[key] = m end
    if not petO then
        if isPhysical then m.phys = m.phys + amount else m.magic = m.magic + amount end
    end

    -- role: exact stats decide when available; otherwise the OBSERVED
    -- damage mix - partial gear scans misclassify hybrids/casters badly
    local role
    local p = db.pools[key]
    if p and p.exact then
        role = ((p.sp or 0) >= (p.ap or 0)) and "sp" or "ap"
    else
        role = (m.magic >= m.phys) and "sp" or "ap"
    end

    -- fight audit: record everything we saw from this unit
    local a
    if audit then
        a = audit.benef[key]
        if not a then
            a = { phys = 0, magic = 0, attr = 0, skip = 0, petd = 0 }
            audit.benef[key] = a
        end
        a.role = role
        a.pool = GetPool(key, role == "ap")
        if petO then
            a.petd = (a.petd or 0) + amount
        elseif isPhysical then
            a.phys = a.phys + amount
        else
            a.magic = a.magic + amount
        end
    end

    -- the buff feeds the ROLE stat; every path below credits against it
    local roleAP = (role == "ap")
    local V = db.buffValue
    local pool = GetPool(key, roleAP)
    if petO then
        -- pet inherits ratio x owner stat, so the buff's slice inside the
        -- pet's pool is ratio x V against a ratio-scaled pool (the ratio
        -- cancels in the share path; coef path approximates the pet pool)
        local r = db.petRatio or 0.5
        V = V * r
        pool = pool * r
    end
    -- best available model per ability: user override > generated DB by
    -- spell ID (exact rank) > measured share > class-average guess
    local attr
    local tier = 3
    local coef = (spellName and db.abilityCoef[spellName])
        or (spellId and COEF_DB[spellId])
        or (spellName and COEF_NAMES[spellName])
    -- verified-flat spells earn a hard ZERO (under-estimate policy)
    if coef and coef.z and not coef.c and not coef.ca and not coef.w then
        if a then a.skip = a.skip + amount end
        if audit then audit.model.zero = audit.model.zero + amount end
        do
            local key2 = spellId or 0
            local s = spellsSeen[key2]
            if not s then
                s = { n = spellName or "?", d = 0, t = 4 }
                spellsSeen[key2] = s
            end
            s.d = s.d + amount
        end
        return
    end
    -- coefficient choice: when the damage school MATCHES the buffed stat,
    -- either coefficient proves scaling (db wording varies); when it does
    -- NOT match, only an explicit coefficient on the buffed stat counts -
    -- hybrids like Tinker fire abilities scale with AP despite the school,
    -- and they must NOT be school-gated away
    local cEff
    if coef then
        if isPhysical == roleAP then
            cEff = roleAP and (coef.ca or coef.c) or (coef.c or coef.ca)
        elseif roleAP then
            cEff = coef.ca
        else
            cEff = coef.c
        end
    end
    if cEff and cEff > 0 then
        tier = 1
        attr = amount * (cEff * V) / ((coef.b or 0) + cEff * (pool + V))
    else
        -- non-coefficient paths can't prove cross-school scaling: damage
        -- whose school doesn't match the buffed stat earns no credit
        -- (pets exempt - inherited stats feed everything they do)
        if not petO and roleAP ~= isPhysical then
            if a then a.skip = a.skip + amount end
            return
        end
        -- weapon-damage hits (auto attacks + "X% weapon damage" abilities):
        -- AP feeds them as AP/14 per weapon-speed second, so with the
        -- target's weapon DPS known the buff slice is exact (speed and
        -- the % multiplier cancel out)
        local wd
        -- (owner's weapon DPS says nothing about the pet's weapon: pets
        -- always fall through to the share path)
        if isPhysical and not petO then
            local pp = db.pools[key]
            if pp then wd = isRanged and pp.rdps or pp.wdps end
        end
        if wd and wd > 0 and (not spellName or isRanged or (coef and coef.w)) then
            tier = 2
            attr = amount * (V / 14) / (wd + (pool + V) / 14)
        else
            local share = (spellName and db.abilityShare[spellName])
                or (isPhysical and db.shareMelee or db.share)
            attr = amount * share * V / (pool + V)
            -- log spells the coefficient DB doesn't know for future scrapes
            if spellId and spellName and not (coef and coef.w) and not db.newSpells[spellId] then
                local n = 0
                for _ in pairs(db.newSpells) do n = n + 1 end
                if n < 500 then db.newSpells[spellId] = spellName end
            end
        end
    end
    if a then a.attr = a.attr + attr end
    do
        local key2 = spellId or 0
        local s = spellsSeen[key2]
        if not s then
            s = { n = spellName or (isRanged and "Auto Shot" or "Auto Attack"), d = 0, t = tier }
            spellsSeen[key2] = s
        end
        s.d = s.d + amount
        if tier < s.t then s.t = tier end
    end
    if audit then
        local m = audit.model
        if petO then m.pet = (m.pet or 0) + attr end
        if tier == 1 then
            m.coef = m.coef + attr
        elseif tier == 2 then
            m.weap = m.weap + attr
        else
            m.share = m.share + attr
            if spellId and spellName then
                local u = audit.unk[spellId]
                if not u then
                    u = { n = spellName, d = 0 }
                    audit.unk[spellId] = u
                end
                u.d = u.d + amount
            end
        end
    end

    totals[key] = (totals[key] or 0) + attr
    sessionAttr = sessionAttr + attr
    if inCombat then
        fightTotals[key] = (fightTotals[key] or 0) + attr
        fightAttr = fightAttr + attr
    end

    -- mirror into the Details segment bucket for the custom display
    local D = _G.Details
    if D then
        local c = D:GetCurrentCombat()
        if c and c.GetCombatNumber then
            local id = c:GetCombatNumber()
            if id then
                if id > maxCombatId then maxCombatId = id end
                local t = detailsData[id]
                if not t then t = {} detailsData[id] = t end
                t[key] = (t[key] or 0) + attr
                segTotals[id] = (segTotals[id] or 0) + attr

                -- mode "extra": Aug-style extension segment on MY bar in
                -- the normal Damage Done display (Details' own refresh
                -- renders total_extra as the translucent extra statusbar).
                -- mode "merge" is handled by the 1s reconciler instead.
                if db.mode == "extra" then
                    local me = c:GetActor(DETAILS_ATTRIBUTE_DAMAGE, playerName)
                    if me then me.total_extra = math.floor(segTotals[id]) end
                end
            end
        end
    end
end

---------------------------------------------------------------------------
-- per-fight audit (debug): what the addon saw and why it credited what
---------------------------------------------------------------------------
local function StartAudit()
    audit = { t0 = GetTime(), win = {}, up = {}, benef = {},
        model = { coef = 0, weap = 0, share = 0, zero = 0, pet = 0 }, unk = {} }
    for guid in pairs(buffed) do
        audit.win[guid] = audit.t0
    end
end

local function FinishAudit()
    if not audit then return end
    local now = GetTime()
    for guid, t in pairs(audit.win) do
        local name = buffed[guid]
        if name then
            audit.up[name] = (audit.up[name] or 0) + (now - t)
        end
    end
    local dur = math.max(1, now - audit.t0)
    local L = {}
    L[#L + 1] = ("== Fight %s | %ds | %s +%d | shares %.2f/%.2f | mode %s"):format(
        date("%H:%M:%S"), dur, db.buffName, db.buffValue, db.share, db.shareMelee, db.mode or "?")
    local any = false
    for name, a in pairs(audit.benef) do
        any = true
        local up = audit.up[name] or 0
        L[#L + 1] = ("%s  [%s pool %d%s]  buffed %.0fs (%d%%)"):format(
            name, a.role == "ap" and "AP" or "SP", a.pool or 0,
            (db.pools[name] and db.pools[name].exact) and " EXACT" or "",
            up, up / dur * 100)
        L[#L + 1] = ("   phys seen %s | magic seen %s | pet seen %s | credited %s | wrong-school skipped %s"):format(
            Fmt(a.phys), Fmt(a.magic), Fmt(a.petd or 0), Fmt(a.attr), Fmt(a.skip))
    end
    if not any then
        local n = 0
        for _ in pairs(buffed) do n = n + 1 end
        L[#L + 1] = ("   nothing credited: %d unit(s) buffed at fight end; no damage from buffed units seen"):format(n)
    end
    local m = audit.model
    L[#L + 1] = ("   model coverage: exact-coef %s | weapon-math %s | share-guess %s | flat-zeroed %s dmg | via pets %s (ratio %.2f)"):format(
        Fmt(m.coef), Fmt(m.weap), Fmt(m.share), Fmt(m.zero or 0), Fmt(m.pet or 0), db.petRatio or 0.5)
    local ul = {}
    for id, u in pairs(audit.unk) do ul[#ul + 1] = { id, u.n, u.d } end
    if #ul > 0 then
        table.sort(ul, function(x, y) return x[3] > y[3] end)
        local parts = {}
        for i = 1, math.min(#ul, 8) do
            parts[#parts + 1] = ("%s (%d) %s"):format(ul[i][2], ul[i][1], Fmt(ul[i][3]))
        end
        L[#L + 1] = "   MISSING from coef DB: " .. table.concat(parts, ", ")
            .. (#ul > 8 and (" +" .. (#ul - 8) .. " more") or "")
    end
    L[#L + 1] = ("   fight attributed total: %s"):format(Fmt(fightAttr))
    table.insert(auditLog, 1, table.concat(L, "\n"))
    if #auditLog > 8 then table.remove(auditLog) end
    audit = nil
    if RefreshDebug then RefreshDebug() end
end

-- the buff row NEVER lives in shared Details data (so hover tooltips,
-- reports and every other surface on Normal windows stay clean). We keep
-- our own rows and slot one into my actor's spell table ONLY while the
-- breakdown panel is open from a Redistributed window.
local function NewRow()
    return { id = db.buffSpellId, total = 0, counter = 0, successful_casted = 0,
        n_min = 0, n_max = 0, n_amt = 0, n_total = 0,
        c_min = 0, c_max = 0, c_amt = 0, c_total = 0,
        g_amt = 0, g_dmg = 0, r_amt = 0, r_dmg = 0,
        b_amt = 0, b_dmg = 0, a_amt = 0, a_dmg = 0,
        targets = {}, extra = {} }
end

local function EnsureRow(id)
    local row = myRows[id]
    if not row then
        row = NewRow()
        myRows[id] = row
    end
    return row
end

-- overall aggregate row: ONLY counts attribution through players that
-- actually exist in this overall combat - Details resets Overall on new
-- groups while our history spans older fights (raids etc), and the bar's
-- redistribution filters by actor presence, so the row must match it
local function BuildOverallRow(combat)
    local row = NewRow()
    if not (combat and combat.GetActor) then return row end
    for id, map in pairs(detailsData) do
        for n, v in pairs(map) do
            if combat:GetActor(DETAILS_ATTRIBUTE_DAMAGE, n) then
                local fv = math.floor(v)
                row.total = row.total + fv
                row.targets[n] = (row.targets[n] or 0) + fv
            end
        end
    end
    row.counter = 1
    row.n_amt = 1
    row.n_total = row.total
    row.n_max = row.total
    return row
end

-- rebuild a per-fight row from the persisted buckets (post-reload); prime
-- injApplied so the live reconciler does not double-add on top of it
local function RowFromData(id)
    local map = detailsData[id]
    if not map then return nil end
    local row = NewRow()
    local total = math.floor(segTotals[id] or 0)
    row.total = total
    row.counter = 1
    row.n_amt = 1
    row.n_total = total
    row.n_max = total
    row.n_min = total
    local inj = { me = total, byName = {} }
    for n, v in pairs(map) do
        local fv = math.floor(v)
        row.targets[n] = fv
        inj.byName[n] = fv
    end
    myRows[id] = row
    injApplied[id] = inj
    return row
end

local insertedTbl, insertedId

local function SyncBreakdownRow()
    local D = _G.Details
    if not (D and db and playerName) then return end

    local bw = D.GetBreakdownWindow and D:GetBreakdownWindow()
    local show, combat = false, nil
    if bw and bw.ativo and bw.instancia and bw.instancia.meu_id
        and db.redistWin[bw.instancia.meu_id] then
        local actor = D.GetActorObjectFromBreakdownWindow and D:GetActorObjectFromBreakdownWindow()
        if actor and (actor.nome or actor.name) == playerName then
            show = true
            combat = bw.instancia.showing
        end
    end

    local desiredTbl, row
    if show and combat then
        local me = combat.GetActor and combat:GetActor(DETAILS_ATTRIBUTE_DAMAGE, playerName)
        local tbl = me and me.spells and me.spells._ActorTable
        if tbl then
            if combat == D:GetOverallCombat() then
                row = BuildOverallRow(combat)
            elseif combat.GetCombatNumber then
                local cid = combat:GetCombatNumber()
                row = myRows[cid] or RowFromData(cid)
            end
            if row and row.total >= 1 then desiredTbl = tbl end
        end
    end

    local changed = false
    if insertedTbl and insertedTbl ~= desiredTbl then
        if insertedId then insertedTbl[insertedId] = nil end
        insertedTbl, insertedId = nil, nil
        changed = true
    end
    if desiredTbl and row then
        local rid = row.id or db.buffSpellId
        if rid then
            if desiredTbl[rid] == nil then changed = true end
            desiredTbl[rid] = row
            insertedTbl, insertedId = desiredTbl, rid
        end
    end

    -- the panel does not redraw itself out of combat: force a rebuild
    -- whenever the row was just inserted or removed while it is open
    if changed and bw and bw.ativo and D.OpenBreakdownWindow then
        local actor = D.GetActorObjectFromBreakdownWindow and D:GetActorObjectFromBreakdownWindow()
        if actor and bw.instancia then
            D:OpenBreakdownWindow(bw.instancia, actor, false, true)
        end
    end
end

-- old versions persisted the row into saved segments - scrub them away
local function PurgeOldRows()
    local D = _G.Details
    if not (D and playerName and db.knownBuffIds) then return end
    local function purge(combat)
        local me = combat and combat.GetActor
            and combat:GetActor(DETAILS_ATTRIBUTE_DAMAGE, playerName)
        local tbl = me and me.spells and me.spells._ActorTable
        if tbl then
            for sid in pairs(db.knownBuffIds) do tbl[sid] = nil end
        end
    end
    purge(D:GetCurrentCombat())
    purge(D:GetOverallCombat())
    local segs = D.GetCombatSegments and D:GetCombatSegments()
    if segs then
        for _, cmb in ipairs(segs) do purge(cmb) end
    end
end

-- hovering the buff's row in the breakdown: show the per-player source
-- list as a tooltip anchored to the bar (recognized via the bar frame's
-- cached spellId under the mouse - works on the bar, icon or dial)
local hoverOwner
local hoverWatch = CreateFrame("Frame")
local hvAcc = 0
hoverWatch:SetScript("OnUpdate", function(self, e)
    hvAcc = hvAcc + e
    if hvAcc < 0.15 then return end
    hvAcc = 0
    if not db then return end
    local D = _G.Details
    local bw = D and D.GetBreakdownWindow and D:GetBreakdownWindow()
    local sid = db.buffSpellId
    local f = GetMouseFocus and GetMouseFocus()
    -- keep showing for the hovered bar; if the bar was CLICKED (selection
    -- overlay visible) the tooltip stays pinned after the mouse leaves
    local cur
    if bw and bw.ativo and sid then
        if f and f.spellId == sid then
            cur = f
        elseif hoverOwner and hoverOwner.spellId == sid and hoverOwner:IsVisible()
            and hoverOwner.overlayTexture and hoverOwner.overlayTexture:IsShown() then
            cur = hoverOwner
        end
    end
    if cur then
        if hoverOwner ~= cur or not GameTooltip:IsOwned(cur) then
            hoverOwner = cur
            local combat = bw.instancia and bw.instancia.showing
            local row
            if combat then
                if combat == D:GetOverallCombat() then
                    row = BuildOverallRow(combat)
                elseif combat.GetCombatNumber then
                    local cid = combat:GetCombatNumber()
                    row = myRows[cid] or RowFromData(cid)
                end
            end
            GameTooltip:SetOwner(cur, "ANCHOR_RIGHT")
            GameTooltip:AddLine(db.buffName .. " - attributed from", 0, 0.8, 1)
            if row and next(row.targets) then
                local list = {}
                for n, v in pairs(row.targets) do list[#list + 1] = { n, v } end
                table.sort(list, function(x, y) return x[2] > y[2] end)
                for i = 1, math.min(#list, 12) do
                    GameTooltip:AddDoubleLine(list[i][1], Fmt(list[i][2]), 1, 1, 1, 1, 0.82, 0)
                end
                if #list > 12 then
                    GameTooltip:AddLine(("... and %d more"):format(#list - 12), 0.6, 0.6, 0.6)
                end
                GameTooltip:AddDoubleLine("Total", Fmt(row.total or 0), 0.6, 1, 0.6, 0.6, 1, 0.6)
            else
                GameTooltip:AddLine("no attribution data for this segment", 0.7, 0.7, 0.7)
            end
            GameTooltip:Show()
        end
    elseif hoverOwner then
        if GameTooltip:IsOwned(hoverOwner) then GameTooltip:Hide() end
        hoverOwner = nil
    end
end)

-- zero out my extension segment everywhere (option turned off)
local function ClearExtraBars()
    local D = _G.Details
    if not (D and playerName) then return end
    local function clearIn(combat)
        if combat and combat.GetActor then
            local actor = combat:GetActor(DETAILS_ATTRIBUTE_DAMAGE, playerName)
            if actor then actor.total_extra = 0 end
        end
    end
    clearIn(D:GetCurrentCombat())
    clearIn(D:GetOverallCombat())
    local segs = D.GetCombatSegments and D:GetCombatSegments()
    if segs then
        for _, cmb in ipairs(segs) do clearIn(cmb) end
    end
end

---------------------------------------------------------------------------
-- mode "merge": full redistribution inside the DEFAULT Damage Done / DPS.
-- Batched once a second: my actor.total grows by the attributed delta (and
-- a real spell row for the buff is added so clicking my bar accounts for
-- it), each beneficiary's actor.total shrinks by their share. Solid bars,
-- real ranking - the retail post-support-events look.
---------------------------------------------------------------------------

-- maintains OUR OWN buff row per fight (never written into shared data;
-- SyncBreakdownRow slots it into view only when appropriate). Bar
-- redistribution is per-window at draw time (InstallRedistHook).
local function ReconcileInjection()
    if not db then return end
    local D = _G.Details
    if not D then return end
    local c = D:GetCurrentCombat()
    if not (c and c.GetCombatNumber) then return end
    local id = c:GetCombatNumber()
    local map = detailsData[id]
    if not map then return end
    local inj = injApplied[id]
    if not inj then inj = { me = 0, byName = {} } injApplied[id] = inj end

    local row = EnsureRow(id)
    if db.buffSpellId then row.id = db.buffSpellId end

    local target = math.floor(segTotals[id] or 0)
    local delta = target - inj.me
    if delta >= 1 then
        row.total = row.total + delta
        row.counter = row.counter + 1
        row.n_amt = row.n_amt + 1
        row.n_total = row.n_total + delta
        if delta > row.n_max then row.n_max = delta end
        if row.n_min == 0 or delta < row.n_min then row.n_min = delta end
        inj.me = target
    end

    for name, v in pairs(map) do
        local applied = inj.byName[name] or 0
        local d2 = math.floor(v) - applied
        if d2 >= 1 then
            inj.byName[name] = applied + d2
            row.targets[name] = (row.targets[name] or 0) + d2
        end
    end
end

---------------------------------------------------------------------------
-- Details! custom display ("Support DPS")
---------------------------------------------------------------------------
-- attributed-damage map (name -> value) for whichever segment Details shows
local function GetSegmentMap(combat)
    local D = _G.Details
    if not D then return nil end
    if combat == D:GetOverallCombat() then
        local map = {}
        for _, t in pairs(detailsData) do
            for name, v in pairs(t) do map[name] = (map[name] or 0) + v end
        end
        return map
    elseif combat.GetCombatNumber then
        return detailsData[combat:GetCombatNumber()]
    end
end

-- breakdown display: one bar per beneficiary the buff earned through
function SupportMeter_FillCustom(combat, container)
    local map = GetSegmentMap(combat)
    if not map then return 0, 0, 0 end

    local total, top, amount = 0, 0, 0
    for name, value in pairs(map) do
        if value >= 1 then
            local actor = combat:GetActor(DETAILS_ATTRIBUTE_DAMAGE, name)
            if actor then
                container:AddValue(actor, math.floor(value))
                total = total + value
                if value > top then top = value end
                amount = amount + 1
            end
        end
    end
    return math.floor(total), math.floor(top), amount
end

-- merged display (retail-Augmentation style): every player's damage bar,
-- with the support share MOVED from each beneficiary onto my bar
function SupportMeter_FillMerged(combat, container)
    if not combat.GetActorList then return 0, 0, 0 end
    local map = GetSegmentMap(combat) or {}
    local myBonus = 0
    for _, v in pairs(map) do myBonus = myBonus + v end

    for _, player in ipairs(combat:GetActorList(DETAILS_ATTRIBUTE_DAMAGE)) do
        if player:IsGroupPlayer() then
            local nm = player.nome or player.name
            local value = (player.total or 0) - (map[nm] or 0)
            -- fold pets into their owner, minus what the buff earned off the pet
            if player.pets then
                for _, petName in ipairs(player.pets) do
                    local pet = combat:GetActor(DETAILS_ATTRIBUTE_DAMAGE, petName)
                    if pet then
                        value = value + (pet.total or 0) - (map[petName] or 0)
                    end
                end
            end
            if nm == playerName then value = value + myBonus end
            if value >= 1 then
                container:AddValue(player, math.floor(value))
            end
        end
    end

    local total, top = container:GetTotalAndHighestValue()
    return math.floor(total), math.floor(top), container:GetNumActors()
end

-- hover tooltip on a breakdown bar: per-spell attributed gain. Every spell
-- of the boosted school gains the SAME fraction of its damage (per-ability
-- coefficients cancel in V/(pool+V)), so gain = spell damage x fraction.
function SupportMeter_FillTooltip(actor, combat)
    local GameCooltip = _G.GameCooltip2
    if not GameCooltip then return end
    local nm = actor.nome or actor.name
    if not nm then return end
    local player = combat:GetActor(DETAILS_ATTRIBUTE_DAMAGE, nm)
    if not (player and player.GetSpellList) then return end

    -- same role/pool/fraction logic as the attribution engine
    local role
    local p = db.pools[nm]
    if p and p.exact then
        role = ((p.sp or 0) >= (p.ap or 0)) and "sp" or "ap"
    else
        local m = dmgMix[nm]
        role = (m and m.phys > m.magic) and "ap" or "sp"
    end
    local isAP = (role == "ap")
    local share = isAP and db.shareMelee or db.share
    local pool = GetPool(nm, isAP)
    local frac = share * db.buffValue / (pool + db.buffValue)

    local list = {}
    for spellID, spellTable in pairs(player:GetSpellList()) do
        local school = spellTable.spellschool or spellTable.school or 1
        if ((school == 1) == isAP) then
            local gain = (spellTable.total or 0) * frac
            if gain >= 1 then list[#list + 1] = { spellID, gain } end
        end
    end
    table.sort(list, function(a, b) return a[2] > b[2] end)

    local topGain = list[1] and list[1][2] or 0
    local lineH = (_G._detalhes and _detalhes.tooltip and _detalhes.tooltip.line_height) or 14
    for i = 1, math.min(#list, 8) do
        local spellID, gain = list[i][1], list[i][2]
        local spellName, _, spellIcon = Details.GetSpellInfo(spellID)
        GameCooltip:AddLine(spellName or ("spell " .. spellID), Fmt(gain))
        Details:AddTooltipBackgroundStatusbar(false, gain / topGain * 100)
        if spellIcon then
            GameCooltip:AddIcon(spellIcon, 1, 1, lineH, lineH, 0.078125, 0.921875, 0.078125, 0.921875)
        end
    end
end

local InstallDetailsPlugin   -- defined after the options panel (needs it)
local AttachWindowButtons    -- ditto (title-bar toggle icons)

local function InstallDetailsDisplay()
    local D = _G.Details
    if not (D and D.InstallCustomObject) then return false end
    D:InstallCustomObject({
        name = "Support DPS",
        icon = [[Interface\Icons\Ability_Warrior_BattleShout]],
        attribute = false,
        spellid = false,
        author = "Arc",
        desc = "Breakdown: who your support buff earned its damage through (SupportMeter). Hover a bar for per-spell gains.",
        source = false,
        target = false,
        script_version = 3,
        script = [[
            local combat, container, instance = ...
            if _G.SupportMeter_FillCustom then
                return _G.SupportMeter_FillCustom(combat, container)
            end
            return 0, 0, 0
        ]],
        tooltip = [[
            local actor, combat, instance = ...
            if _G.SupportMeter_FillTooltip then
                _G.SupportMeter_FillTooltip(actor, combat)
            end
        ]],
    })
    D:InstallCustomObject({
        name = "Damage Done + Support",
        icon = [[Interface\Icons\INV_Sword_27]],
        attribute = false,
        spellid = false,
        author = "Arc",
        desc = "Damage meter with support redistribution: your buff's share is moved from each buffed player onto your bar (SupportMeter).",
        source = false,
        target = false,
        script_version = 3,
        script = [[
            local combat, container, instance = ...
            if _G.SupportMeter_FillMerged then
                return _G.SupportMeter_FillMerged(combat, container)
            end
            return 0, 0, 0
        ]],
        tooltip = false,
    })
    if D.RemoveCustomObject then
        D:RemoveCustomObject("Damage Done (No Support)")
        D:RemoveCustomObject("Damage Done (Raw)")
    end
    return true
end

---------------------------------------------------------------------------
-- per-window redistribution in the NATIVE damage displays. The shared
-- data always stays vanilla; when a flagged window redraws, we add the
-- support redistribution to the actor totals just for that draw and put
-- everything back immediately after. Works for Damage Done and DPS.
---------------------------------------------------------------------------
local redistHooked
local function InstallRedistHook()
    local D = _G.Details
    if redistHooked or not (D and D.atributo_damage and D.atributo_damage.RefreshWindow) then return end
    redistHooked = true
    local orig = D.atributo_damage.RefreshWindow
    D.atributo_damage.RefreshWindow = function(selfClass, instanceObject, combatObject, bForceUpdate, bExportData)
        local id = instanceObject and instanceObject.meu_id
        if not (id and db and db.redistWin and db.redistWin[id] and combatObject and playerName) then
            return orig(selfClass, instanceObject, combatObject, bForceUpdate, bExportData)
        end
        local map = GetSegmentMap(combatObject)
        local me = map and combatObject.GetActor
            and combatObject:GetActor(DETAILS_ATTRIBUTE_DAMAGE, playerName)
        if not me then
            return orig(selfClass, instanceObject, combatObject, bForceUpdate, bExportData)
        end

        local touched = {}
        local myBonus = 0
        for name, v in pairs(map) do
            local actor = combatObject:GetActor(DETAILS_ATTRIBUTE_DAMAGE, name)
            if actor then
                v = math.floor(v)
                actor.total = actor.total - v
                touched[actor] = v
                myBonus = myBonus + v
            end
        end
        me.total = me.total + myBonus

        local r1, r2, r3 = orig(selfClass, instanceObject, combatObject, bForceUpdate, bExportData)

        me.total = me.total - myBonus
        for actor, v in pairs(touched) do
            actor.total = actor.total + v
        end
        return r1, r2, r3
    end
end

-- per-window alpha-segment filter: Details passes the window object into
-- its extra-statusbar renderer, so we can suppress the segment for
-- windows the user turned off (db.segOff[window id])
local segFilterInstalled
local function InstallSegmentFilter()
    local D = _G.Details
    if segFilterInstalled or not (D and D.ShowExtraStatusbar) then return end
    segFilterInstalled = true
    local orig = D.ShowExtraStatusbar
    D.ShowExtraStatusbar = function(selfD, thisLine, amount, extraAmount, totalAmount, topAmount, instanceObject, ...)
        if instanceObject and db and db.segOff and instanceObject.meu_id
            and db.segOff[instanceObject.meu_id] then
            extraAmount = 0
        end
        return orig(selfD, thisLine, amount, extraAmount, totalAmount, topAmount, instanceObject, ...)
    end
end

-- per-window breakdown: opened/refreshed from a Normal window the buff
-- spell row is stripped for the draw (pure vanilla breakdown); from a
-- Redistributed window my total is raised for the draw so the row's
-- percent is computed against the redistributed total
local bdHooked
local function InstallBreakdownFilter()
    local D = _G.Details
    if bdHooked or not (D and D.OpenBreakdownWindow) then return end
    bdHooked = true
    local orig = D.OpenBreakdownWindow
    D.OpenBreakdownWindow = function(selfD, instanceObject, actorObject, ...)
        local sid = db and db.buffSpellId
        local isMe = actorObject and (actorObject.nome or actorObject.name) == playerName
        local removed, bumped
        if sid and isMe and instanceObject and instanceObject.meu_id then
            if not db.redistWin[instanceObject.meu_id] then
                local tbl = actorObject.spells and actorObject.spells._ActorTable
                if tbl and tbl[sid] then
                    removed = tbl[sid]
                    tbl[sid] = nil
                end
            else
                local combat = instanceObject.showing
                local map = combat and GetSegmentMap(combat)
                if map then
                    local sum = 0
                    for _, v in pairs(map) do sum = sum + v end
                    bumped = math.floor(sum)
                    if bumped > 0 then
                        actorObject.total = actorObject.total + bumped
                    else
                        bumped = nil
                    end
                end
            end
        end
        local r1, r2, r3 = orig(selfD, instanceObject, actorObject, ...)
        if removed then
            actorObject.spells._ActorTable[sid] = removed
        end
        if bumped then
            actorObject.total = actorObject.total - bumped
        end
        return r1, r2, r3
    end
end

-- hover tooltip on my bar in a Redistributed window: slot our row in just
-- for the tooltip build so Aerodynamics shows without opening the panel
local ttHooked
local function InstallTooltipFilter()
    local D = _G.Details
    if ttHooked or not (D and D.atributo_damage and D.atributo_damage.ToolTip_DamageDone) then return end
    ttHooked = true
    local orig = D.atributo_damage.ToolTip_DamageDone
    D.atributo_damage.ToolTip_DamageDone = function(selfActor, instancia, numero, barra, keydown)
        local inserted, tbl, rid
        if db and instancia and instancia.meu_id and db.redistWin[instancia.meu_id]
            and (selfActor.nome or selfActor.name) == playerName then
            tbl = selfActor.spells and selfActor.spells._ActorTable
            if tbl then
                local combat = instancia.showing
                local row
                if combat == D:GetOverallCombat() then
                    row = BuildOverallRow(combat)
                elseif combat and combat.GetCombatNumber then
                    local cid = combat:GetCombatNumber()
                    row = myRows[cid] or RowFromData(cid)
                end
                if row and row.total >= 1 then
                    rid = row.id or db.buffSpellId
                    if rid and not tbl[rid] then
                        tbl[rid] = row
                        inserted = true
                    end
                end
            end
        end
        local r1, r2, r3 = orig(selfActor, instancia, numero, barra, keydown)
        if inserted then tbl[rid] = nil end
        return r1, r2, r3
    end
end

---------------------------------------------------------------------------
-- tooltip-diff coefficient measurement: tooltips render damage numbers
-- computed from YOUR stats, even for other classes' spells. Snapshot all
-- missing spells' tooltips, swap gear, snapshot again - the number deltas
-- divided by the stat delta ARE the coefficients. /sm snap twice.
---------------------------------------------------------------------------
local tipSnap
local snapLog = {}           -- copy-paste-able measurement results
local MySP, MyAP   -- forward (defined in comms section)

local function CaptureOne(id, out)
    scanTip:ClearLines()
    scanTip:SetOwner(UIParent, "ANCHOR_NONE")
    scanTip:SetHyperlink("spell:" .. id)
    local nums, name, isWeapon
    nums = {}
    for l = 1, 12 do
        local fs = _G["SupportMeterScanTipTextLeft" .. l]
        local t = fs and fs:GetText()
        if t and not t:find("SpellID") and not t:find("IconID") then
            if l == 1 then name = t end
            if t:find("[Ww]eapon [Dd]amage") then isWeapon = true end
            local clean = t:gsub("%d+%.?%d*%%", "")
            for n in clean:gmatch("%d+") do
                nums[#nums + 1] = tonumber(n)
            end
        end
    end
    if name then
        out.t[id] = { name = name, nums = nums }
        -- weapon-damage tooltips have no stat-reactive numbers, so flag
        -- them for the weapon formula right at capture time
        if isWeapon and not db.abilityCoef[name] then
            db.abilityCoef[name] = { w = 1 }
        end
    end
end

local function SnapTargets(verify)
    local set = {}
    for id in pairs(db.newSpells) do set[id] = true end
    for _, id in ipairs(_G.SUPPORTMETER_SNAPLIST or {}) do
        if verify or not COEF_DB[id] then set[id] = true end
    end
    if verify then
        for id in pairs(COEF_DB) do set[id] = true end
    end
    local ids = {}
    for id in pairs(set) do ids[#ids + 1] = id end
    return ids
end

-- chunked capture: 250 tooltips per frame so big verify runs never hitch
local snapJob
local snapFrame = CreateFrame("Frame")
snapFrame:Hide()
snapFrame:SetScript("OnUpdate", function()
    local job = snapJob
    if not job then snapFrame:Hide() return end
    local n = 0
    while job.idx < #job.ids and n < 250 do
        job.idx = job.idx + 1
        CaptureOne(job.ids[job.idx], job.out)
        n = n + 1
    end
    if job.idx >= #job.ids then
        snapFrame:Hide()
        snapJob = nil
        job.done(job.out)
    end
end)

local function StartCapture(verify, done)
    if snapJob then
        print(TAG .. "a capture is already running, wait a moment.")
        return
    end
    snapJob = { ids = SnapTargets(verify), idx = 0,
        out = { sp = MySP(), ap = MyAP(), t = {} }, done = done }
    snapFrame:Show()
end

local ProcessSnap2

local function SnapCommand(verify)
    if not tipSnap then
        StartCapture(verify, function(out)
            tipSnap = out
            tipSnap.verify = verify
            local n = 0
            for _ in pairs(tipSnap.t) do n = n + 1 end
            print(TAG .. ("snapshot 1: %d spells captured at SP %d / AP %d."):format(n, tipSnap.sp, tipSnap.ap))
            print(TAG .. ("now swap SP or AP gear and run /sm %s again."):format(verify and "verify" or "snap"))
        end)
        return
    end
    StartCapture(tipSnap.verify, function(out) ProcessSnap2(out) end)
end

ProcessSnap2 = function(s2)
    local dsp = s2.sp - tipSnap.sp
    local dap = s2.ap - tipSnap.ap
    local stat = math.abs(dsp) >= math.abs(dap) and "sp" or "ap"
    local dstat = (stat == "sp") and dsp or dap
    if dstat == 0 then
        print(TAG .. "stats did not change between snapshots - swap gear first. Snapshot kept.")
        return
    end
    local base1 = (stat == "sp") and tipSnap.sp or tipSnap.ap
    local verify = tipSnap.verify
    local found, flat, okCount = 0, 0, 0
    snapLog = {}
    snapLog[1] = ("== SNAP %s | %s delta %+d (%d -> %d) =="):format(
        verify and "VERIFY" or "MEASUREMENTS",
        stat:upper(), dstat, base1, (stat == "sp") and s2.sp or s2.ap)
    -- phase 1: pick each spell's first plausible reacting number, and
    -- count identical deltas across spells - a delta shared by many
    -- unrelated spells is a tooltip artifact (a stat readout), not scaling
    -- phase 1: collect every plausible reacting number per spell, and
    -- count first-candidate deltas: a delta shared by 50+ spells is a
    -- tooltip artifact (families legitimately share coefficient deltas,
    -- but only an embedded stat readout hits hundreds of spells)
    local cands, dnCount = {}, {}
    for id, r1 in pairs(tipSnap.t) do
        local r2 = s2.t[id]
        if r2 and #r1.nums == #r2.nums and #r1.nums > 0 then
            local list = {}
            for k = 1, #r1.nums do
                local dn = r2.nums[k] - r1.nums[k]
                if dn ~= 0 then
                    local c = dn / dstat
                    if c > 0.01 and c <= 3 then
                        list[#list + 1] = { dn = dn, c = c,
                            b = math.max(0, math.floor(r1.nums[k] - c * base1 + 0.5)) }
                    end
                end
            end
            cands[id] = { r1 = r1, list = list }
            if list[1] then
                dnCount[list[1].dn] = (dnCount[list[1].dn] or 0) + 1
            end
        end
    end
    -- phase 2: pick each spell's first NON-artifact candidate
    local picks, noReact, mismatches = {}, {}, {}
    local tickSkipped, artifactSkipped = 0, 0
    for id, e in pairs(cands) do
        local pick
        for _, cand in ipairs(e.list) do
            if (dnCount[cand.dn] or 0) < 50 then
                pick = cand
                break
            end
        end
        if pick then
            picks[#picks + 1] = { id = id, r1 = e.r1, c = pick.c, b = pick.b }
        elseif #e.list > 0 then
            artifactSkipped = artifactSkipped + 1
        elseif not COEF_DB[id] then
            flat = flat + 1
            noReact[#noReact + 1] = ("%d %s"):format(id, e.r1.name)
            -- no page, no tooltip reaction: zero it (under-estimate policy)
            if not db.abilityCoef[e.r1.name] then
                db.abilityCoef[e.r1.name] = { z = 1 }
            end
        end
    end
    -- phase 3: process picks
    for _, p in ipairs(picks) do
        do
            local dbe = COEF_DB[p.id]
            local expected = dbe and ((stat == "sp") and dbe.c or dbe.ca)
            if dbe and dbe.t then
                -- per-tick DB entries vs whole-duration tooltips: not
                -- comparable, the DB per-tick value is the correct one
                tickSkipped = tickSkipped + 1
            elseif expected and expected > 0 then
                local rel = math.abs(p.c - expected) / expected
                if rel <= 0.12 then
                    okCount = okCount + 1
                else
                    mismatches[#mismatches + 1] = { rel, ("%d | %s | DB %.1f%% vs measured %.1f%% %s"):format(
                        p.id, p.r1.name, expected * 100, p.c * 100, stat:upper()) }
                end
            elseif not (dbe and (dbe.c or dbe.ca or dbe.w)) then
                local entry = db.abilityCoef[p.r1.name] or {}
                entry.b = p.b
                entry.z = nil   -- a real measurement un-zeroes a flat mark
                if stat == "sp" then entry.c = p.c else entry.ca = p.c end
                db.abilityCoef[p.r1.name] = entry
                snapLog[#snapLog + 1] = ("%d | %s | base %d + %.1f%% %s"):format(p.id, p.r1.name, p.b, p.c * 100, stat:upper())
                found = found + 1
            end
        end
    end
    if verify then
        table.sort(mismatches, function(x, y) return x[1] > y[1] end)
        snapLog[#snapLog + 1] = ""
        snapLog[#snapLog + 1] = ("VERIFIED OK: %d within 12%% | MISMATCHES: %d | tick-based skipped: %d | artifact deltas discarded: %d"):format(
            okCount, #mismatches, tickSkipped, artifactSkipped)
        for i = 1, math.min(#mismatches, 50) do
            snapLog[#snapLog + 1] = "  " .. mismatches[i][2]
        end
    end
    snapLog[#snapLog + 1] = ""
    snapLog[#snapLog + 1] = ("%d new measured and applied; %d flat/unreactive."):format(found, flat)
    for i = 1, math.min(#noReact, 40) do
        snapLog[#snapLog + 1] = "  no reaction: " .. noReact[i]
    end
    print(TAG .. ("done: %d verified ok, %d mismatches, %d new measured - results window opened."):format(okCount, #mismatches, found))
    tipSnap = nil
    CreateDebugWindow()
    dbgWin.mode = "snap"
    dbgWin:Show()
    RefreshDebug()
end

---------------------------------------------------------------------------
-- group comms: plugin users broadcast their EXACT own stats (the only
-- stats the client can read); everyone else stays predicted
---------------------------------------------------------------------------
local COMM_PREFIX = "SMTR"
local lastBroadcast = 0
local lastSentSP, lastSentAP = -1, -1

MySP = function()
    local best = 0
    for school = 2, 7 do
        local v = GetSpellBonusDamage(school)
        if v and v > best then best = v end
    end
    return best
end

MyAP = function()
    local base, pos, neg = UnitAttackPower("player")
    return math.max(0, (base or 0) + (pos or 0) + (neg or 0))
end

local function BroadcastStats(force)
    if not db or not db.comm then return end
    local now = GetTime()
    if not force and now - lastBroadcast < 15 then return end
    local chan
    if GetNumRaidMembers() > 0 then chan = "RAID"
    elseif GetNumPartyMembers() > 0 then chan = "PARTY"
    else return end
    lastBroadcast = now
    lastSentSP, lastSentAP = MySP(), MyAP()
    local function wdpsOf(slot)
        local link = GetInventoryItemLink("player", slot)
        if not link then return 0 end
        scanTip:ClearLines()
        scanTip:SetOwner(UIParent, "ANCHOR_NONE")
        scanTip:SetHyperlink(link)
        for l = 1, 30 do
            local t = _G["SupportMeterScanTipTextLeft" .. l]
            t = t and t:GetText()
            local v = t and t:match("%(([%d%.]+) damage per second%)")
            if v then return tonumber(v) end
        end
        return 0
    end
    SendAddonMessage(COMM_PREFIX, ("S2:%d:%d:%.1f:%.1f")
        :format(lastSentSP, lastSentAP, wdpsOf(16), wdpsOf(18)), chan)
end

---------------------------------------------------------------------------
-- inspect sweep: read raiders' gear, sum their SP/AP from item tooltips
-- (same source the logs website's uploader uses)
---------------------------------------------------------------------------
local inspectQueue = {}
local inspecting = nil
local inspectTimer = 0
local sweepQuiet = false

local function ScanInspectedGear(unit)
    local sp, ap = 0, 0
    local mhDps, rDps
    local found = false
    for slot = 1, 18 do
        local link = GetInventoryItemLink(unit, slot)
        if link then
            found = true
            scanTip:ClearLines()
            scanTip:SetOwner(UIParent, "ANCHOR_NONE")
            scanTip:SetHyperlink(link)
            for l = 1, 30 do
                local line = _G["SupportMeterScanTipTextLeft" .. l]
                local t = line and line:GetText()
                if t then
                    local v = t:match("[Ss]pell power by (%d+)")
                    if v then sp = sp + tonumber(v) end
                    v = t:match("[Aa]ttack power by (%d+)")
                    if v then ap = ap + tonumber(v) end
                    if slot == 16 or slot == 18 then
                        local dv = t:match("%(([%d%.]+) damage per second%)")
                        if dv then
                            if slot == 16 then mhDps = tonumber(dv) else rDps = tonumber(dv) end
                        end
                    end
                end
            end
        end
    end
    if found then
        local name = UnitName(unit)
        if name then
            db.pools[name] = db.pools[name] or {}
            -- exact stats (broadcast by their own SupportMeter) always beat
            -- the gear scan; otherwise gear numbers are a floor (no base
            -- stats) so only use when bigger than what we already know
            if db.pools[name].exact then return found end
            if sp > (db.pools[name].sp or 0) then db.pools[name].sp = sp end
            if ap > (db.pools[name].ap or 0) then db.pools[name].ap = ap end
            if mhDps then db.pools[name].wdps = mhDps end
            if rDps then db.pools[name].rdps = rDps end
            if not sweepQuiet then
                print(TAG .. ("inspected %s: gear SP %d, gear AP %d"):format(name, sp, ap))
            end
        end
    end
    return found
end

local inspectPump = CreateFrame("Frame")
inspectPump:Hide()
inspectPump:SetScript("OnUpdate", function(self, e)
    inspectTimer = inspectTimer - e
    if inspectTimer > 0 then return end
    if inspecting then
        ScanInspectedGear(inspecting)
        if ClearInspectPlayer then ClearInspectPlayer() end
        inspecting = nil
    end
    local nextUnit = table.remove(inspectQueue, 1)
    if not nextUnit then
        self:Hide()
        if not sweepQuiet then print(TAG .. "inspect sweep done.") end
        RefreshGUI()
        return
    end
    if UnitExists(nextUnit) and CheckInteractDistance(nextUnit, 1) and CanInspect(nextUnit) then
        NotifyInspect(nextUnit)
        inspecting = nextUnit
        inspectTimer = 1.6
    else
        if not sweepQuiet then
            local nm = UnitName(nextUnit)
            if nm then print(TAG .. nm .. " out of inspect range - skipped.") end
        end
        inspectTimer = 0.1
    end
end)

local function StartInspectSweep(quiet)
    if inspectPump:IsShown() then return end
    sweepQuiet = quiet and true or false
    wipe(inspectQueue)
    local n = GetNumRaidMembers()
    if n > 0 then
        for i = 1, n do
            if not UnitIsUnit("raid" .. i, "player") then
                inspectQueue[#inspectQueue + 1] = "raid" .. i
            end
        end
    else
        for i = 1, GetNumPartyMembers() do
            inspectQueue[#inspectQueue + 1] = "party" .. i
        end
    end
    if #inspectQueue == 0 then
        if not sweepQuiet then print(TAG .. "no party/raid members to inspect.") end
        return
    end
    if not sweepQuiet then
        print(TAG .. "inspecting " .. #inspectQueue .. " members (stay in range)...")
    end
    inspecting = nil
    inspectTimer = 0
    inspectPump:Show()
end

---------------------------------------------------------------------------
-- events
---------------------------------------------------------------------------
local f = CreateFrame("Frame")
f:RegisterEvent("ADDON_LOADED")
f:RegisterEvent("PLAYER_LOGIN")
f:RegisterEvent("PLAYER_REGEN_DISABLED")
f:RegisterEvent("PLAYER_REGEN_ENABLED")
f:RegisterEvent("COMBAT_LOG_EVENT_UNFILTERED")
f:RegisterEvent("CHAT_MSG_ADDON")
f:RegisterEvent("PARTY_MEMBERS_CHANGED")
f:RegisterEvent("RAID_ROSTER_UPDATE")
f:RegisterEvent("UNIT_INVENTORY_CHANGED")
f:RegisterEvent("UNIT_PET")

f:SetScript("OnEvent", function(self, event, ...)
    if event == "COMBAT_LOG_EVENT_UNFILTERED" then
        if not db then return end
        local _, sub, srcGUID, srcName, srcFlags, dstGUID, dstName, _, a9, a10, a11, a12 = ...
        -- "mine" includes my pet/guardian: some support buffs are applied
        -- by a summon (e.g. Battle Screech via the War Falcon)
        local srcMine = srcGUID == playerGUID
            or (srcFlags and band(srcFlags, AFFIL_MINE) > 0)

        -- my buff windows
        if srcMine and a10 == db.buffName then
            if sub == "SPELL_AURA_APPLIED" or sub == "SPELL_AURA_REFRESH" then
                buffed[dstGUID] = dstName
                buffedAt[dstGUID] = GetTime()
                db.buffSpellId = a9   -- current rank's id, for the breakdown row
                db.knownBuffIds[a9] = true
                if audit and not audit.win[dstGUID] then
                    audit.win[dstGUID] = GetTime()
                end
                -- live value read off the real aura (scaling-buff safe);
                -- re-read on rank change or every 30s
                if not db.valueManual and (a9 ~= lastReadSpellId or GetTime() - lastValueRead > 30) then
                    local tok = UnitTokenForName(dstName)
                    local v = tok and ReadValueFromUnitAura(tok)
                    if v then
                        lastReadSpellId = a9
                        lastValueRead = GetTime()
                        db.buffValue = v
                    end
                end
            elseif sub == "SPELL_AURA_REMOVED" then
                if audit and audit.win[dstGUID] then
                    local nm = buffed[dstGUID] or dstName
                    if nm then
                        audit.up[nm] = (audit.up[nm] or 0) + (GetTime() - audit.win[dstGUID])
                    end
                    audit.win[dstGUID] = nil
                end
                buffed[dstGUID] = nil
                buffedAt[dstGUID] = nil
            end
            return
        end

        -- exclusive-group interaction: ANOTHER supporter's group buff
        -- landing on my target. Server rules may REPLACE my aura, or both
        -- may coexist with only one taking effect - so VERIFY: close my
        -- window only if my aura is actually gone from the target
        if not srcMine and (KNOWN_SET[a10] or a10 == db.buffName) and buffed[dstGUID]
            and (sub == "SPELL_AURA_APPLIED" or sub == "SPELL_AURA_REFRESH") then
            local mineStillUp = false
            local tok = dstName and UnitTokenForName(dstName)
            if tok then
                for i = 1, 40 do
                    local bname, _, _, _, _, _, _, caster = UnitBuff(tok, i)
                    if not bname then break end
                    if bname == db.buffName and (caster == "player" or caster == "pet") then
                        mineStillUp = true
                        break
                    end
                end
            else
                -- can't verify (out of range): keep the window, the 16s
                -- duration watchdog caps any error
                mineStillUp = true
            end
            if not mineStillUp then
                if audit and audit.win[dstGUID] then
                    local nm = buffed[dstGUID]
                    if nm then
                        audit.up[nm] = (audit.up[nm] or 0) + (GetTime() - audit.win[dstGUID])
                    end
                    audit.win[dstGUID] = nil
                end
                buffed[dstGUID] = nil
                buffedAt[dstGUID] = nil
            end
        end

        -- proc-buff tracking on group members (raises their pool while up)
        if db.procs[a10] and dstName then
            if sub == "SPELL_AURA_APPLIED" or sub == "SPELL_AURA_REFRESH" then
                local t = procActive[dstName]
                if not t then t = {} procActive[dstName] = t end
                t[a10] = true
            elseif sub == "SPELL_AURA_REMOVED" then
                local t = procActive[dstName]
                if t then t[a10] = nil end
            end
        end

        -- damage by buffed units (self AND own pet excluded: supporting
        -- yourself is just your own damage). Other players' pets ride
        -- their OWNER's buff window at the inheritance-reduced value
        if srcMine then return end
        local petO
        if not buffed[srcGUID] then
            petO = petOwner[srcGUID]
            if not (petO and buffed[petO.g] and (db.petRatio or 0) > 0) then return end
        end

        if sub == "SWING_DAMAGE" then
            Attribute(srcGUID, srcName, a9, 1, nil, nil, nil, petO)
        elseif sub == "RANGE_DAMAGE" then
            Attribute(srcGUID, srcName, a12, 1, a10, a9, true, petO)
        elseif sub == "SPELL_DAMAGE" or sub == "SPELL_PERIODIC_DAMAGE" then
            -- ignore list: known flat/non-scaling abilities earn no credit
            if not db.ignored[a10] then
                Attribute(srcGUID, srcName, a12, a11, a10, a9, nil, petO)
            end
        end
        return
    end

    if event == "CHAT_MSG_ADDON" then
        local prefix, msg, _, sender = ...
        if prefix ~= COMM_PREFIX or not db or sender == playerName then return end
        local sp, ap, wd, rd = msg:match("^S2:(%d+):(%d+):([%d%.]+):([%d%.]+)$")
        if not sp then sp, ap = msg:match("^S1:(%d+):(%d+)$") end
        if sp then
            local isNew = not (db.pools[sender] and db.pools[sender].exact)
            db.pools[sender] = { sp = tonumber(sp), ap = tonumber(ap), exact = true,
                wdps = wd and tonumber(wd) or nil, rdps = rd and tonumber(rd) or nil }
            -- answer newcomers so they get our exact stats too
            if isNew then BroadcastStats() end
        end
        return
    end

    if event == "PARTY_MEMBERS_CHANGED" or event == "RAID_ROSTER_UPDATE" then
        UpdateRosterLevels()
        UpdatePetMap()
        BroadcastStats()
        return
    end

    if event == "UNIT_PET" then
        UpdatePetMap()
        return
    end

    if event == "UNIT_INVENTORY_CHANGED" then
        if (...) == "player" then BroadcastStats() end
        return
    end

    if event == "ADDON_LOADED" then
        if (...) ~= "SupportMeter" then return end
        SupportMeterDB = SupportMeterDB or {}
        db = SupportMeterDB
        db.share = db.share or 0.45
        db.shareMelee = db.shareMelee or 0.55
        db.buffName = db.buffName or "Aerodynamics"
        db.buffValue = db.buffValue or 145
        db.pools = db.pools or {}
        db.defaults = db.defaults or { sp = 350, ap = 550 }
        db.baseSP = db.baseSP or 100
        db.baseAP = db.baseAP or 400
        db.buffDur = db.buffDur or 16
        db.knownBuffIds = db.knownBuffIds or {}
        if db.buffSpellId then db.knownBuffIds[db.buffSpellId] = true end
        -- persist the attribution buckets so saved Details segments keep
        -- their redistribution across /reload and relogs
        db.segData = db.segData or {}
        db.segSums = db.segSums or {}
        detailsData = db.segData
        segTotals = db.segSums
        for id in pairs(detailsData) do
            if id > maxCombatId then maxCombatId = id end
        end
        if db.autoInspect == nil then db.autoInspect = true end
        db.autoInterval = db.autoInterval or 120
        db.ignored = db.ignored or {}
        db.abilityShare = db.abilityShare or {}
        db.abilityCoef = db.abilityCoef or {}
        db.newSpells = db.newSpells or {}
        COEF_DB = _G.SUPPORTMETER_COEFS or COEF_DB
        COEF_NAMES = _G.SUPPORTMETER_COEF_NAMES or COEF_NAMES
        -- prune the missing-list: drop anything the database now covers
        for id, sname in pairs(db.newSpells) do
            if COEF_DB[id] or COEF_NAMES[sname] then
                db.newSpells[id] = nil
            end
        end
        db.procs = db.procs or {}
        db.petRatio = db.petRatio or 0.5
        db.segOff = db.segOff or {}
        db.redistWin = db.redistWin or {}
        if db.comm == nil then db.comm = true end
        db.mode = db.mode or (db.extraBar == false and "off" or "extra")
        self:UnregisterEvent("ADDON_LOADED")
        return
    end

    if event == "PLAYER_LOGIN" then
        playerGUID = UnitGUID("player")
        playerName = UnitName("player")
        if not db.buffManual then
            local found = FindSupportBuffInSpellbook()
            if found and found ~= db.buffName then
                db.buffName = found
                wipe(buffed)
                print(TAG .. "support buff auto-detected: |cffffd700" .. found .. "|r")
            end
        end
        if not db.valueManual then
            local v = AutoReadBuffValue()
            if v then db.buffValue = v end
        end
        print(TAG .. ("tracking %s (+%d, live-updates off real auras)."):format(db.buffName, db.buffValue))
        if InstallDetailsDisplay() then
            print(TAG .. "Details integration on: Plugins page has |cffffd700Support Meter|r (Options button); custom displays |cffffd700Damage Done + Support|r / |cffffd700Support DPS|r.")
        end
        if InstallDetailsPlugin then InstallDetailsPlugin() end
        InstallSegmentFilter()
        InstallRedistHook()
        InstallBreakdownFilter()
        InstallTooltipFilter()
        PurgeOldRows()
        if AttachWindowButtons then AttachWindowButtons() end
        print(TAG .. "loaded. |cffffd700/sm|r window, |cffffd700/sm options|r settings, |cffffd700/sm inspect|r gear scan.")
        UpdateRosterLevels()
        UpdatePetMap()
        BroadcastStats(true)
        return
    end

    if event == "PLAYER_REGEN_DISABLED" then
        inCombat = true
        fightStart = GetTime()
        fightAttr = 0
        wipe(fightTotals)
        StartAudit()
        RefreshGUI()
        return
    end

    if event == "PLAYER_REGEN_ENABLED" then
        inCombat = false
        fightDur = GetTime() - fightStart
        FinishAudit()
        ReconcileInjection()
        -- drop Details buckets for segments long since scrolled away
        for id in pairs(detailsData) do
            if maxCombatId - id > 40 then
                detailsData[id] = nil
                segTotals[id] = nil
                injApplied[id] = nil
                myRows[id] = nil
            end
        end
        RefreshGUI()
        return
    end
end)

-- live window refresh + periodic quiet re-inspect (the client never receives
-- other players' stat sheets, so gear re-scan is the only refresh possible)
local tick = CreateFrame("Frame")
local tAcc = 0
local autoAcc = 0
local commAcc = 0
local statAcc = 0
tick:SetScript("OnUpdate", function(self, e)
    tAcc = tAcc + e
    if tAcc >= 1 then
        tAcc = 0
        SyncBreakdownRow()
        ReconcileInjection()
        if gui and gui:IsShown() then RefreshGUI() end
    end
    commAcc = commAcc + e
    if commAcc >= 60 then
        commAcc = 0
        BroadcastStats()
    end
    -- in combat, watch OWN stats for proc swings and re-broadcast so other
    -- plugin users' picture of us stays exact through procs
    statAcc = statAcc + e
    if statAcc >= 3 then
        statAcc = 0
        if db and db.comm and inCombat then
            local sp, ap = MySP(), MyAP()
            if math.abs(sp - lastSentSP) >= 15 or math.abs(ap - lastSentAP) >= 15 then
                BroadcastStats(true)
            end
        end
    end
    if db and db.autoInspect then
        autoAcc = autoAcc + e
        if autoAcc >= db.autoInterval then
            autoAcc = 0
            if not inCombat and (GetNumRaidMembers() > 0 or GetNumPartyMembers() > 0) then
                StartInspectSweep(true)
            end
        end
    end
end)

---------------------------------------------------------------------------
-- GUI
---------------------------------------------------------------------------
local GOLD = { 1, 0.82, 0 }
local NUM_ROWS = 10
local rows = {}

local function Hairline(parent, y)
    local t = parent:CreateTexture(nil, "ARTWORK")
    t:SetTexture("Interface\\Buttons\\WHITE8X8")
    t:SetVertexColor(GOLD[1], GOLD[2], GOLD[3], 0.25)
    t:SetHeight(1)
    t:SetPoint("TOPLEFT", 20, y)
    t:SetPoint("TOPRIGHT", -20, y)
end

local function CreateGUI()
    if gui then return gui end

    gui = CreateFrame("Frame", "SupportMeterFrame", UIParent)
    gui:SetSize(380, 420)
    gui:SetPoint("CENTER", 200, 0)
    gui:SetFrameStrata("HIGH")
    gui:SetBackdrop({
        bgFile = "Interface\\Buttons\\WHITE8X8",
        edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
        tile = false, edgeSize = 32,
        insets = { left = 11, right = 12, top = 12, bottom = 11 },
    })
    gui:SetBackdropColor(0.07, 0.07, 0.09, 0.97)
    gui:SetMovable(true)
    gui:EnableMouse(true)
    gui:RegisterForDrag("LeftButton")
    gui:SetScript("OnDragStart", function(self) self:StartMoving() end)
    gui:SetScript("OnDragStop", function(self) self:StopMovingOrSizing() end)
    gui:SetClampedToScreen(true)
    gui:Hide()
    tinsert(UISpecialFrames, "SupportMeterFrame")

    local title = gui:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
    title:SetPoint("TOP", 0, -16)
    title:SetText("|cff00ccffSupport Meter|r")

    local close = CreateFrame("Button", nil, gui, "UIPanelCloseButton")
    close:SetPoint("TOPRIGHT", -4, -4)

    gui.status = gui:CreateFontString(nil, "OVERLAY", "GameFontDisableSmall")
    gui.status:SetPoint("TOP", 0, -40)
    gui.status:SetWidth(340)

    gui.fightLine = gui:CreateFontString(nil, "OVERLAY", "GameFontHighlight")
    gui.fightLine:SetPoint("TOPLEFT", 24, -60)
    gui.fightLine:SetWidth(330)
    gui.fightLine:SetJustifyH("LEFT")

    gui.sessLine = gui:CreateFontString(nil, "OVERLAY", "GameFontHighlight")
    gui.sessLine:SetPoint("TOPLEFT", 24, -80)
    gui.sessLine:SetWidth(330)
    gui.sessLine:SetJustifyH("LEFT")

    Hairline(gui, -102)

    local hdr = gui:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
    hdr:SetPoint("TOPLEFT", 28, -110)
    hdr:SetText("Beneficiary")
    hdr:SetTextColor(1, 0.82, 0)
    local hdr2 = gui:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
    hdr2:SetPoint("TOPLEFT", 220, -110)
    hdr2:SetText("Fight")
    hdr2:SetTextColor(1, 0.82, 0)
    local hdr3 = gui:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
    hdr3:SetPoint("TOPLEFT", 296, -110)
    hdr3:SetText("Session")
    hdr3:SetTextColor(1, 0.82, 0)

    for i = 1, NUM_ROWS do
        local row = CreateFrame("Frame", nil, gui)
        row:SetSize(336, 20)
        row:SetPoint("TOPLEFT", 22, -126 - (i - 1) * 21)
        if i % 2 == 1 then
            local bg = row:CreateTexture(nil, "BACKGROUND")
            bg:SetAllPoints()
            bg:SetTexture("Interface\\Buttons\\WHITE8X8")
            bg:SetVertexColor(1, 1, 1, 0.03)
        end
        row.name = row:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
        row.name:SetPoint("LEFT", 6, 0)
        row.name:SetWidth(186)
        row.name:SetJustifyH("LEFT")
        row.name:SetWordWrap(false)
        row.fight = row:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
        row.fight:SetPoint("LEFT", 196, 0)
        row.fight:SetWidth(72)
        row.fight:SetJustifyH("RIGHT")
        row.sess = row:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
        row.sess:SetPoint("LEFT", 272, 0)
        row.sess:SetWidth(60)
        row.sess:SetJustifyH("RIGHT")
        row:Hide()
        rows[i] = row
    end

    local resetBtn = CreateFrame("Button", nil, gui, "UIPanelButtonTemplate")
    resetBtn:SetSize(60, 20)
    resetBtn:SetPoint("BOTTOMLEFT", 20, 18)
    resetBtn:SetText("Reset")
    resetBtn:SetScript("OnClick", function()
        wipe(totals)
        wipe(fightTotals)
        sessionAttr = 0
        fightAttr = 0
        RefreshGUI()
    end)

    local inspBtn = CreateFrame("Button", nil, gui, "UIPanelButtonTemplate")
    inspBtn:SetSize(92, 20)
    inspBtn:SetPoint("LEFT", resetBtn, "RIGHT", 8, 0)
    inspBtn:SetText("Inspect raid")
    inspBtn:SetScript("OnClick", function() StartInspectSweep() end)

    local optBtn = CreateFrame("Button", nil, gui, "UIPanelButtonTemplate")
    optBtn:SetSize(70, 20)
    optBtn:SetPoint("LEFT", inspBtn, "RIGHT", 8, 0)
    optBtn:SetText("Options")
    optBtn:SetScript("OnClick", function() SlashCmdList["SUPPORTMETER"]("options") end)

    local dbgBtn = CreateFrame("Button", nil, gui, "UIPanelButtonTemplate")
    dbgBtn:SetSize(64, 20)
    dbgBtn:SetPoint("LEFT", optBtn, "RIGHT", 8, 0)
    dbgBtn:SetText("Debug")
    dbgBtn:SetScript("OnClick", function() SlashCmdList["SUPPORTMETER"]("debug") end)

    gui.note = gui:CreateFontString(nil, "OVERLAY", "GameFontDisableSmall")
    gui.note:SetPoint("BOTTOMRIGHT", -22, 44)
    gui.note:SetWidth(240)
    gui.note:SetJustifyH("RIGHT")
    gui.note:SetText("|cff00ff88*|r = exact stats (runs SupportMeter), rest predicted")

    return gui
end

RefreshGUI = function()
    if not gui or not gui:IsShown() then return end

    gui.status:SetText(("%s +%d   shares %.2f/%.2f   display: %s%s")
        :format(db.buffName, db.buffValue, db.share, db.shareMelee,
                db.mode or "extra",
                db.autoInspect and "   auto-scan" or ""))

    local dur = inCombat and (GetTime() - fightStart) or fightDur
    local dps = (dur and dur > 1) and (fightAttr / dur) or 0
    gui.fightLine:SetText(("Fight: |cff00ff00%s|r attributed  (|cff00ff00%s|r DPS)%s")
        :format(Fmt(fightAttr), Fmt(dps), inCombat and "  |cffffd700[live]|r" or ""))
    gui.sessLine:SetText(("Session: |cff00ccff%s|r attributed"):format(Fmt(sessionAttr)))

    local list = {}
    for name, v in pairs(totals) do
        list[#list + 1] = { name = name, sess = v, fight = fightTotals[name] or 0 }
    end
    table.sort(list, function(a, b) return a.sess > b.sess end)

    for i = 1, NUM_ROWS do
        local row = rows[i]
        local e = list[i]
        if e then
            local p = db.pools[e.name]
            row.name:SetText(e.name .. ((p and p.exact) and " |cff00ff88*|r" or ""))
            row.fight:SetText(e.fight > 0 and Fmt(e.fight) or "-")
            row.sess:SetText(Fmt(e.sess))
            row:Show()
        else
            row:Hide()
        end
    end
end

---------------------------------------------------------------------------
-- debug window: copy-paste-able per-fight audit log
---------------------------------------------------------------------------
CreateDebugWindow = function()
    if dbgWin then return dbgWin end
    dbgWin = CreateFrame("Frame", "SupportMeterDebugFrame", UIParent)
    dbgWin:SetSize(600, 440)
    dbgWin:SetPoint("CENTER", 0, 40)
    dbgWin:SetFrameStrata("DIALOG")
    dbgWin:SetBackdrop({
        bgFile = "Interface\\Buttons\\WHITE8X8",
        edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
        tile = false, edgeSize = 32,
        insets = { left = 11, right = 12, top = 12, bottom = 11 },
    })
    dbgWin:SetBackdropColor(0.07, 0.07, 0.09, 0.97)
    dbgWin:SetMovable(true)
    dbgWin:EnableMouse(true)
    dbgWin:RegisterForDrag("LeftButton")
    dbgWin:SetScript("OnDragStart", function(self) self:StartMoving() end)
    dbgWin:SetScript("OnDragStop", function(self) self:StopMovingOrSizing() end)
    dbgWin:SetClampedToScreen(true)
    dbgWin:Hide()
    tinsert(UISpecialFrames, "SupportMeterDebugFrame")

    local title = dbgWin:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
    title:SetPoint("TOP", 0, -16)
    title:SetText("|cff00ccffSupport Meter|r Fight Audit")

    local close = CreateFrame("Button", nil, dbgWin, "UIPanelCloseButton")
    close:SetPoint("TOPRIGHT", -4, -4)

    local sf = CreateFrame("ScrollFrame", "SupportMeterDebugScroll", dbgWin, "UIPanelScrollFrameTemplate")
    sf:SetPoint("TOPLEFT", 20, -44)
    sf:SetPoint("BOTTOMRIGHT", -40, 48)
    local eb = CreateFrame("EditBox", nil, sf)
    eb:SetMultiLine(true)
    eb:SetFontObject(ChatFontNormal)
    eb:SetWidth(530)
    eb:SetAutoFocus(false)
    eb:SetScript("OnEscapePressed", function(self) self:ClearFocus() end)
    sf:SetScrollChild(eb)
    dbgWin.eb = eb

    local selBtn = CreateFrame("Button", nil, dbgWin, "UIPanelButtonTemplate")
    selBtn:SetSize(90, 20)
    selBtn:SetPoint("BOTTOMLEFT", 20, 18)
    selBtn:SetText("Select All")
    selBtn:SetScript("OnClick", function()
        dbgWin.eb:SetFocus()
        dbgWin.eb:HighlightText()
    end)

    local clrBtn = CreateFrame("Button", nil, dbgWin, "UIPanelButtonTemplate")
    clrBtn:SetSize(70, 20)
    clrBtn:SetPoint("LEFT", selBtn, "RIGHT", 8, 0)
    clrBtn:SetText("Clear")
    clrBtn:SetScript("OnClick", function()
        if dbgWin.mode == "missing" then
            wipe(db.newSpells)
        elseif dbgWin.mode == "spells" then
            wipe(spellsSeen)
        elseif dbgWin.mode == "snap" then
            wipe(snapLog)
        else
            wipe(auditLog)
        end
        RefreshDebug()
    end)

    local modeBtn = CreateFrame("Button", nil, dbgWin, "UIPanelButtonTemplate")
    modeBtn:SetSize(110, 20)
    modeBtn:SetPoint("LEFT", clrBtn, "RIGHT", 8, 0)
    modeBtn:SetText("Show Missing")
    dbgWin.modeBtn = modeBtn
    modeBtn:SetScript("OnClick", function()
        if dbgWin.mode == "missing" then
            dbgWin.mode = "spells"
        elseif dbgWin.mode == "spells" then
            dbgWin.mode = "snap"
        elseif dbgWin.mode == "snap" then
            dbgWin.mode = "audit"
        else
            dbgWin.mode = "missing"
        end
        RefreshDebug()
    end)

    local hint = dbgWin:CreateFontString(nil, "OVERLAY", "GameFontDisableSmall")
    hint:SetPoint("BOTTOMRIGHT", -24, 22)
    hint:SetText("last 8 fights, newest first - updates when a fight ends")

    dbgWin:SetScript("OnShow", function() RefreshDebug() end)
    return dbgWin
end

RefreshDebug = function()
    if not (dbgWin and dbgWin:IsShown()) then return end
    if dbgWin.mode == "snap" then
        dbgWin.modeBtn:SetText("Show Audits")
        dbgWin.eb:SetText(#snapLog > 0 and table.concat(snapLog, "\n")
            or "No snap measurements yet.\n/sm snap, swap SP or AP gear, /sm snap again.")
    elseif dbgWin.mode == "spells" then
        dbgWin.modeBtn:SetText("Show Snap Results")
        local TIER_TAG = { [1] = "[exact]", [2] = "[weapon]", [3] = "[GUESS]", [4] = "[flat-zero]" }
        local list = {}
        for id, s in pairs(spellsSeen) do
            list[#list + 1] = { id, s.n, s.d, s.t }
        end
        table.sort(list, function(x, y) return x[3] > y[3] end)
        local L = {}
        for _, e in ipairs(list) do
            local tag = TIER_TAG[e[4]] or "?"
            if e[4] == 3 and e[1] ~= 0 then tag = tag .. "  << MISSING from DB" end
            L[#L + 1] = ("%-7d %-28s %8s  %s"):format(e[1], e[2]:sub(1, 28), Fmt(e[3]), tag)
        end
        dbgWin.eb:SetText(#L > 0
            and ("SPELLS SEEN FROM BUFFED PLAYERS (session, by damage)\nid      name                            damage  model\n\n"
                .. table.concat(L, "\n"))
            or "No spells observed yet this session.")
    elseif dbgWin.mode == "missing" then
        dbgWin.modeBtn:SetText("Show Spells Seen")
        local list = {}
        for id, name in pairs(db.newSpells) do
            list[#list + 1] = { id, name }
        end
        table.sort(list, function(x, y) return x[2] < y[2] end)
        local L = {}
        for _, e in ipairs(list) do
            L[#L + 1] = ("%d = %s"):format(e[1], e[2])
        end
        dbgWin.eb:SetText(#L > 0
            and ("MISSING FROM COEF DB (" .. #L .. " spells)\n\n" .. table.concat(L, "\n"))
            or "No missing spells recorded.")
    else
        dbgWin.modeBtn:SetText("Show Missing")
        if #auditLog > 0 then
            dbgWin.eb:SetText(table.concat(auditLog, "\n\n"))
        else
            dbgWin.eb:SetText("No fights recorded yet.\nGet into combat with your buff on someone, leave combat, and the audit for that fight appears here.")
        end
    end
    dbgWin.eb:SetCursorPosition(0)
end

---------------------------------------------------------------------------
-- options panel
---------------------------------------------------------------------------
local opt
local RefreshOptions
local IGNORE_ROWS = 6
local ignoreRows = {}

local MODE_LABELS = { off = "Off", extra = "Extra segment", merge = "Full redistribution" }
local MODE_NEXT = { off = "extra", extra = "merge", merge = "off" }
local UpdateWindowButtons   -- defined below (title-bar toggle icons)

local function SetMode(m)
    if not MODE_LABELS[m] or db.mode == m then return end
    if db.mode == "extra" then ClearExtraBars() end
    db.mode = m
    if m == "extra" then
        -- backfill the current fight's segment immediately
        local D = _G.Details
        local c = D and D:GetCurrentCombat()
        local id = c and c.GetCombatNumber and c:GetCombatNumber()
        if id and segTotals[id] then
            local me = c:GetActor(DETAILS_ATTRIBUTE_DAMAGE, playerName)
            if me then me.total_extra = math.floor(segTotals[id]) end
        end
    elseif m == "merge" then
        ReconcileInjection()
    end
    print(TAG .. "support display mode: |cffffd700" .. MODE_LABELS[m] .. "|r")
    -- force every window to redraw NOW so the toggle is instant even out
    -- of combat (bars otherwise wait for the next data event)
    local D = _G.Details
    if D and D.RefreshMainWindow then D:RefreshMainWindow(-1, true) end
    if RefreshOptions then RefreshOptions() end
    if UpdateWindowButtons then UpdateWindowButtons() end
    RefreshGUI()
end

local function MakeLabel(parent, text, x, y)
    local fs = parent:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
    fs:SetPoint("TOPLEFT", x, y)
    fs:SetText(text)
    return fs
end

local function MakeEdit(parent, name, x, y, w, onDone)
    local e = CreateFrame("EditBox", name, parent, "InputBoxTemplate")
    e:SetSize(w, 20)
    e:SetPoint("TOPLEFT", x, y)
    e:SetAutoFocus(false)
    e:SetScript("OnEnterPressed", function(self)
        onDone(self:GetText())
        self:ClearFocus()
        RefreshOptions()
    end)
    e:SetScript("OnEscapePressed", function(self)
        self:ClearFocus()
        RefreshOptions()
    end)
    return e
end

local function MakeCheck(parent, name, text, x, y, onClick)
    local c = CreateFrame("CheckButton", name, parent, "UICheckButtonTemplate")
    c:SetPoint("TOPLEFT", x, y)
    _G[name .. "Text"]:SetText(text)
    c:SetScript("OnClick", function(self)
        onClick(self:GetChecked() and true or false)
        RefreshOptions()
    end)
    return c
end

local function MakeSlider(parent, name, label, x, y, minV, maxV, step, onChange)
    local s = CreateFrame("Slider", name, parent, "OptionsSliderTemplate")
    s:SetPoint("TOPLEFT", x, y)
    s:SetWidth(150)
    s:SetMinMaxValues(minV, maxV)
    s:SetValueStep(step)
    _G[name .. "Low"]:SetText(tostring(minV))
    _G[name .. "High"]:SetText(tostring(maxV))
    s.label = _G[name .. "Text"]
    s.labelBase = label
    s:SetScript("OnValueChanged", function(self, v)
        v = math.floor(v * 100 + 0.5) / 100
        self.label:SetText(self.labelBase .. ": " .. v)
        if not self.loading then onChange(v) end
    end)
    return s
end

local function CreateOptions()
    if opt then return opt end

    opt = CreateFrame("Frame", "SupportMeterOptionsFrame", UIParent)
    opt:SetSize(380, 560)
    opt:SetPoint("CENTER", 240, 0)
    opt:SetFrameStrata("DIALOG")
    opt:SetBackdrop({
        bgFile = "Interface\\Buttons\\WHITE8X8",
        edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
        tile = false, edgeSize = 32,
        insets = { left = 11, right = 12, top = 12, bottom = 11 },
    })
    opt:SetBackdropColor(0.07, 0.07, 0.09, 0.97)
    opt:SetMovable(true)
    opt:EnableMouse(true)
    opt:RegisterForDrag("LeftButton")
    opt:SetScript("OnDragStart", function(self) self:StartMoving() end)
    opt:SetScript("OnDragStop", function(self) self:StopMovingOrSizing() end)
    opt:SetClampedToScreen(true)
    opt:Hide()
    tinsert(UISpecialFrames, "SupportMeterOptionsFrame")

    local title = opt:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
    title:SetPoint("TOP", 0, -16)
    title:SetText("|cff00ccffSupport Meter|r Options")

    local close = CreateFrame("Button", nil, opt, "UIPanelCloseButton")
    close:SetPoint("TOPRIGHT", -4, -4)

    -- buff
    MakeLabel(opt, "Tracked buff", 24, -50)
    opt.buffEdit = MakeEdit(opt, "SMOptBuffName", 130, -46, 150, function(t)
        t = t:trim()
        if t ~= "" and t ~= db.buffName then
            db.buffName = t
            db.buffManual = true
            wipe(buffed)
            local auto = AutoReadBuffValue()
            if auto and not db.valueManual then db.buffValue = auto end
        end
    end)

    MakeLabel(opt, "Buff power value", 24, -78)
    opt.valueEdit = MakeEdit(opt, "SMOptValue", 130, -74, 60, function(t)
        local v = tonumber(t)
        if v and v > 0 then
            db.buffValue = v
            db.valueManual = true
        end
    end)

    local readBtn = CreateFrame("Button", nil, opt, "UIPanelButtonTemplate")
    readBtn:SetSize(120, 20)
    readBtn:SetPoint("TOPLEFT", 200, -74)
    readBtn:SetText("Read spellbook")
    readBtn:SetScript("OnClick", function()
        local v = AutoReadBuffValue()
        if v then
            db.buffValue = v
            db.valueManual = nil
            print(TAG .. "value read from spellbook: " .. v .. " (auto-read back on)")
        else
            print(TAG .. "couldn't find '" .. db.buffName .. "' in your spellbook.")
        end
        RefreshOptions()
        RefreshGUI()
    end)

    -- shares
    opt.shareSlider = MakeSlider(opt, "SMOptShare", "Spell share", 28, -128,
        0.1, 1, 0.05, function(v) db.share = v RefreshGUI() end)
    opt.mshareSlider = MakeSlider(opt, "SMOptMShare", "Melee share", 202, -128,
        0.1, 1, 0.05, function(v) db.shareMelee = v RefreshGUI() end)

    -- auto scan + comm
    opt.autoCheck = MakeCheck(opt, "SMOptAuto", "Auto gear re-scan (out of combat)", 18, -166,
        function(on) db.autoInspect = on RefreshGUI() end)
    MakeLabel(opt, "every", 262, -176)
    opt.intervalEdit = MakeEdit(opt, "SMOptInterval", 300, -172, 40, function(t)
        local v = tonumber(t)
        if v then db.autoInterval = math.max(30, v) end
    end)
    MakeLabel(opt, "s", 346, -176)

    opt.commCheck = MakeCheck(opt, "SMOptComm", "Share my exact stats with the group", 18, -196,
        function(on) db.comm = on if on then BroadcastStats(true) end end)

    MakeLabel(opt, "Damage Done / DPS support display", 24, -232)
    opt.modeBtn = CreateFrame("Button", nil, opt, "UIPanelButtonTemplate")
    opt.modeBtn:SetSize(140, 20)
    opt.modeBtn:SetPoint("TOPLEFT", 216, -228)
    opt.modeBtn:SetScript("OnClick", function() SetMode(MODE_NEXT[db.mode] or "extra") end)

    -- fallback pools
    MakeLabel(opt, "Fallback SP", 24, -266)
    opt.defSPEdit = MakeEdit(opt, "SMOptDefSP", 100, -262, 55, function(t)
        local v = tonumber(t)
        if v and v > 0 then db.defaults.sp = v end
    end)
    MakeLabel(opt, "Fallback AP", 190, -266)
    opt.defAPEdit = MakeEdit(opt, "SMOptDefAP", 266, -262, 55, function(t)
        local v = tonumber(t)
        if v and v > 0 then db.defaults.ap = v end
    end)

    MakeLabel(opt, "Base SP bonus", 24, -296)
    opt.baseSPEdit = MakeEdit(opt, "SMOptBaseSP", 116, -292, 45, function(t)
        local v = tonumber(t)
        if v and v >= 0 then db.baseSP = v end
    end)
    MakeLabel(opt, "Base AP bonus", 190, -296)
    opt.baseAPEdit = MakeEdit(opt, "SMOptBaseAP", 282, -292, 45, function(t)
        local v = tonumber(t)
        if v and v >= 0 then db.baseAP = v end
    end)

    Hairline(opt, -322)

    -- ignore list
    MakeLabel(opt, "Ignored abilities (no power scaling) - click a row to remove", 24, -332)
    opt.ignoreEdit = MakeEdit(opt, "SMOptIgnore", 24, -352, 200, function() end)
    local addBtn = CreateFrame("Button", nil, opt, "UIPanelButtonTemplate")
    addBtn:SetSize(60, 20)
    addBtn:SetPoint("TOPLEFT", 236, -352)
    addBtn:SetText("Add")
    addBtn:SetScript("OnClick", function()
        local t = opt.ignoreEdit:GetText():trim()
        if t ~= "" then
            db.ignored[t] = true
            opt.ignoreEdit:SetText("")
            opt.ignoreEdit:ClearFocus()
        end
        RefreshOptions()
    end)

    for i = 1, IGNORE_ROWS do
        local btn = CreateFrame("Button", nil, opt)
        btn:SetSize(320, 18)
        btn:SetPoint("TOPLEFT", 26, -380 - (i - 1) * 19)
        btn.text = btn:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
        btn.text:SetPoint("LEFT", 4, 0)
        btn.text:SetWidth(312)
        btn.text:SetJustifyH("LEFT")
        local hl = btn:CreateTexture(nil, "HIGHLIGHT")
        hl:SetAllPoints()
        hl:SetTexture("Interface\\Buttons\\WHITE8X8")
        hl:SetVertexColor(1, 0.3, 0.3, 0.15)
        btn:SetScript("OnClick", function(self)
            if self.spell then
                db.ignored[self.spell] = nil
                RefreshOptions()
            end
        end)
        btn:Hide()
        ignoreRows[i] = btn
    end

    opt.hint = opt:CreateFontString(nil, "OVERLAY", "GameFontDisableSmall")
    opt.hint:SetPoint("BOTTOM", 0, 20)
    opt.hint:SetWidth(330)
    opt.hint:SetText("Details: window menu > Display > Custom > Damage Done + Support (meter) / Support DPS (breakdown)")

    opt:SetScript("OnShow", function() RefreshOptions() end)
    return opt
end

RefreshOptions = function()
    if not opt or not opt:IsShown() then return end
    opt.buffEdit:SetText(db.buffName)
    opt.valueEdit:SetText(tostring(db.buffValue))
    opt.shareSlider.loading = true
    opt.shareSlider:SetValue(db.share)
    opt.shareSlider.loading = false
    opt.shareSlider.label:SetText("Spell share: " .. db.share)
    opt.mshareSlider.loading = true
    opt.mshareSlider:SetValue(db.shareMelee)
    opt.mshareSlider.loading = false
    opt.mshareSlider.label:SetText("Melee share: " .. db.shareMelee)
    opt.autoCheck:SetChecked(db.autoInspect)
    opt.intervalEdit:SetText(tostring(db.autoInterval))
    opt.commCheck:SetChecked(db.comm)
    opt.modeBtn:SetText(MODE_LABELS[db.mode] or "Extra segment")
    opt.defSPEdit:SetText(tostring(db.defaults.sp))
    opt.defAPEdit:SetText(tostring(db.defaults.ap))
    opt.baseSPEdit:SetText(tostring(db.baseSP))
    opt.baseAPEdit:SetText(tostring(db.baseAP))

    local list = {}
    for name in pairs(db.ignored) do list[#list + 1] = name end
    table.sort(list)
    for i = 1, IGNORE_ROWS do
        local btn = ignoreRows[i]
        local name = list[i]
        if name then
            btn.spell = name
            btn.text:SetText("|cffff6060x|r  " .. name)
            btn:Show()
        else
            btn.spell = nil
            btn:Hide()
        end
    end
    if #list > IGNORE_ROWS then
        ignoreRows[IGNORE_ROWS].text:SetText(("... and %d more (/sm ignore lists all)"):format(#list - IGNORE_ROWS + 1))
        ignoreRows[IGNORE_ROWS].spell = nil
    end
end

---------------------------------------------------------------------------
-- Details! plugin registration: puts a "Support Meter" row (with a real
-- Options button opening our panel) on the Plugins page of the Details
-- options window
---------------------------------------------------------------------------
InstallDetailsPlugin = function()
    local D = _G.Details
    if not (D and D.NewPluginObject and D.InstallPlugin) then return end
    if _G.DETAILS_PLUGIN_SUPPORT_METER then return end
    local plugin = D:NewPluginObject("Details_SupportMeterFrame", 0, "TOOLBAR")
    if not plugin then return end
    if plugin.SetPluginDescription then
        plugin:SetPluginDescription("Attributes the damage your support raid buff adds through the group back to you, Augmentation-style. Display modes for the normal Damage Done window, Support DPS custom displays, exact-stat sharing between users. Slash: /sm")
    end
    plugin.OpenOptionsPanel = function()
        CreateOptions()
        opt:Show()
        RefreshOptions()
    end
    D:InstallPlugin("TOOLBAR", "Support Meter", [[Interface\Icons\Spell_Nature_Cyclone]],
        plugin, "DETAILS_PLUGIN_SUPPORT_METER", nil, "Arc", "v1.0")
end

---------------------------------------------------------------------------
-- title-bar toggle icon on every Details window, left of the cog wheel:
-- click cycles Off > Extra segment > Full redistribution, right-click
-- opens our options; icon dims when mode is off
---------------------------------------------------------------------------
local function CustomDisplayID(displayName)
    local D = _G.Details
    if not (D and D.custom) then return end
    for i, obj in ipairs(D.custom) do
        if obj.name == displayName then return i end
    end
end

local function MergedDisplayID() return CustomDisplayID("Damage Done + Support") end

-- is this window showing plain (non-redistributed) numbers?
local function WindowSupportOff(inst)
    local id = inst and inst.meu_id
    return not (id and db.redistWin[id])
end

UpdateWindowButtons = function()
    local D = _G.Details
    if not (D and D.tabela_instancias) then return end
    for _, instance in ipairs(D.tabela_instancias) do
        local header = instance.baseframe and instance.baseframe.cabecalho
        local b = header and header._smButton
        if b then
            if WindowSupportOff(instance) then
                b.tex:SetDesaturated(true)
                b.tex:SetAlpha(0.45)
            else
                b.tex:SetDesaturated(false)
                b.tex:SetAlpha(1)
            end
        end
    end
end

-- header members can be framework wrapper tables; dig out the real frame
local function RealFrame(x)
    if type(x) ~= "table" then return nil end
    -- framework wrappers proxy SetPoint via metatable, so check for the
    -- embedded real widget FIRST
    if type(x.widget) == "table" and x.widget.GetObjectType then return x.widget end
    if type(x.button) == "table" and x.button.GetObjectType then return x.button end
    if x.GetObjectType and x.SetPoint then return x end
end

AttachWindowButtons = function()
    local D = _G.Details
    if not (D and D.tabela_instancias) then return end
    for _, instance in ipairs(D.tabela_instancias) do
        local base = instance.baseframe
        local header = base and base.cabecalho
        local anchor = header and not header._smButton
            and (RealFrame(header.modo_selecao) or RealFrame(header.segmento)
                 or RealFrame(header.atributo) or RealFrame(header.fechar))
        if anchor then
            local b = CreateFrame("Button", nil, base)
            b:SetSize(14, 14)
            b:SetPoint("RIGHT", anchor, "LEFT", -3, 0)
            b:SetFrameLevel(anchor:GetFrameLevel() + 1)
            local tex = b:CreateTexture(nil, "OVERLAY")
            tex:SetAllPoints()
            tex:SetTexture("Interface\\Icons\\Spell_Nature_Cyclone")
            tex:SetTexCoord(0.08, 0.92, 0.08, 0.92)
            b.tex = tex
            b.instance = instance
            b:RegisterForClicks("LeftButtonUp", "RightButtonUp")
            b:SetScript("OnClick", function(self, mouse)
                if mouse == "RightButton" then
                    CreateOptions()
                    opt:Show()
                    RefreshOptions()
                else
                    -- per-window toggle: redistributed <-> plain, right in
                    -- the native display (no display switching, ever)
                    local inst = self.instance
                    local id = inst and inst.meu_id
                    if not id then return end
                    if db.redistWin[id] then
                        db.redistWin[id] = nil
                    else
                        db.redistWin[id] = true
                    end
                    local D2 = _G.Details
                    if D2 and D2.RefreshMainWindow then D2:RefreshMainWindow(-1, true) end
                    UpdateWindowButtons()
                end
                if GameTooltip:IsOwned(self) then
                    self:GetScript("OnEnter")(self)
                end
            end)
            b:SetScript("OnEnter", function(self)
                GameTooltip:SetOwner(self, "ANCHOR_BOTTOMLEFT")
                GameTooltip:AddLine("Support Meter")
                local off = WindowSupportOff(self.instance)
                GameTooltip:AddLine("This window: " .. (off and "|cffffffffNormal|r" or "|cff00ff00Redistributed|r"), 1, 0.82, 0)
                GameTooltip:AddLine("Click: toggle this window   Right-click: options", 0.8, 0.8, 0.8)
                GameTooltip:Show()
            end)
            b:SetScript("OnLeave", function() GameTooltip:Hide() end)
            header._smButton = b
        end
    end
    UpdateWindowButtons()
end

-- windows can be opened after login; cheap periodic re-attach
local attachTick = CreateFrame("Frame")
local attachAcc = 0
attachTick:SetScript("OnUpdate", function(self, e)
    attachAcc = attachAcc + e
    if attachAcc < 10 then return end
    attachAcc = 0
    if db then AttachWindowButtons() end
end)

---------------------------------------------------------------------------
-- slash
---------------------------------------------------------------------------
SLASH_SUPPORTMETER1 = "/supportmeter"
SLASH_SUPPORTMETER2 = "/sm"
SlashCmdList["SUPPORTMETER"] = function(msg)
    msg = (msg or ""):trim()
    local cmd, rest = msg:match("^(%S+)%s*(.*)$")
    cmd = (cmd or ""):lower()

    if cmd == "" then
        CreateGUI()
        if gui:IsShown() then gui:Hide() else gui:Show() RefreshGUI() end
    elseif cmd == "options" or cmd == "opt" or cmd == "config" then
        CreateOptions()
        if opt:IsShown() then opt:Hide() else opt:Show() end
    elseif cmd == "missing" then
        CreateDebugWindow()
        dbgWin.mode = "missing"
        dbgWin:Show()
        RefreshDebug()
    elseif cmd == "snap" then
        SnapCommand(false)
    elseif cmd == "verify" then
        SnapCommand(true)
    elseif cmd == "spells" then
        CreateDebugWindow()
        dbgWin.mode = "spells"
        dbgWin:Show()
        RefreshDebug()
    elseif cmd == "debug" then
        CreateDebugWindow()
        if dbgWin:IsShown() then dbgWin:Hide() else dbgWin:Show() end
    elseif cmd == "inspect" then
        StartInspectSweep()
    elseif cmd == "value" then
        local v = tonumber(rest)
        if v then
            db.buffValue = v
            db.valueManual = true
            print(TAG .. "buff value locked to " .. v .. " (/sm value to unlock auto-read)")
        else
            db.valueManual = nil
            local auto = AutoReadBuffValue()
            if auto then db.buffValue = auto end
            print(TAG .. "buff value: " .. db.buffValue .. " (auto-read on)")
        end
        RefreshGUI()
    elseif cmd == "share" then
        local v = tonumber(rest)
        if v and v > 0 and v <= 1 then db.share = v end
        print(TAG .. "spell power share: " .. db.share)
        RefreshGUI()
    elseif cmd == "mshare" then
        local v = tonumber(rest)
        if v and v > 0 and v <= 1 then db.shareMelee = v end
        print(TAG .. "melee/physical share: " .. db.shareMelee)
        RefreshGUI()
    elseif cmd == "petratio" then
        local v = tonumber(rest)
        if v and v >= 0 and v <= 1 then db.petRatio = v end
        print(TAG .. ("pet inheritance ratio: %.2f (%s; measure: pet stat gain / your gear stat gain, /sm petratio 0 disables pet credit)")
            :format(db.petRatio, db.petRatio > 0 and "pet damage credited via owner" or "pet credit OFF"))
        RefreshGUI()
    elseif cmd == "buff" then
        if rest:lower() == "auto" then
            db.buffManual = nil
            local found = FindSupportBuffInSpellbook()
            if found then
                db.buffName = found
                wipe(buffed)
                local auto = AutoReadBuffValue()
                if auto and not db.valueManual then db.buffValue = auto end
            end
            print(TAG .. ("auto-detect: tracking %s (+%d)"):format(db.buffName, db.buffValue))
        elseif rest ~= "" then
            db.buffName = rest
            db.buffManual = true
            wipe(buffed)
            local auto = AutoReadBuffValue()
            if auto and not db.valueManual then db.buffValue = auto end
            print(TAG .. ("tracking buff: %s (+%d)"):format(db.buffName, db.buffValue))
        else
            print(TAG .. "tracking buff: " .. db.buffName .. "  (/sm buff Name, or /sm buff auto)")
        end
        RefreshGUI()
    elseif cmd == "auto" then
        local r = rest:lower()
        if r == "on" then db.autoInspect = true
        elseif r == "off" then db.autoInspect = false
        elseif tonumber(r) then db.autoInterval = math.max(30, tonumber(r)) end
        print(TAG .. ("auto gear re-scan: %s (every %ds, out of combat)")
            :format(db.autoInspect and "ON" or "OFF", db.autoInterval))
        RefreshGUI()
    elseif cmd == "merge" then
        -- flip Details window 1 between normal Damage Done and the
        -- Aug-style merged display (the retail-like on/off toggle)
        local D = _G.Details
        local instance = D and D.GetInstance and D:GetInstance(1)
        if not instance then
            print(TAG .. "no Details window found.")
            return
        end
        local id = MergedDisplayID()
        if not id then
            print(TAG .. "display not installed yet - /reload once with Details enabled.")
            return
        end
        if instance.atributo == 5 and instance.sub_atributo == id then
            D:TrocaTabela(instance, nil, 1, 1)
            print(TAG .. "window 1: normal |cffffd700Damage Done|r.")
        else
            D:TrocaTabela(instance, nil, 5, id)
            print(TAG .. "window 1: |cffffd700Damage Done + Support|r.")
        end
    elseif cmd == "mode" or cmd == "extra" or cmd == "extrabar" then
        local m = rest:lower():trim()
        if m == "off" or m == "extra" or m == "merge" then
            SetMode(m)
        else
            print(TAG .. "usage: /sm mode off|extra|merge  (current: " .. db.mode .. ")")
        end
    elseif cmd == "proc" then
        local delName = rest:match("^del%s+(.+)$")
        local name, stat, v = rest:match("^(.-)%s+(%a%a)%s+(%d+)$")
        if stat then stat = stat:lower() end
        if delName then
            db.procs[delName] = nil
            print(TAG .. "proc removed: " .. delName)
        elseif name and (stat == "sp" or stat == "ap") then
            db.procs[name] = { [stat] = tonumber(v) }
            print(TAG .. ("proc registered: %s = +%s %s while active"):format(name, v, stat:upper()))
        elseif rest == "" then
            local n = 0
            for pname, def in pairs(db.procs) do
                print(TAG .. ("proc: %s (+%d %s)"):format(pname, def.sp or def.ap, def.sp and "SP" or "AP"))
                n = n + 1
            end
            if n == 0 then print(TAG .. "no procs registered. /sm proc Buff Name sp|ap N") end
        else
            print(TAG .. "usage: /sm proc Buff Name sp|ap N  |  /sm proc del Buff Name  |  /sm proc")
        end
    elseif cmd == "coef" then
        local delName = rest:match("^del%s+(.+)$")
        local name, b, c = rest:match("^(.-)%s+(%d+)%s+([%d%.]+)$")
        if delName then
            db.abilityCoef[delName] = nil
            print(TAG .. "coefficient removed: " .. delName)
        elseif name and tonumber(b) and tonumber(c) then
            db.abilityCoef[name] = { b = tonumber(b), c = tonumber(c) }
            print(TAG .. ("coefficient: %s = base %s + %.0f%% of power (exact formula)"):format(name, b, tonumber(c) * 100))
        elseif rest == "" then
            local n = 0
            for aname, t in pairs(db.abilityCoef) do
                print(TAG .. ("coef: %s = base %d + %.0f%% power"):format(aname, t.b or 0, (t.c or 0) * 100))
                n = n + 1
            end
            if n == 0 then print(TAG .. "no coefficients set. /sm coef Spell Name 87 0.61") end
        else
            print(TAG .. "usage: /sm coef Spell Name <base> <coef>  e.g. /sm coef Windpelt 87 0.61")
        end
    elseif cmd == "ashare" then
        local delName = rest:match("^del%s+(.+)$")
        local name, v = rest:match("^(.-)%s+([%d%.]+)$")
        if delName then
            db.abilityShare[delName] = nil
            print(TAG .. "ability share removed: " .. delName)
        elseif name and tonumber(v) and tonumber(v) > 0 and tonumber(v) <= 1 then
            db.abilityShare[name] = tonumber(v)
            print(TAG .. ("ability share: %s = %.2f"):format(name, tonumber(v)))
        elseif rest == "" then
            local n = 0
            for aname, s in pairs(db.abilityShare) do
                print(TAG .. ("ashare: %s = %.2f"):format(aname, s))
                n = n + 1
            end
            if n == 0 then print(TAG .. "no per-ability shares set. /sm ashare Spell Name 0.7") end
        else
            print(TAG .. "usage: /sm ashare Spell Name 0.7  |  /sm ashare del Spell Name  |  /sm ashare")
        end
    elseif cmd == "ignore" then
        if rest ~= "" then
            db.ignored[rest] = true
            print(TAG .. "ignoring (no scaling): " .. rest)
        else
            local n = 0
            for name in pairs(db.ignored) do
                print(TAG .. "ignored: " .. name)
                n = n + 1
            end
            if n == 0 then print(TAG .. "ignore list empty. /sm ignore Spell Name") end
        end
    elseif cmd == "unignore" then
        if db.ignored[rest] then
            db.ignored[rest] = nil
            print(TAG .. "removed from ignore list: " .. rest)
        else
            print(TAG .. "not on ignore list: " .. rest)
        end
    elseif cmd == "dur" then
        local v = tonumber(rest)
        if v and v >= 0 then
            db.buffDur = v
            print(TAG .. ("buff window watchdog: %s"):format(v > 0 and (v .. "s") or "OFF"))
        else
            print(TAG .. ("buff window watchdog: %ds (buff duration + 1; /sm dur N, 0 = off)"):format(db.buffDur))
        end
    elseif cmd == "base" then
        local stat, v = rest:match("^(%a%a)%s+(%d+)$")
        if stat then stat = stat:lower() end
        if (stat == "sp" or stat == "ap") and v then
            if stat == "sp" then db.baseSP = tonumber(v) else db.baseAP = tonumber(v) end
            print(TAG .. ("base %s bonus: +%s added to every gear-scanned pool"):format(stat:upper(), v))
            RefreshOptions()
        else
            print(TAG .. ("base bonuses: SP +%d, AP +%d  (usage: /sm base sp|ap N)"):format(db.baseSP, db.baseAP))
        end
    elseif cmd == "pool" then
        local name, stat, v = rest:match("^(%S+)%s+(%S+)%s+(%d+)$")
        if name and (stat == "sp" or stat == "ap") then
            db.pools[name] = db.pools[name] or {}
            db.pools[name][stat] = tonumber(v)
            print(TAG .. ("pool for %s: %s = %s"):format(name, stat:upper(), v))
        else
            print(TAG .. "usage: /sm pool Name sp|ap N")
        end
    elseif cmd == "reset" then
        wipe(totals)
        wipe(fightTotals)
        sessionAttr = 0
        fightAttr = 0
        RefreshGUI()
        print(TAG .. "totals reset.")
    else
        print(TAG .. "windows: /sm, options, debug, missing, spells")
        print(TAG .. "model: mode off|extra|merge, snap (tooltip-measure missing), coef Name b c, ashare Name X, share X, mshare X, petratio X, base sp|ap N, dur N")
        print(TAG .. "data: inspect, pool Name sp|ap N, proc Buff sp|ap N, ignore/unignore Spell, buff Name, value N, auto on|off|secs, merge (window flip), reset")
    end
end