"""Nonlethal damage track (SRD "Nonlethal Damage", KB
rules/prpg-core-rulebook/nonlethal-damage.md): a separate running total never
deducted from hp, derived staggered/unconscious thresholds, the max-hp
overflow-to-lethal rule, undead/construct immunity, and healing that removes
an equal amount of nonlethal damage.

This file covers the TRACK; the damage SOURCES (unarmed strikes, the CRB
Minimum Damage floor) are locked in the "sources" section at the bottom,
which exercises the routing through resolve_attack.
"""

from __future__ import annotations

from pf1e_simulator.combat import Action, CombatantState, CombatEngine
from pf1e_simulator.dice import parse_dice
from pf1e_simulator.grid import Grid
from pf1e_simulator.map import MapSpec, TerrainType
from pf1e_simulator.models import (
    AbilityScores,
    ACProfile,
    AttackSpec,
    Combatant,
    DamageComponent,
    DamageReduction,
    Saves,
)
from pf1e_simulator.rng import ScriptedRng
from pf1e_simulator.spells import HealEffect


def _combatant(
    cid: str,
    *,
    hp: int = 6,
    attack_bonus: int = 2,
    weapon_name: str = "short sword",
    damage: str = "1d4",
    dr: DamageReduction | None = None,
    creature_type: str = "living",
) -> Combatant:
    attack = AttackSpec(
        id=f"{cid}-w",
        name=weapon_name,
        kind="melee",
        attack_bonus=attack_bonus,
        damage=[DamageComponent(formula=parse_dice(damage), types=["bludgeoning"])],
    )
    return Combatant(
        id=cid,
        name=cid,
        level=1,
        size="Medium",
        abilities=AbilityScores(
            str_score=10, dex_score=10, con_score=10,
            int_score=10, wis_score=10, cha_score=10,
        ),
        hp_max=hp,
        ac=ACProfile(total=13, touch=13, flat_footed=13),
        bab=attack_bonus,
        initiative_mod=0,
        speed_land_ft=30,
        saves=Saves(fort=0, ref=0, will=0),
        attacks=[attack],
        dr=dr,
        creature_type=creature_type,
    )


def _state(
    combatant: Combatant, side: str, pos: tuple[int, int], hp: int | None = None
) -> CombatantState:
    return CombatantState(
        combatant=combatant, side=side, pos=pos,
        hp=combatant.hp_max if hp is None else hp,
    )


def _grid() -> Grid:
    legend = {".": TerrainType(type="floor", move_cost=1)}
    spec = MapSpec(name="test", terrain=tuple(["." * 8] * 8), legend=legend)
    return Grid.from_spec(spec)


def _engine(
    states: list[CombatantState], rolls: list[int] | None = None
) -> CombatEngine:
    return CombatEngine(ScriptedRng(rolls or [20] * 200), _grid(), states)


# ── Track accumulation and separation from hp ────────────────────────────────

def test_take_nonlethal_accumulates_without_touching_hp() -> None:
    # SRD: "keep a running total ... Do not deduct the nonlethal damage
    # number from your current hit points."
    foe = _state(_combatant("foe", hp=10), "monsters", (0, 1))
    assert foe.take_nonlethal(4) == 0
    assert foe.nonlethal == 4
    assert foe.hp == 10
    foe.take_nonlethal(3)
    assert foe.nonlethal == 7
    assert foe.hp == 10


def test_nonlethal_below_hp_is_no_state() -> None:
    foe = _state(_combatant("foe", hp=10), "monsters", (0, 1))
    foe.take_nonlethal(9)
    assert not foe.nonlethal_staggered
    assert not foe.nonlethal_unconscious
    assert foe.active is True


# ── Derived thresholds: staggered at == hp, unconscious at > hp ──────────────

