import { describe, expect, it } from "vitest";
import { deflectLandedCombatResult, resolveCombatResult } from "./combatResults";

function attack(overrides: Parameters<typeof resolveCombatResult>[0]["rules"] = {}, roll = 0.5) {
  return resolveCombatResult({ amount: 100, attackKind: "spell", damageSchool: "frost",
    attacker: { level: 80, criticalChancePercent: 100 },
    defender: { level: 80, resistances: { frost: 400 } },
    rules: { canMiss: false, resistanceMode: "partial", ...overrides }, roll: () => roll });
}

describe("guaranteed source deflection after the existing hit gate", () => {
  it("discards landed critical/partial-resist damage without reporting absorb, block or crit", () => {
    const landed = attack();
    expect(landed).toMatchObject({ landed: true, critical: true, partiallyResisted: true });
    const result = deflectLandedCombatResult(landed);
    expect(result).toMatchObject({ outcome: "deflect", deflected: true, landed: false,
      avoided: true, rawDamage: 100, finalDamage: 0, blocked: false, blockedAmount: 0,
      critical: false, resistedAmount: 0, fullyResisted: false, partiallyResisted: false });
  });
  it.each(["miss", "resist"] as const)("preserves an earlier %s and its original evidence", (outcome) => {
    const prior = outcome === "miss"
      ? attack({ canMiss: true, baseMissChancePercent: 100 })
      : attack({ resistanceMode: "binary" }, 0);
    expect(prior.outcome).toBe(outcome);
    expect(deflectLandedCombatResult(prior)).toBe(prior);
  });
  it("removes block-roll evidence from the discarded ranged spell packet", () => {
    const blocked = resolveCombatResult({ amount: 100, attackKind: "ranged", damageSchool: "physical",
      attacker: { level: 80 }, defender: { level: 80, blockPercent: 100, blockValue: 20,
        criticalBlockChancePercent: 100 },
      rules: { canMiss: false, canCrit: false, blockMode: "post-hit" }, roll: () => 0.5 });
    expect(blocked).toMatchObject({ landed: true, blocked: true, criticalBlocked: true });
    const deflected = deflectLandedCombatResult(blocked);
    expect(deflected).toMatchObject({ outcome: "deflect", blocked: false, finalDamage: 0 });
    expect(deflected.postHitBlockRoll).toBeUndefined();
    expect(deflected.criticalBlockRoll).toBeUndefined();
  });
});