Tracker.lua

--[[--------------------------------------------------------------------
	WhoDidIt - tracker: turns Nampower / SuperWoW / threat events into a
	live fight record (W.Tracker.fight). The Analyzer reads it.
----------------------------------------------------------------------]]

local W = WhoDidIt
local T = {}
W.Tracker = T

local floor = math.floor
local getn = table.getn

local RECAP_SIZE    = 30    -- events remembered per player
local RECAP_WINDOW  = 15    -- seconds of history kept for a death recap
local AGGRO_CONFIRM = 2.0   -- boss must hold a (non-melee) target this long
local TIMELINE_CAP  = 400

local HIT_CRIT     = 128     -- 0x80
local HIT_CRUSHING = 32768   -- 0x8000

local ENV = {
	[0] = "Fatigue", [1] = "Drowning", [2] = "Falling", [3] = "Lava",
	[4] = "Slime", [5] = "Burning ground", [6] = "Fell off the edge",
}

local F              -- the live fight, same table as T.fight
local isBoss = {}    -- guid -> bool
-- bosses seen dying (a respawn has a new GUID): their damage over time keeps ticking after
-- death (Golemagg's Magma Splash, MC 15 Oct 2026) and must not start a fight. Forgotten past 500.
local slain, nSlain = {}, 0
local function noteSlain(guid)
	if slain[guid] then return end
	nSlain = nSlain + 1
	if nSlain > 500 then slain, nSlain = {}, 1 end
	slain[guid] = true
end
local function deadBoss(guid)
	return slain[guid] or (W.env.superwow and UnitExists(guid) and UnitIsDead(guid)) and true or false
end

local function hasFlag(v, flag)
	if not v or not bit or not bit.band then return false end
	return bit.band(v, flag) ~= 0
end

------------------------------------------------------------------ helpers

function T:Line(kind, text, who)
	if not F or getn(F.timeline) >= TIMELINE_CAP then return nil end
	local l = { t = GetTime() - F.t0, k = kind, x = text, w = who }
	tinsert(F.timeline, l)
	return l
end

function T.IsBoss(guid)
	if not guid then return false end
	local c = isBoss[guid]
	if c ~= nil then return c end
	if W.roster.byGuid[guid] or W.roster.pets[guid] then
		isBoss[guid] = false
		return false
	end
	local name = UnitName(guid)
	if not name or name == "" or name == UNKNOWNOBJECT then return false end
	local b = false
	if UnitCanAttack("player", guid) then
		local cls = UnitClassification(guid)
		if W.Data.bosses[name] or cls == "worldboss" then
			b = true
		elseif WhoDidItDB.opts.trackTrash and (cls == "elite" or cls == "rareelite") then
			b = true
		end
	end
	isBoss[guid] = b
	return b
end

-- empty player / fight records (also used by the demo)
function T.NewPlayer(name, class)
	return {
		name = name, class = class or "WARRIOR",
		dmg = 0, bossDmg = 0, heal = 0, taken = 0,
		ds = {}, hs = {}, ts = {},
		-- per spell: hits, crits, biggest hit (damage dn/dc/dm, healing hn/hc/hm)
		dn = {}, dc = {}, dm = {}, hn = {}, hc = {}, hm = {},
		act = {}, nAct = 0,
		deadTotal = 0, aggroTime = 0, bossSwings = 0, crush = 0,
		consumes = {}, nCons = 0, kicks = 0, dispels = 0, tranqs = 0,
		cbuffs = {},  -- consumable buff name -> fight time first seen (0 = before the pull)
		-- two rings: damage taken, and everything else (heals, buffs, items), so a
		-- flood of heal ticks can't push the killing blows out of a death recap
		recap = {}, rhead = 0, drecap = {}, dhead = 0,
	}
end

function T.NewFight(t0, enc)
	return {
		t0 = t0, date = date("%Y-%m-%d %H:%M"), at = time(), zone = GetRealZoneText(),
		enc = enc,
		bosses = {}, nBoss = 0,
		players = {}, deaths = {}, timeline = {}, aggro = {},
		avoid = {}, carry = {}, stacks = {},
		interrupts = {}, casting = {}, lastKick = {},
		dispelTimes = {}, activeDebuffs = {}, mc = {}, debuffAt = {},
		frenzyOn = {}, frenzies = {}, bossDebuffs = {}, raidFails = {},
		threat = {}, threatPeak = {}, ffire = {}, taunts = {}, castLines = {},
		buffs = {},
		saves = {}, shields = {}, tauntCasts = {},
		env = {
			nampower = W.env.nampower, superwow = W.env.superwow,
			threat = W.env.twthreat or WhoDidItDB.opts.queryThreat,
		},
	}
end

function T:P(name)
	local p = F.players[name]
	if p then return p end
	local e = W.roster.byName[name]
	p = T.NewPlayer(name, e and e.class)
	F.players[name] = p
	return p
end

-- mark a player as "doing something" for every second in [t1, t2]
local function mark(p, t1, t2)
	local a = floor(t1 - F.t0)
	local b = floor((t2 or t1) - F.t0)
	if b > a + 10 then b = a + 10 end
	for s = a, b do
		if not p.act[s] then
			p.act[s] = true
			p.nAct = p.nAct + 1
		end
	end
end

-- death recap ring buffer
local DMG_KIND = { dmg = true, melee = true, env = true }
local function push(p, kind, src, spell, amt, crit, extra)
	local ring, h
	if DMG_KIND[kind] and p.drecap then
		ring = p.drecap
		h = p.dhead + 1
		if h > RECAP_SIZE then h = 1 end
		p.dhead = h
	else
		ring = p.recap
		h = p.rhead + 1
		if h > RECAP_SIZE then h = 1 end
		p.rhead = h
	end
	local r = ring[h]
	if not r then r = {}; ring[h] = r end
	r.t = GetTime(); r.k = kind; r.src = src; r.sp = spell; r.a = amt; r.c = crit; r.x = extra
	local e = W.roster.byName[p.name]
	if e then
		r.hp = UnitHealth(e.unit)
		r.hpm = UnitHealthMax(e.unit)
		if r.hpm and r.hpm > 0 then p.hpFrac = r.hp / r.hpm end
	else
		r.hp = nil; r.hpm = nil
	end
end

------------------------------------------------------------------ fight lifecycle

function T:AddBoss(guid)
	if F.bosses[guid] then return end
	local name = W.GuidName(guid)
	F.bosses[guid] = { name = name, dead = false }
	F.nBoss = F.nBoss + 1
	if not F.mainBoss then F.mainBoss = guid end
	local enc = W.Data.bosses[name]
	if enc and not F.encKnown then
		F.enc = enc
		F.encKnown = true
		F.encDef = W.Data.encounters[enc]
	end
	if F.started then T:Line("boss", name .. " joins the fight") end
end

function T:Start(guid, puller, how)
	F = T.NewFight(GetTime(), W.GuidName(guid))
	F.puller = puller
	F.pullHow = how
	T.fight = F
	T:AddBoss(guid)
	for name in pairs(W.roster.byName) do T:P(name) end
	F.started = true
	T:SnapshotBuffs()
	local bname = W.GuidName(guid)
	if puller then
		T:Line("pull", how == "aggro" and (bname .. " attacked " .. puller) or (puller .. " pulled " .. bname), puller)
	else
		T:Line("pull", bname .. " engaged")
	end
	if F.encKnown or UnitClassification(guid) == "worldboss" then
		W.Print("Tracking |cffffd100" .. F.enc .. "|r.")
	end
	if W.Logs then W.Logs:OnFightStart() end
	if W.UI then W.UI:OnFightStart() end
end

function T:Finish(result)
	if not F then return end
	local now = GetTime()
	F.tEnd = F.killedAt or F.idleSince or now
	for _, b in pairs(F.bosses) do T:Accrue(b, F.tEnd) end   -- (boss aggro time stops when the fight did)
	F.result = result
	T:Line(result == "KILL" and "kill" or "wipe", result == "KILL" and "Encounter won" or (result == "WIPE" and "Wipe" or "Fight reset"))
	local fight = F
	F = nil
	T.fight = nil
	isBoss = {}
	W.ResetCaches()
	local dur = fight.tEnd - fight.t0
	-- a "reset" where nobody hit a boss wasn't an attempt: a boss's adds still
	-- fighting after it died, a role-play, a stray pull. Not saved.
	local bossDmg = 0
	for _, p in pairs(fight.players) do bossDmg = bossDmg + (p.bossDmg or 0) end
	if (result ~= "KILL" and dur < (WhoDidItDB.opts.minDuration or 8)) or (result == "RESET" and bossDmg <= 0) then
		if W.UI then W.UI:OnFightEnd() end
		return
	end
	W:SaveFight(W.Analyzer:Build(fight, true))
end

function T:CheckKill()
	local def = F.encDef
	if def and def.final then
		for _, b in pairs(F.bosses) do
			if b.name == def.final and b.dead then F.killedAt = GetTime() end
		end
		return
	end
	local main = false
	for _, b in pairs(F.bosses) do
		if b.name == F.enc and b.dead then main = true end
	end
	for _, b in pairs(F.bosses) do
		-- the boss the encounter is named after is dead: what's left (images, adds
		-- that despawn instead of dying) doesn't keep the fight going
		if not b.dead and not main then return end
	end
	F.killedAt = GetTime()