def test_staggered_when_nonlethal_equals_hp() -> None:
    # SRD: "when your nonlethal damage equals your current hit points,
    # you're staggered."
    foe = _state(_combatant("foe", hp=10), "monsters", (0, 1))
    foe.take_nonlethal(10)
    assert foe.nonlethal_staggered is True
    assert foe.nonlethal_unconscious is False
    assert foe.active is True  # staggered still acts (limited)


def test_unconscious_when_nonlethal_exceeds_hp() -> None:
    # SRD: "when it exceeds your current hit points, you fall unconscious.
    # While unconscious, you are helpless."
    foe = _state(_combatant("foe", hp=10), "monsters", (0, 1))
    foe.take_nonlethal(11)
    assert foe.nonlethal_unconscious is True
    assert foe.nonlethal_staggered is False  # subsumed by unconscious
    assert foe.active is False  # cannot act, threatens nothing, counts downed
    assert foe.hp == 10  # unconsciousness never costs hp


def test_engine_treats_nonlethal_unconscious_as_helpless_and_staggered_as_limited() -> (
    None
):
    # _is_helpless drives the Dex-0 / +4-melee package; _is_staggered_limited
    # drives the one-move-or-standard action filter.
    engine = _engine(
        [
            _state(_combatant("a"), "players", (0, 0)),
            _state(_combatant("b", hp=20), "monsters", (0, 1), hp=10),
        ]
    )
    staggered = engine._states[1]
    staggered.take_nonlethal(10)
    assert engine._is_staggered_limited(staggered) is True
    assert engine._is_helpless(staggered) is False
    staggered.take_nonlethal(1)
    # Unconscious is NOT staggered-limited: it is total inaction (active is
    # False, so the turn never reaches the action filter) plus helpless.
    assert engine._is_staggered_limited(staggered) is False
    assert staggered.active is False
    assert engine._is_helpless(staggered) is True


def test_staggered_from_nonlethal_downgrades_full_attack() -> None:
    # The derived staggered state feeds the existing action-economy filter:
    # a full attack collapses to a single standard attack.
    engine = _engine(
        [
            _state(_combatant("a"), "players", (0, 0)),
            _state(_combatant("b", hp=10), "monsters", (0, 1)),
        ]
    )
    b = engine._states[1]
    b.nonlethal = 10  # == hp -> staggered
    kept = engine._filter_turn_actions(
        b, (Action(kind="full_attack", target_id="a"),), []
    )
    assert [a.kind for a in kept] == ["attack"]


# ── Nonlethal never kills below the max-hp ceiling ───────────────────────────

def test_further_nonlethal_just_keeps_the_target_unconscious() -> None:
    # SRD: nonlethal below total-max-hp is never hp damage; a pummeled
    # unconscious creature simply accrues more nonlethal.
    foe = _state(_combatant("foe", hp=30), "monsters", (0, 1), hp=10)
    for _ in range(5):
        assert foe.take_nonlethal(4) == 0
    assert foe.nonlethal == 20  # far above hp...
    assert foe.hp == 10  # ...but no hp was ever lost
    assert foe.dead is False


def test_overflow_at_max_hp_converts_to_lethal() -> None:
    # SRD: "If a creature's nonlethal damage is equal to his total maximum
    # hit points (not his current hit points), all further nonlethal damage
    # is treated as lethal damage."
    foe = _state(_combatant("foe", hp=10), "monsters", (0, 1))
    assert foe.take_nonlethal(10) == 0  # reaches hp_max exactly: still nonlethal
    assert foe.nonlethal == 10
    assert foe.take_nonlethal(3) == 3  # at the ceiling: this instance is lethal
    assert foe.nonlethal == 10  # the track stops growing