end

function T:CheckEnd()
	local now = GetTime()
	if F.killedAt then
		if now - F.killedAt > 1.5 then T:Finish("KILL") end
		return
	end
	local anyCombat, dead, total = false, 0, 0
	for _, e in pairs(W.roster.byName) do
		total = total + 1
		if UnitIsDeadOrGhost(e.unit) then
			dead = dead + 1
		elseif UnitAffectingCombat(e.unit) then
			anyCombat = true
		end
	end
	if anyCombat then
		F.idleSince = nil
		return
	end
	F.idleSince = F.idleSince or now
	local def = F.encDef
	local wiped = total > 0 and dead / total >= 0.5
	-- some encounters drop combat between phases (Thaddius, C'Thun)
	local grace = (not wiped and def and def.idleGrace) or 3
	if now - F.idleSince < grace then return end
	if not wiped and W.env.superwow then
		local want = (def and def.final) or F.enc
		for g, b in pairs(F.bosses) do
			if b.name == want and not b.dead and UnitExists(g) and UnitIsDead(g) then
				b.dead = true
				noteSlain(g)
				T:CheckKill()
			end
		end
		if F.killedAt then T:Finish("KILL") return end
	end
	if wiped then
		T:Finish("WIPE")
	elseif def and def.noDeath then
		T:Finish("KILL")
	else
		T:Finish("RESET")
	end
end

function T:ManualStart()
	if F then W.Print("Already tracking " .. F.enc .. ".") return end
	local g = W.Guid("target")
	if not g or not UnitCanAttack("player", "target") then
		W.Print("Target a hostile unit first (needs SuperWoW).")
		return
	end
	isBoss[g] = true
	T:Start(g, UnitName("player"), "manual")
end

function T:ManualStop()
	if not F then W.Print("Not tracking anything.") return end
	F.idleSince = GetTime()
	T:Finish("RESET")
end

------------------------------------------------------------------ pull buff snapshot

function T:SnapshotBuffs()
	F.buffs = {}
	if not W.Cons then return end   -- new file: loads after a full restart
	for name, e in pairs(W.roster.byName) do
		local set = {}
		local p = T:P(name)
		local ids = W.Cons.Auras(e.unit, e.guid)
		for i = 1, getn(ids or {}) do
			set[W.SpellName(ids[i])] = true
			F.buffsOk = true
			local b = W.Cons.BuffName(ids[i])
			if b then p.cbuffs[b] = 0 end
		end
		F.buffs[name] = set
		-- unreadable (out of range) = unknown, never "missing" in the consume check
		p.read = ids and true or false
		p.wpn = W.Cons.Weapon(e.unit)
	end
end

-- a raid member gained a buff: remember consumables (protection potions etc.)
function T:RaidBuff(guid, spellId)
	if not W.Cons then return end
	local e = W.roster.byGuid[guid]
	if not e then return end
	local sp = W.Cons.BuffName(spellId)
	if not sp then return end
	local p = T:P(e.name)
	p.read = true   -- we saw them gain it, so they're readable
	if not p.cbuffs[sp] then
		p.cbuffs[sp] = GetTime() - F.t0
		push(p, "buff", nil, sp)
	end
end

------------------------------------------------------------------ damage / healing

function T:Damage(src, dst, spell, amt, crit, swing, hitInfo, absorb)
	if not src or not dst then return end
	local srcN, srcPet = W.Owner(src)
	local dstN, dstPet = W.Owner(dst)
	if not F then
		if srcN and not dstN and T.IsBoss(dst) and not deadBoss(dst) then
			T:Start(dst, srcN, "hit")
		elseif dstN and not srcN and not dstPet and T.IsBoss(src) and not deadBoss(src) then
			T:Start(src, dstN, "aggro")
		else
			return
		end
	end
	local now = GetTime()

	-- raid -> enemy
	if srcN and not dstN then
		if not F.bosses[dst] and T.IsBoss(dst) then T:AddBoss(dst) end
		local p = T:P(srcN)
		p.dmg = p.dmg + amt
		local key = srcPet and ("Pet: " .. spell) or spell
		p.ds[key] = (p.ds[key] or 0) + amt
		if amt > 0 then
			p.dn[key] = (p.dn[key] or 0) + 1
			if crit then p.dc[key] = (p.dc[key] or 0) + 1 end
			if amt > (p.dm[key] or 0) then p.dm[key] = amt end
		end
		if F.bosses[dst] then p.bossDmg = p.bossDmg + amt end
		if not srcPet then mark(p, now, swing and (now + 1.5) or now) end
		return
	end

	if not dstN or dstPet then return end
	local p = T:P(dstN)

	-- raid -> raid (mind control, friendly fire)
	if srcN then
		if amt <= 0 then return end
		p.taken = p.taken + amt
		local mc = F.mc[src]
		push(p, "dmg", mc and (srcN .. " (mind controlled)") or srcN, spell, amt, crit)
		if not mc and not F.mc[dst] and srcN ~= dstN then
			F.ffire[srcN] = (F.ffire[srcN] or 0) + amt
		end
		return
	end

	-- enemy -> raid
	if not F.bosses[src] and T.IsBoss(src) then T:AddBoss(src) end
	local crushing = swing and hasFlag(hitInfo, HIT_CRUSHING)
	if swing and F.bosses[src] then
		T:BossSwing(src, dst, p, now)
		if crushing then p.crush = p.crush + 1 end
	end
	if absorb and absorb > 0 then T:CheckShield(dst, p, absorb) end
	if amt <= 0 then return end
	p.taken = p.taken + amt
	p.ts[spell] = (p.ts[spell] or 0) + amt
	push(p, swing and "melee" or "dmg", W.GuidName(src), spell, amt, crit, crushing and "crushing" or nil)
	if not swing then
		T:CheckAvoid(p, spell, amt, now)
		T:CheckSplash(p, spell, amt, now)
	end
end

function T:Env(guid, typ, dmg)
	if not F then return end
	local e = W.roster.byGuid[guid]
	if not e then return end
	local p = T:P(e.name)
	local sp = ENV[tonumber(typ) or -1] or "Environment"
	dmg = tonumber(dmg) or 0
	p.taken = p.taken + dmg
	p.ts[sp] = (p.ts[sp] or 0) + dmg
	push(p, "env", "Environment", sp, dmg)
	T:CheckAvoid(p, sp, dmg, GetTime())
end

function T:Heal(targetGuid, casterGuid, spellId, amount, crit, periodic)
	if not F then return end
	amount = tonumber(amount) or 0
	local now = GetTime()
	local sp = W.SpellName(spellId)
	local cn, cpet = W.Owner(casterGuid)
	if cn then
		local p = T:P(cn)
		p.heal = p.heal + amount
		p.hs[sp] = (p.hs[sp] or 0) + amount
		if amount > 0 then
			p.hn[sp] = (p.hn[sp] or 0) + 1
			if tonumber(crit) == 1 then p.hc[sp] = (p.hc[sp] or 0) + 1 end
			if amount > (p.hm[sp] or 0) then p.hm[sp] = amount end
		end
		if not cpet and tonumber(periodic) ~= 1 then mark(p, now) end
	end
	local te = W.roster.byGuid[targetGuid]
	if te then
		local q = T:P(te.name)
		-- clutch heal: target was under 20% (last known health) and it was a real heal
		local pre = q.hpFrac
		local mx = UnitHealthMax(te.unit) or 0
		if cn and pre and pre < 0.2 and mx > 0 and amount >= mx * 0.1 and not UnitIsDeadOrGhost(te.unit) then
			T:Save("heal", cn, te.name, sp, amount, pre)
		end
		push(q, "heal", cn or W.GuidName(casterGuid), sp, amount, tonumber(crit) == 1)
	end
end

------------------------------------------------------------------ heroes

-- a possible game-saving moment; the Analyzer confirms it (e.g. they survived)
function T:Save(kind, who, target, sp, amt, pre)
	local now = GetTime() - F.t0
	if kind == "heal" then
		-- one clutch heal per target per 3s (the first one that landed)
		for i = getn(F.saves), 1, -1 do
			local s = F.saves[i]
			if now - s.t > 3 then break end
			if s.kind == "heal" and s.target == target then return end
		end
	end
	tinsert(F.saves, { t = now, kind = kind, who = who, target = target, sp = sp, amt = amt, pre = pre })
end

local function liveFrac(unit, mana)
	if mana then
		local mx = UnitManaMax(unit) or 0
		return mx > 0 and (UnitMana(unit) / mx) or nil
	end
	local mx = UnitHealthMax(unit) or 0
	return mx > 0 and (UnitHealth(unit) / mx) or nil
end

-- an absorb shield took a hit bigger than the health its target had left
function T:CheckShield(guid, p, absorb)
	local sh = F.shields[guid]
	if not sh or sh.saved or GetTime() - sh.t > 30 then return end
	local e = W.roster.byGuid[guid]
	if not e then return end
	local hp = UnitHealth(e.unit) or 0
	if hp > 0 and hp <= absorb then
		sh.saved = true
		T:Save(sh.by == p.name and "self" or "shield", sh.by, p.name, sh.sp, absorb, p.hpFrac)
	end
end

------------------------------------------------------------------ mechanics

function T:CheckAvoid(p, spell, amt, now)
	local rule = W.Data.avoid[spell]
	-- a listed name only counts in its own raid (trash elsewhere casts the same names)
	if rule and rule.zones and not F.demo and not rule.zones[GetRealZoneText() or ""] then rule = nil end
	if not rule and WhoDidItDB.avoid[spell] then rule = W.Data.customRule end
	if not rule then return end
	local a = F.avoid[p.name]
	if not a then a = {}; F.avoid[p.name] = a end
	local r = a[spell]
	if not r then
		r = { hits = 0, dmg = 0, inst = 0, last = -999, first = now - F.t0 }
		a[spell] = r
	end
	r.hits = r.hits + 1
	r.dmg = r.dmg + amt
	if now - r.last > 4 then
		r.inst = r.inst + 1
		if r.inst <= 3 then
			T:Line("avoid", p.name .. " hit by " .. spell .. " (" .. W.FmtNum(amt) .. ")", p.name)
		end
	end
	r.last = now
end

function T:CheckSplash(p, spell, amt, now)
	local srcs = W.Data.splashIdx[spell]
	if not srcs then return end
	for i = 1, getn(srcs) do
		local list = F.carry[srcs[i]]
		if list then
			for j = getn(list), 1, -1 do
				local c = list[j]
				if now - c.t <= c.win + 1 then
					if c.name ~= p.name then
						c.hits = c.hits + 1
						if not c.victims[p.name] then
							c.victims[p.name] = 0
							c.nv = c.nv + 1
						end
						c.victims[p.name] = c.victims[p.name] + amt
					end
					return
				end
			end
		end
	end
end

function T:Debuff(guid, spellId, stacks)
	if not F then return end
	local now = GetTime()
	local sp = W.SpellName(spellId)
	local D = W.Data
	stacks = tonumber(stacks)

	if F.bosses[guid] then
		if guid == F.mainBoss and D.raidDebuffs[sp] then
			local u = F.bossDebuffs[sp]
			if not u then u = { total = 0, max = 0 }; F.bossDebuffs[sp] = u end
			if not u.since then u.since = now end
			if stacks and stacks > u.max then u.max = stacks end
		end
		return
	end

	local e = W.roster.byGuid[guid]
	if not e or D.ignoreDebuffs[sp] then return end
	local p = T:P(e.name)
	local ad = F.activeDebuffs[guid]
	if not ad then ad = {}; F.activeDebuffs[guid] = ad end
	if not ad[sp] then
		ad[sp] = now
		F.debuffAt = F.debuffAt or {}   -- (kept after it's gone: the dispel event may come after the removal)
		F.debuffAt[guid .. sp] = now
		push(p, "debuff", nil, sp, stacks)
		if D.mc[sp] then
			F.mc[guid] = now
			T:Line("mc", e.name .. " is mind controlled (" .. sp .. ")", e.name)
		end
		local cr = D.carriers[sp]
		if cr then
			local list = F.carry[sp]
			if not list then list = {}; F.carry[sp] = list end
			tinsert(list, { name = e.name, t = now, win = cr.win or 10, hits = 0, victims = {}, nv = 0 })
			T:Line("debuff", e.name .. " has " .. sp, e.name)
		end
	end
	if stacks and D.stacks[sp] then
		local s = F.stacks[e.name]
		if not s then s = {}; F.stacks[e.name] = s end
		if stacks > (s[sp] or 0) then s[sp] = stacks end
	end
end

function T:DebuffRemoved(guid, spellId, state)
	if not F or tonumber(state) ~= 1 then return end
	local now = GetTime()
	local sp = W.SpellName(spellId)

	if F.bosses[guid] then
		local u = F.bossDebuffs[sp]
		if u and u.since and guid == F.mainBoss then
			u.total = u.total + (now - u.since)
			u.since = nil
		end
		return
	end

	local ad = F.activeDebuffs[guid]
	if not ad or not ad[sp] then return end
	local t0 = ad[sp]
	ad[sp] = nil
	if W.Data.mc[sp] then F.mc[guid] = nil end
	local e = W.roster.byGuid[guid]
	if W.Data.dispel[sp] and e and not UnitIsDeadOrGhost(e.unit) then
		local d = F.dispelTimes[sp]
		if not d then d = { n = 0, total = 0, max = 0 }; F.dispelTimes[sp] = d end
		local dt = now - t0
		d.n = d.n + 1
		d.total = d.total + dt
		if dt > d.max then d.max = dt; d.maxWho = e.name end
	end
end

function T:BossBuff(guid, spellId, added)
	if not F then return end
	local b = F.bosses[guid]
	if not b then return end
	local sp = W.SpellName(spellId)
	local now = GetTime()
	if W.Data.frenzy[sp] then
		if added then
			if not F.frenzyOn[guid] then
				F.frenzyOn[guid] = now
				T:Line("boss", b.name .. " gains " .. sp)
			end
		elseif F.frenzyOn[guid] then
			local st = F.frenzyOn[guid]
			F.frenzyOn[guid] = nil
			local lt = F.lastTranq
			local by = lt and (now - lt.t) < 2 and lt.name or nil
			tinsert(F.frenzies, { t = st - F.t0, dur = now - st, by = by, boss = b.name })
			T:Line("tranq", by and (by .. " tranquilized " .. b.name) or (sp .. " faded from " .. b.name), by)
		end
	elseif added and W.Data.berserk[sp] then
		local mx = UnitHealthMax(guid) or 0
		local pct = mx > 0 and ((UnitHealth(guid) or 0) / mx) or 1
		if pct > 0.25 then
			if not F.enraged then
				F.enraged = now - F.t0
				F.enrageBoss = b.name
			end
			T:Line("enrage", b.name .. " goes " .. sp .. " at " .. floor(pct * 100) .. "% health")
		else
			T:Line("boss", b.name .. " goes " .. sp .. " (low health)")
		end
	end
end

------------------------------------------------------------------ deaths

-- when each raider last used a potion, a healthstone or a class defensive.
-- Kept for the whole session (not just the fight), so a potion drunk just
-- before the pull still counts as on cooldown when they die.
T.cdLog = {}

function T:NoteUse(name, item)
	local log = T.cdLog[name]
	if not log then log = {}; T.cdLog[name] = log end
	if string.find(item, "Healthstone", 1, true) then
		log.healthstone = { GetTime(), item }
	elseif string.find(item, "Potion", 1, true) or item == "Restore Mana" or item == "Healing Potion" then
		log.potion = { GetTime(), item }   -- every potion shares one 2 minute cooldown
	end
end

local function warlockInRaid()
	for _, e in pairs(W.roster.byName) do
		if e.class == "WARLOCK" then return true end
	end
end

-- at a death: what was off cooldown ({ { label, kind, note }, ... }) and what
-- wasn't ({ { label, seconds left, what they used }, ... }). log: optional
-- (the demo passes its own)
function T:Readiness(name, class, now, log)
	log = log or T.cdLog[name] or {}
	local ready, cooling = {}, {}
	local function check(key, label, cd, kind, note)
		local u = log[key]
		local t = (type(u) == "table") and u[1] or u
		if t and now - t < cd then
			tinsert(cooling, { label, floor(cd - (now - t)), (type(u) == "table") and u[2] or nil })
		else
			tinsert(ready, { label, kind, note })
		end
	end
	check("potion", "Healing / protection potion", 120, "potion")
	if log.healthstone or log.warlock or warlockInRaid() then check("healthstone", "Healthstone", 120, "healthstone") end
	local defs = W.Data.defensives[class or ""] or {}
	for i = 1, getn(defs) do check(defs[i][1], defs[i][1], defs[i][2], "spell", defs[i][3] and "if they took the talent" or nil) end
	return ready, cooling
end

function T:Died(guid)
	if not F then return end
	local b = F.bosses[guid]
	if b then
		noteSlain(guid)
		if not b.dead then
			b.dead = true
			b.diedAt = GetTime() - F.t0
			T:Line("kill", b.name .. " dies")
			T:CheckKill()
		end
		return
	end
	local e = W.roster.byGuid[guid]
	if e then T:Death(e, guid) end
end

function T:Death(e, guid)
	local p = T:P(e.name)
	if p.deadAt then return end
	local now = GetTime()
	p.deadAt = now
	local d = {
		name = e.name, class = e.class, t = now - F.t0, at = now,
		lines = {}, debuffs = {}, verify = now + 1.5,
	}
	-- both rings (damage taken, everything else), newest back to the window, in time order
	local function read(ring, h)
		if not ring then return end
		for i = 0, RECAP_SIZE - 1 do
			local idx = h - i
			if idx < 1 then idx = idx + RECAP_SIZE end
			local r = ring[idx]
			if not r or not r.t or now - r.t > RECAP_WINDOW or r.t < F.t0 or r.t <= (p.lastDeathAt or 0) then break end
			tinsert(d.lines, {
				t = r.t - F.t0, k = r.k, s = r.src, sp = r.sp, a = r.a, c = r.c,
				hp = r.hp, hm = r.hpm, x = r.x,
			})
		end
	end
	read(p.recap, p.rhead)
	read(p.drecap, p.dhead or 0)
	table.sort(d.lines, function(a, b) return a.t < b.t end)
	p.lastDeathAt = now
	local ad = guid and F.activeDebuffs[guid]
	if ad then
		for sp in pairs(ad) do tinsert(d.debuffs, sp) end
	end
	d.cons = p.nCons
	-- freeze what was off cooldown at this moment: what could have saved them
	d.ready, d.cooling = T:Readiness(e.name, e.class, now)
	for _, b in pairs(F.bosses) do
		if guid and b.holder == guid then d.hadAggro = b.name end
	end
	tinsert(F.deaths, d)
	d.line = T:Line("death", e.name .. " died", e.name)
end

-- feign death check + resurrections
function T:CheckLiving()
	local now = GetTime()
	for i = 1, getn(F.deaths) do
		local d = F.deaths[i]
		if d.verify and now >= d.verify then
			d.verify = nil
			local e = W.roster.byName[d.name]
			if e and UnitHealth(e.unit) > 0 and not UnitIsGhost(e.unit) then
				d.fd = true
				local p = F.players[d.name]
				if p then p.deadAt = nil end
				if d.line then d.line.k = "info"; d.line.x = d.name .. " feigned death" end
			end
		end
	end
	for name, p in pairs(F.players) do
		if p.deadAt and now - p.deadAt > 3 then
			local e = W.roster.byName[name]
			if e and not UnitIsDeadOrGhost(e.unit) and UnitHealth(e.unit) > 0 then
				p.deadTotal = p.deadTotal + (now - p.deadAt)
				p.deadAt = nil
				T:Line("info", name .. " is back up", name)
			end
		end
	end
end

------------------------------------------------------------------ aggro

function T:Accrue(b, now)
	if b.holder and b.lastAcc then
		local e = W.roster.byGuid[b.holder]
		if e then
			local p = F.players[e.name]
			if p and now > b.lastAcc then p.aggroTime = p.aggroTime + (now - b.lastAcc) end
		end
	end
	b.lastAcc = now
end

function T:AggroChange(bguid, b, g, now, how)
	T:Accrue(b, now)
	local old = b.holder
	b.holder = g
	b.cand = g
	b.candSince = now
	local e = W.roster.byGuid[g]
	if not e then return end
	local oe = old and W.roster.byGuid[old]
	local th = F.threat[e.name]
	local perc = th and (now - th.t) < 5 and th.perc or nil
	local op = oe and F.players[oe.name]
	local oldDead = op and op.deadAt and (now - op.deadAt) < 8
	tinsert(F.aggro, {
		t = now - F.t0, boss = b.name, to = e.name, class = e.class,
		from = oe and oe.name, perc = perc, how = how, oldDead = oldDead and true or nil,
	})
	if not F.firstHolder then F.firstHolder = e.name end
	T:Line("aggro", b.name .. " -> " .. e.name .. (perc and (" (" .. perc .. "% threat)") or ""), e.name)
end

function T:BossSwing(bguid, vguid, p, now)
	local b = F.bosses[bguid]
	p.bossSwings = p.bossSwings + 1
	if b.holder ~= vguid then T:AggroChange(bguid, b, vguid, now, "melee") end
end

function T:PollTargets()
	local now = GetTime()
	for guid, b in pairs(F.bosses) do
		if not b.dead then
			T:Accrue(b, now)
			local tg = W.Guid(guid .. "target")
			if tg ~= b.cand then
				b.cand = tg
				b.candSince = now
			end
			if b.cand and b.cand ~= b.holder and now - b.candSince >= AGGRO_CONFIRM
				and (not b.castUntil or now > b.castUntil) then
				T:AggroChange(guid, b, b.cand, now, "target")
			end
		end
	end
end

------------------------------------------------------------------ casts (SuperWoW)

function T:CastEvent(caster, target, evt, spellId, dur)
	if evt == "CAST" then
		local sp = W.SpellName(spellId)
		if W.Data.defensiveSpell[sp] then
			local who, pet = W.Owner(caster)
			if who and not pet then
				T.cdLog[who] = T.cdLog[who] or {}
				T.cdLog[who][sp] = GetTime()
			end
		end
	end
	if not F then return end
	local now = GetTime()
	local n, isPet = W.Owner(caster)
	dur = (tonumber(dur) or 0) / 1000

	if n then
		local p = T:P(n)
		if not isPet then
			if evt == "START" or evt == "CHANNEL" then
				mark(p, now, now + dur)
			elseif evt == "CAST" then
				mark(p, now, now + 1)
			elseif evt == "MAINHAND" or evt == "OFFHAND" then
				mark(p, now, now + 1.5)
			end
		end
		if evt == "CAST" then
			local D = W.Data
			local sp = W.SpellName(spellId)
			if D.kickSpells[sp] then
				p.kicks = p.kicks + 1
				if target then F.lastKick[target] = { name = n, t = now } end
			elseif sp == "Tranquilizing Shot" then
				p.tranqs = p.tranqs + 1
				F.lastTranq = { name = n, t = now }
			end
			local te = target and W.roster.byGuid[target]
			if D.absorbSpells[sp] then
				F.shields[te and target or caster] = { by = n, t = now, sp = sp }
			end
			if D.taunts[sp] then
				tinsert(F.tauntCasts, { t = now - F.t0, who = n })
			end
			local kind = D.saveCasts[sp]
			if kind and te and te.name ~= n then
				if kind == "rez" then
					if UnitIsDeadOrGhost(te.unit) then T:Save("rez", n, te.name, sp) end
				elseif kind == "mana" then
					local m = liveFrac(te.unit, true)
					if m and m < 0.3 then T:Save("innervate", n, te.name, sp, nil, m) end
				else
					local hp = liveFrac(te.unit)
					local hadAggro = false
					for _, b in pairs(F.bosses) do
						if b.holder == target then hadAggro = true end
					end
					if hp and (hp < 0.35 or (hadAggro and sp == "Blessing of Protection")) then
						T:Save("cooldown", n, te.name, sp, nil, hp)
					end
				end
			end
			if D.selfSaves[sp] and not isPet then
				local me = W.roster.byName[n]
				local hp = me and liveFrac(me.unit)
				if hp and hp < 0.3 then T:Save("self", n, n, sp, nil, hp) end
			end
		end
		return
	end

	if evt == "MAINHAND" or evt == "OFFHAND" then return end
	local sp = W.SpellName(spellId)
	local b = F.bosses[caster]
	if b then
		if evt == "START" or evt == "CHANNEL" then
			b.castUntil = now + dur + 0.5
		else
			b.castUntil = now + 0.5
		end
		if evt == "START" or (evt == "CAST" and not F.casting[caster]) then
			local last = F.castLines[sp]
			if not last or now - last > 5 then
				F.castLines[sp] = now
				T:Line("cast", b.name .. (evt == "START" and " begins casting " or " casts ") .. sp)
			end
		end
	end

	if W.Data.interrupts[sp] then
		local st = F.interrupts[sp]
		if not st then st = { casts = 0, kicked = 0, done = 0, by = {} }; F.interrupts[sp] = st end
		if evt == "START" then
			st.casts = st.casts + 1
			F.casting[caster] = { sp = sp, t = now }
		elseif evt == "FAIL" then
			local c = F.casting[caster]
			if c and c.sp == sp then
				st.kicked = st.kicked + 1
				local k = F.lastKick[caster]
				if k and now - k.t < 1.5 then st.by[k.name] = (st.by[k.name] or 0) + 1 end
				F.casting[caster] = nil
			end
		elseif evt == "CAST" then
			local c = F.casting[caster]
			if c and c.sp == sp then
				st.done = st.done + 1
				F.casting[caster] = nil
				T:Line("interrupt", sp .. " was not interrupted (" .. W.GuidName(caster) .. ")")
			end
		end
	elseif evt == "CAST" then
		F.casting[caster] = nil
	end

	if evt == "CAST" and W.Data.raidFail[sp] then
		F.raidFails[sp] = (F.raidFails[sp] or 0) + 1
		T:Line("fail", W.Data.raidFail[sp].tip)
	end
end

function T:SpellGo(itemId, spellId, casterGuid)
	itemId = tonumber(itemId)
	if not itemId or itemId == 0 then return end
	local e = W.roster.byGuid[casterGuid]
	if not e then return end
	-- prefer the item's name ("Major Mana Potion") over its spell ("Restore Mana")
	local sp = GetItemInfo(itemId) or W.SpellName(spellId)
	T:NoteUse(e.name, sp)   -- cooldowns are tracked between fights too
	if not F then return end
	local p = T:P(e.name)
	p.consumes[sp] = (p.consumes[sp] or 0) + 1
	p.nCons = p.nCons + 1
	-- last-second health potion / healthstone
	local D = W.Data
	for i = 1, getn(D.healthItems) do
		if string.find(sp, D.healthItems[i], 1, true) then
			local hp = liveFrac(e.unit)
			if hp and hp < 0.3 then T:Save("potion", e.name, e.name, sp, nil, hp) end
			break
		end
	end
	push(p, "item", e.name, sp, 0)
end

function T:SpellMiss(casterGuid, targetGuid, spellId, missInfo)
	if not F or not F.bosses[targetGuid] then return end
	local sp = W.SpellName(spellId)
	if not W.Data.taunts[sp] then return end
	local n = W.Owner(casterGuid)
	if not n then return end
	F.taunts[n] = (F.taunts[n] or 0) + 1
	T:Line("taunt", n .. "'s " .. sp .. " was resisted", n)
end

function T:Dispel(casterGuid, targetGuid, spellId)
	if not F then return end
	local n = W.Owner(casterGuid)
	if n then
		local p = T:P(n)
		p.dispels = p.dispels + 1
		-- freeing someone from mind control, or removing a dangerous debuff, is a save -
		-- worth more the faster it was (seconds since the debuff landed, as amt)
		local te = targetGuid and W.roster.byGuid[targetGuid]
		local sp = spellId and W.SpellName(spellId)
		if te and sp and (W.Data.mc[sp] or W.Data.dispel[sp]) then
			local ad = F.activeDebuffs[targetGuid]
			local t0 = (ad and ad[sp]) or (F.debuffAt and F.debuffAt[targetGuid .. sp])
			local dt = t0 and math.max(0, GetTime() - t0)
			T:Save(W.Data.mc[sp] and "freed" or "dispel", n, te.name, sp, dt)
		end
	end
end

------------------------------------------------------------------ threat (Turtle WoW server API, same packets TWThreat uses)

function T:ThreatPacket(msg)
	if not F or not msg then return end
	local s = string.find(msg, "TWTv4=", 1, true)
	if not s then return end
	local tg = W.Guid("target")
	if not tg or not F.bosses[tg] then return end
	local bname = F.bosses[tg].name
	local data = string.sub(msg, s + 6)
	local hash = string.find(data, "#", 1, true)
	if hash then data = string.sub(data, 1, hash - 1) end
	local now = GetTime()
	for entry in string.gfind(data, "[^;]+") do
		local _, _, name, tank, threat, perc = string.find(entry, "^([^:]+):([^:]*):([^:]*):([^:]*)")
		perc = tonumber(perc)
		if perc then perc = math.floor(perc + 0.5) end   -- 86.599998 -> 87
		if name and perc then
			F.threat[name] = { perc = perc, threat = tonumber(threat), t = now, tank = (tank == "1") }
			local pk = F.threatPeak[name]
			if tank ~= "1" and (not pk or perc > pk.perc) then
				F.threatPeak[name] = { perc = perc, t = now - F.t0, boss = bname }
			end
		end
	end
end

function T:QueryThreat()
	if not WhoDidItDB.opts.queryThreat or W.env.twthreat then return end
	local tg = W.Guid("target")
	if not tg or not F.bosses[tg] then return end
	local ch
	if GetNumRaidMembers() > 0 then ch = "RAID" elseif GetNumPartyMembers() > 0 then ch = "PARTY" end
	if ch then SendAddonMessage("TWT_UDTSv4", "limit=10", ch) end
end

------------------------------------------------------------------ mana

function T:SampleMana()
	local t = GetTime() - F.t0
	for name, e in pairs(W.roster.byName) do
		if UnitPowerType(e.unit) == 0 and not UnitIsDeadOrGhost(e.unit) then
			local mx = UnitManaMax(e.unit)
			if mx and mx > 0 then
				local p = T:P(name)
				local s = p.mana
				if not s then s = {}; p.mana = s end
				if getn(s) < 1200 then
					tinsert(s, t)
					tinsert(s, UnitMana(e.unit) / mx)
				end
			end
		end
	end
end

------------------------------------------------------------------ event wiring

local function num(v) return tonumber(v) or 0 end

-- Nampower
local function onSpellDamage(targetGuid, casterGuid, spellId, amount, mitigation, hitInfo)
	-- mitigation is "absorb,block,resist"
	local _, _, absorb = string.find(mitigation or "", "^(%d+)")
	T:Damage(casterGuid, targetGuid, W.SpellName(spellId), num(amount), num(hitInfo) == 2, false, nil, num(absorb))
end
local function onSwing(attackerGuid, targetGuid, totalDamage, hitInfo, victimState, subDamageCount, blocked, totalAbsorb)
	hitInfo = num(hitInfo)
	T:Damage(attackerGuid, targetGuid, "Melee", num(totalDamage), hasFlag(hitInfo, HIT_CRIT), true, hitInfo, num(totalAbsorb))
end
local function onHeal(targetGuid, casterGuid, spellId, amount, crit, periodic)
	T:Heal(targetGuid, casterGuid, spellId, amount, crit, periodic)
end
local function onEnv(guid, typ, dmg) T:Env(guid, typ, dmg) end
local function onDebuffAdd(guid, luaSlot, spellId, stacks) T:Debuff(guid, spellId, stacks) end
local function onDebuffRem(guid, luaSlot, spellId, stacks, auraLevel, auraSlot, state) T:DebuffRemoved(guid, spellId, state) end
local function onBuffAdd(guid, luaSlot, spellId, stacks, auraLevel, auraSlot, state)
	if not F or num(state) == 2 then return end
	if F.bosses[guid] then
		T:BossBuff(guid, spellId, true)
	else
		T:RaidBuff(guid, spellId)
	end
end
local function onBuffRem(guid, luaSlot, spellId, stacks, auraLevel, auraSlot, state)
	if num(state) == 1 then T:BossBuff(guid, spellId, false) end
end
local function onGo(itemId, spellId, casterGuid) T:SpellGo(itemId, spellId, casterGuid) end
local function onMiss(casterGuid, targetGuid, spellId, missInfo) T:SpellMiss(casterGuid, targetGuid, spellId, missInfo) end
local function onDispel(casterGuid, targetGuid, spellId) T:Dispel(casterGuid, targetGuid, spellId) end

W:On("SPELL_DAMAGE_EVENT_SELF", onSpellDamage)
W:On("SPELL_DAMAGE_EVENT_OTHER", onSpellDamage)
W:On("AUTO_ATTACK_SELF", onSwing)
W:On("AUTO_ATTACK_OTHER", onSwing)
W:On("SPELL_HEAL_BY_SELF", onHeal)
W:On("SPELL_HEAL_BY_OTHER", onHeal)
W:On("ENVIRONMENTAL_DMG_SELF", onEnv)
W:On("ENVIRONMENTAL_DMG_OTHER", onEnv)
W:On("DEBUFF_ADDED_SELF", onDebuffAdd)
W:On("DEBUFF_ADDED_OTHER", onDebuffAdd)
W:On("DEBUFF_REMOVED_SELF", onDebuffRem)
W:On("DEBUFF_REMOVED_OTHER", onDebuffRem)
W:On("BUFF_ADDED_SELF", onBuffAdd)
W:On("BUFF_ADDED_OTHER", onBuffAdd)
W:On("BUFF_REMOVED_OTHER", onBuffRem)
W:On("SPELL_GO_SELF", onGo)
W:On("SPELL_GO_OTHER", onGo)
W:On("SPELL_MISS_SELF", onMiss)
W:On("SPELL_MISS_OTHER", onMiss)
W:On("SPELL_DISPEL_BY_SELF", onDispel)
W:On("SPELL_DISPEL_BY_OTHER", onDispel)
W:On("UNIT_DIED", function(guid) T:Died(guid) end)

-- SuperWoW
W:On("UNIT_CASTEVENT", function(caster, target, evt, spellId, dur)
	T:CastEvent(caster, target, evt, spellId, dur)
end)

-- Turtle threat API
W:On("CHAT_MSG_ADDON", function(prefix, msg)
	if F then T:ThreatPacket(msg) end
end)

-- Fallbacks when Nampower isn't installed: plain combat log death messages
W:On("CHAT_MSG_COMBAT_FRIENDLY_DEATH", function(msg)
	if W.env.nampower or not F or not msg then return end
	local _, _, name = string.find(msg, "^(.+) dies%.$")
	if msg == UNITDIESSELF then name = UnitName("player") end
	local e = name and W.roster.byName[name]
	if e then T:Death(e, e.guid) end
end)

W:On("CHAT_MSG_COMBAT_HOSTILE_DEATH", function(msg)
	if W.env.nampower or not F or not msg then return end
	local _, _, name = string.find(msg, "^(.+) dies%.$")
	if not name then return end
	for g, b in pairs(F.bosses) do
		if b.name == name and not b.dead then T:Died(g) return end
	end
end)

-- Leaving the world mid-fight (a /reload, a disconnect, a loading screen) doesn't end
-- the fight: it's kept (saved, for a /reload) and carried on when we're back in the same
-- place within two minutes. Otherwise it ends then, as a reset, at the moment we left.
local RESUME = 120
W:On("PLAYER_LEAVING_WORLD", function()
	if not F or not WhoDidItDB then return end
	F.leftAt, F.leftEpoch = GetTime(), time()
	WhoDidItDB.liveFight = F
end)
W:On("PLAYER_ENTERING_WORLD", function()
	local db = WhoDidItDB
	if not db then return end
	local saved = db.liveFight
	db.liveFight = nil
	if not F and saved then
		F = saved
		T.fight = F
	end
	if not F or not F.leftAt then return end
	-- (the real clock: the game's timer starts again if the PC was restarted)
	local away = time() - (F.leftEpoch or 0)
	if away >= 0 and away < RESUME and F.zone == GetRealZoneText() then
		F.leftAt, F.leftEpoch = nil, nil
		F.idleSince = nil
		T:Line("info", "Back after " .. floor(away) .. "s away (reload / disconnect) - the fight carries on")
		if W.UI then W.UI:OnFightStart() end
		return
	end
	F.idleSince = F.leftAt
	F.leftAt, F.leftEpoch = nil, nil
	T:Finish("RESET")
end)

-- once (1.23.4): fights saved as RESET by mistake. One whose boss is seen dying in
-- its timeline (an encounter with images or adds that despawn) was a kill; one where
-- nobody hit a boss (adds after the boss died, a role-play) wasn't a fight.
W:On("PLAYER_ENTERING_WORLD", function()
	local db = WhoDidItDB
	if not db or db.resetFix then return end
	db.resetFix = 1
	local fixed, dropped = 0, 0
	for i = getn(db.fights or {}), 1, -1 do
		local rec = db.fights[i]
		if rec.result == "RESET" and not rec.demo then
			local bossDmg = 0
			for _, p in pairs(rec.players or {}) do bossDmg = bossDmg + (p.boss or 0) end
			local died = false
			for j = 1, getn(rec.timeline or {}) do
				local l = rec.timeline[j]
				if l.k == "kill" and l.x == (rec.enc .. " dies") then died = true end
			end
			if died then
				rec.result = "KILL"
				fixed = fixed + 1
			elseif bossDmg <= 0 then
				tremove(db.fights, i)
				dropped = dropped + 1
			end
		end
	end
	if fixed + dropped > 0 then
		W.Print("Tidied up your saved fights: " .. fixed .. " marked RESET were kills, " .. dropped .. " that weren't fights (nobody hit the boss) removed.")
	end
end)

------------------------------------------------------------------ timers

W:Every(0.2, function()
	if F then T:PollTargets() end
end)

W:Every(0.5, function()
	if F then
		T:CheckLiving()
		T:CheckEnd()
	elseif UnitAffectingCombat("player") and W.env.superwow then
		-- backup start trigger: your own target is a boss already in combat
		local g = W.Guid("target")
		if g and UnitAffectingCombat("target") and T.IsBoss(g) and not deadBoss(g) then T:Start(g, nil, "combat") end
	end
end)

W:Every(1, function()
	if F then T:QueryThreat() end
end)

W:Every(2, function()
	if F then T:SampleMana() end
end)