def test_engine_apply_nonlethal_logs_thresholds_and_books_overflow() -> None:
    engine = _engine(
        [
            _state(_combatant("a"), "players", (0, 0)),
            _state(_combatant("b", hp=4), "monsters", (0, 1)),
        ]
    )
    b = engine._states[1]
    assert engine._apply_nonlethal(b, 5) == 0
    assert "b: unconscious (nonlethal 5 > hp 4)" in engine._transcript[-1]
    # b.nonlethal (5) >= hp_max (4): further nonlethal is lethal damage.
    assert engine._apply_nonlethal(b, 2) == 2
    assert b.hp == 2
    assert engine._stats["b"].damage_taken == 2  # only the lethal part is booked


# ── Undead / construct immunity ──────────────────────────────────────────────

def test_undead_are_not_subject_to_nonlethal() -> None:
    # SRD undead traits (KB undead-16-rp.md:15): "not subject to ... nonlethal
    # damage".
    lich = _state(
        _combatant("lich", hp=10, creature_type="undead"), "monsters", (0, 1)
    )
    assert lich.take_nonlethal(8) == 0
    assert lich.nonlethal == 0
    assert lich.hp == 10


def test_construct_is_not_subject_to_nonlethal() -> None:
    # SRD construct traits (KB construct-20-rp.md:16): "not subject to ...
    # nonlethal damage".
    robot = _state(
        _combatant("robot", hp=10, creature_type="construct"), "monsters", (0, 1)
    )
    assert robot.take_nonlethal(8) == 0
    assert robot.nonlethal == 0


# ── Healing restores consciousness ───────────────────────────────────────────

def test_healing_above_the_nonlethal_total_restores_consciousness() -> None:
    # Derived thresholds: raising hp back above the nonlethal total ends the
    # unconscious state with no bookkeeping ("You cease being staggered when
    # your current hit points once again exceed your nonlethal damage" - the
    # same pure function governs both thresholds).
    foe = _state(_combatant("foe", hp=10), "monsters", (0, 1), hp=4)
    foe.take_nonlethal(6)  # 6 > hp 4 -> unconscious
    assert foe.nonlethal_unconscious is True
    assert foe.active is False
    foe.hp = 7  # healed above the nonlethal total
    assert foe.nonlethal_unconscious is False
    assert foe.nonlethal_staggered is False
    assert foe.active is True


def test_spell_healing_removes_equal_nonlethal() -> None:
    # SRD: "When a spell or ability cures hit point damage, it also removes
    # an equal amount of nonlethal damage."
    engine = _engine(
        [
            _state(_combatant("a"), "players", (0, 0)),
            _state(_combatant("b", hp=10), "monsters", (0, 1), hp=3),
        ]
    )
    b = engine._states[1]
    b.nonlethal = 8  # unconscious (8 > 3)
    effect = HealEffect(formula=parse_dice("6"))
    out = engine._apply_heal_effect(
        effect, b, caster_level=1, empower=False, maximize=False, saved=False
    )
    assert out == "+6 HP"
    assert b.hp == 9
    assert b.nonlethal == 2  # 8 - 6 equal removal
    assert b.active is True


def test_channel_heal_removes_equal_nonlethal() -> None:
    engine = _engine(
        [
            _state(_combatant("a"), "players", (0, 0)),
            _state(_combatant("b", hp=10), "monsters", (0, 1), hp=2),
        ]
    )
    healer, b = engine._states[0], engine._states[1]
    b.nonlethal = 5  # unconscious (5 > 2)
    engine._channel_heal(healer, b, 4)
    assert b.hp == 6
    assert b.nonlethal == 1  # 5 - 4
    assert b.nonlethal_staggered is False
    assert b.active is True


# ── Observation snapshot exposure ────────────────────────────────────────────

def test_snapshot_exposes_nonlethal() -> None:
    engine = _engine(
        [
            _state(_combatant("a"), "players", (0, 0)),
            _state(_combatant("b", hp=10), "monsters", (0, 1)),
        ]
    )
    b = engine._states[1]
    b.nonlethal = 7
    snapshot = engine._combatant_snapshot(b)
    assert snapshot["nonlethal"] == 7
    assert snapshot["hp"] == 10