import { describe, expect, it } from "vitest";
import type { AbilityEffect } from "./abilityCatalog";
import { ROM_ALL_ABILITIES } from "./romAbilityCatalog";
import generated from "./romPlayerCatalog.generated.json";

function named(name: string) {
  const ability = ROM_ALL_ABILITIES.find((entry) => entry.name === name);
  if (!ability) throw new Error(`Missing RuneWaker ability: ${name}`);
  return ability;
}

function sourceSkill(sourceSkillId: number) {
  const ability = ROM_ALL_ABILITIES.find((entry) => entry.dbcSpellId === sourceSkillId);
  if (!ability) throw new Error(`Missing RuneWaker source skill: ${sourceSkillId}`);
  return ability;
}

function isMeaningfulEffect(effect: AbilityEffect): boolean {
  if (effect.kind === "scripted" || effect.kind === "unsupported") return false;
  if (["damage", "heal", "dot", "hot", "shield"].includes(effect.kind)) {
    const output = effect as Extract<AbilityEffect, { kind: "damage" | "heal" | "dot" | "hot" | "shield" }>;
    return (
      output.coefficient > 0
      || (output.coefficientPerLevel ?? 0) > 0
      || (output.kind === "damage" && (output.weaponDpsCoefficient ?? 0) > 0)
      || (output.basePoints ?? 0) > 0
      || (output.pointsPerLevel ?? 0) > 0
      || (output.kind === "heal" && (output.percentMaxHealth ?? 0) > 0)
    );
  }
  if (effect.kind === "apply-aura") {
    return Boolean(
      effect.control
      || effect.aura.modifiers?.length
      || effect.aura.absorbs?.length
      || effect.aura.procs?.length
      || effect.aura.utilityTags?.length
      || effect.aura.controlImmunities?.length
      || effect.aura.reflectSpellChance
      || effect.aura.redirectDamagePercent,
    );
  }
  return true;
}

describe("executable RuneWaker ability mappings", () => {
  it("shows readable Priest / Knight spell descriptions without client string tokens", () => {
    const priest = ROM_ALL_ABILITIES.filter((ability) => ability.classId === "rom-priest"
      && (!ability.secondaryClassId || ability.secondaryClassId === "rom-knight"));
    for (const ability of priest) {
      for (const description of [ability.description, ...(ability.ranks ?? []).map((rank) => rank.description)]) {
        expect(description, ability.name).not.toMatch(/\([^)]*(?:Buff\d*|DMG\d*)[^)]*\)|\[SC_SKILLTIPS_[^\]]+\]|\[\d{6}\]/i);
      }
    }
  });
  it("maps Taunt, Shout, and Cleanse to their real combat mechanics", () => {
    expect(named("Taunt").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "taunt" }),
    ]));
    expect(named("Shout").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "apply-aura", control: { kind: "stun" } }),
    ]));
    expect(named("Shout")).toMatchObject({
      target: "self",
      radius: 10,
      targeting: { shape: "circle", radius: 10 },
      cooldownMs: 40_000,
      cost: { resource: "rage", amount: 15 },
    });
    expect(named("Cleanse").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "dispel", mode: "cleanse", relationship: "friendly" }),
    ]));
  });

  it("keeps Priest and Priest/Scout support casts on friendly targets", () => {
    for (const name of ["Grace of Life", "Amplified Attack"]) {
      const ability = named(name);
      expect(ability.target, name).toBe("friendly");
      expect(ability.effects).toEqual(expect.arrayContaining([
        expect.objectContaining({ kind: "apply-aura", recipient: "ability-target" }),
      ]));
    }
    const curingShot = named("Curing Shot");
    expect(curingShot.target).toBe("friendly");
    expect(curingShot.effects.map((effect) => effect.kind)).toEqual(expect.arrayContaining(["heal", "hot"]));
    expect(curingShot.effects.some((effect) => effect.kind === "dot")).toBe(false);
  });

  it("fans Priest-secondary class buffs out to the described party recipients", () => {
    for (const sourceId of [491335, 498649]) {
      const auras = sourceSkill(sourceId).effects.filter((effect) => effect.kind === "apply-aura");
      expect(auras.length, `source ${sourceId}`).toBeGreaterThan(0);
      expect(auras.every((effect) => effect.scope === "party"), `source ${sourceId}`).toBe(true);
    }

    const salvation = sourceSkill(498719).effects.filter((effect) => effect.kind === "apply-aura");
    expect(salvation.length).toBeGreaterThan(0);
    expect(salvation.every((effect) => effect.scope === "party" && effect.excludeCaster)).toBe(true);

    const advance = sourceSkill(498722).effects.filter((effect) => effect.kind === "apply-aura");
    const partyBuffs = advance.filter((effect) => effect.scope === "party");
    const casterPenalties = advance.filter((effect) => effect.scope !== "party");
    expect(partyBuffs.some((effect) => effect.aura.modifiers?.some((modifier) => (
      modifier.kind === "damage" && modifier.direction === "dealt" && modifier.value > 0
    )))).toBe(true);
    expect(casterPenalties.some((effect) => effect.aura.modifiers?.some((modifier) => (
      modifier.kind === "stat" && ["armor", "magical-defense"].includes(modifier.stat) && modifier.value < 0
    )))).toBe(true);
    expect(casterPenalties.every((effect) => effect.recipient === "caster")).toBe(true);
  });

  it("keeps Scout/Knight Healing Shot damage and lowest-max-health party heal separate", () => {
    const healingShot = ROM_ALL_ABILITIES.find((ability) => ability.id === "rom-scout-rom-knight-elite-20")!;
    expect(healingShot).toMatchObject({ target: "hostile" });
    expect(healingShot.effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "damage" }),
      expect.objectContaining({
        kind: "heal", scope: "party", maximumTargets: 1, selection: "lowest-max-health",
      }),
    ]));
  });

  it("requires Nature's Power for Druid/Scout Group Exorcism", () => {
    const exorcism = ROM_ALL_ABILITIES.find((ability) => ability.id === "rom-druid-rom-scout-elite-30")!;
    expect(exorcism).toMatchObject({ target: "self", targeting: { shape: "circle", radius: 5 } });
    expect(exorcism.costs).toEqual(expect.arrayContaining([
      expect.objectContaining({ resource: "nature-power", amount: 1 }),
    ]));
    expect(exorcism.effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "dispel", mode: "cleanse", relationship: "friendly" }),
    ]));
  });

  it("roots nearby enemies with Knight Shackles of Light", () => {
    const shackles = named("Shackles of Light");
    expect(shackles).toMatchObject({ target: "self", radius: 10 });
    expect(shackles.effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "apply-aura", control: { kind: "root" } }),
    ]));
  });

  it("maps Scout Cripple Joint to its 55% Joint Blow root proc", () => {
    const crippleJoint = sourceSkill(491173);
    expect(crippleJoint.passive).toBe(true);
    expect(crippleJoint.effects).toEqual([
      expect.objectContaining({
        kind: "apply-aura",
        recipient: "caster",
        aura: expect.objectContaining({
          utilityTags: ["rom-cripple-joint"],
          procs: [{
            id: "rom-cripple-joint-root",
            triggers: ["hit", "crit"],
            chance: 0.55,
            action: { kind: "custom", id: "rom-cripple-joint" },
          }],
        }),
      }),
    ]);
    expect(sourceSkill(490420)).toMatchObject({ name: "Joint Blow", dbcSpellId: 490420 });
  });

  it("uses Neck Strike's sourced six-second NPC stun instead of an unsupported ten seconds", () => {
    expect(sourceSkill(490438).effects).toEqual([{
      kind: "status",
      status: "stun",
      durationMs: 6_000,
      maxTargets: 1,
      breakOnDamage: true,
    }]);
  });

  it("gives Champion nearby and fan spells their source-shaped target areas", () => {
    const bySpellId = (spellId: number) => ROM_ALL_ABILITIES.find((ability) => ability.dbcSpellId === spellId)!;
    expect(bySpellId(498481)).toMatchObject({ target: "self", radius: 10 });
    expect(bySpellId(498537)).toMatchObject({ target: "self", radius: 7.5 });
    expect(bySpellId(498721)).toMatchObject({
      target: "self",
      radius: 10,
      targeting: { shape: "circle", radius: 10 },
    });
    expect(bySpellId(498534)).toMatchObject({
      target: "self",
      radius: 10,
      targeting: { shape: "cone", radius: 10, attackArcRadians: Math.PI / 2 },
    });
  });

  it("restores Rune Pulse Rage on the Champion after its hostile hit", () => {
    const runePulse = ROM_ALL_ABILITIES.find((ability) => ability.dbcSpellId === 498529)!;
    expect(runePulse.effects).toEqual(expect.arrayContaining([
      expect.objectContaining({
        kind: "apply-aura",
        recipient: "caster",
        aura: expect.objectContaining({ modifiers: expect.arrayContaining([
          expect.objectContaining({ kind: "resource", resource: "rage", property: "regeneration" }),
        ]) }),
      }),
    ]));
  });

  it("puts Scout/Mage Aggro Transfer mana regeneration on the selected ally", () => {
    const aggroTransfer = ROM_ALL_ABILITIES.find((ability) => ability.dbcSpellId === 493255)!;
    expect(aggroTransfer.target).toBe("friendly");
    expect(aggroTransfer.effects).toEqual(expect.arrayContaining([
      expect.objectContaining({
        kind: "apply-aura",
        recipient: "ability-target",
        aura: expect.objectContaining({ modifiers: expect.arrayContaining([
          expect.objectContaining({ kind: "resource", resource: "mana", property: "regeneration" }),
        ]) }),
      }),
    ]));
  });

  it("preserves Druid elite healing and chain targeting semantics", () => {
    const bySpellId = (spellId: number) => ROM_ALL_ABILITIES.find((ability) => ability.dbcSpellId === spellId)!;
    const arrows = bySpellId(494021);
    expect(arrows).toMatchObject({ target: "friendly", targeting: { shape: "circle", radius: 20, maximumTargets: 5 } });
    expect(arrows.effects.map((effect) => effect.kind)).toEqual(["hot", "hot"]);
    const arrowHots = arrows.effects.filter((effect): effect is Extract<typeof effect, { kind: "hot" }> => effect.kind === "hot");
    expect(arrowHots).toHaveLength(2);
    expect(arrowHots[0]!.basePoints).toBeCloseTo(23.6);
    expect(arrowHots[1]!.basePoints).toBeCloseTo(18.88);
    const earthChain = bySpellId(494025);
    expect(earthChain).toMatchObject({ targeting: { shape: "chain", maximumTargets: 3, jumpRange: 6 } });
    expect(earthChain.effects.filter((effect) => effect.kind === "damage")).toEqual([
      expect.objectContaining({ kind: "damage", falloffPerJump: 0.7 }),
      expect.objectContaining({ kind: "damage", falloffPerJump: 0.7 }),
    ]);
    const ripple = bySpellId(494323);
    expect(ripple).toMatchObject({ targeting: { shape: "circle", radius: 6, maximumTargets: 3 } });
    expect(ripple.effects.filter((effect) => effect.kind === "heal")).toEqual([
      expect.objectContaining({ falloffPerJump: 0.5 }),
      expect.objectContaining({ falloffPerJump: 0.5 }),
    ]);
    expect(bySpellId(493540).targeting?.shape).toBe("line");
    expect(bySpellId(494217)).toMatchObject({ target: "self", targeting: { shape: "circle", radius: 5 } });
    expect(bySpellId(494217).effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "dispel", relationship: "friendly", mode: "cleanse" }),
    ]));
    expect(bySpellId(494027)).toMatchObject({ target: "friendly", targeting: { shape: "circle", radius: 6, maximumTargets: 3 } });
    expect(bySpellId(494026).targeting).toMatchObject({ shape: "circle", radius: 12 });
  });

  it("models Champion Overrule as control immunity instead of applying control", () => {
    const overrule = ROM_ALL_ABILITIES.find((ability) => ability.dbcSpellId === 498570)!;
    expect(overrule.effects).toEqual(expect.arrayContaining([
      expect.objectContaining({
        kind: "apply-aura",
        recipient: "caster",
        aura: expect.objectContaining({
          durationMs: 3_000,
          controlImmunities: expect.arrayContaining(["stun", "root", "slow"]),
        }),
      }),
    ]));
    expect(overrule.effects.some((effect) => effect.kind === "apply-aura" && effect.control)).toBe(false);
  });

  it("models Free Will as a 10-second Root and Slow immunity for its friendly target", () => {
    const freeWill = ROM_ALL_ABILITIES.find((ability) => ability.dbcSpellId === 491351)!;
    expect(freeWill).toMatchObject({ target: "friendly" });
    expect(freeWill.effects).toEqual([expect.objectContaining({
      kind: "apply-aura",
      recipient: "ability-target",
      aura: expect.objectContaining({
        disposition: "buff",
        durationMs: 10_000,
        controlImmunities: ["root", "slow"],
      }),
    })]);
    expect(freeWill.effects.some((effect) => effect.kind === "apply-aura" && effect.control)).toBe(false);
  });

  it("applies Fire Ward to the Priest's party", () => {
    expect(named("Fire Ward").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "apply-aura", scope: "party" }),
    ]));
  });

  it("fans out Warden Crystalline Protection and Acceleration within their source radius", () => {
    const protection = ROM_ALL_ABILITIES.find((ability) => ability.dbcSpellId === 498201)!;
    const acceleration = ROM_ALL_ABILITIES.find((ability) => ability.dbcSpellId === 498202)!;
    for (const ability of [protection, acceleration]) {
      expect(ability).toMatchObject({
        target: "self",
        radius: 7.5,
        targeting: { shape: "circle", radius: 7.5 },
      });
      expect(ability.effects).toEqual(expect.arrayContaining([
        expect.objectContaining({ kind: "apply-aura", scope: "party" }),
      ]));
    }
    expect(protection.effects).toEqual(expect.arrayContaining([
      expect.objectContaining({
        kind: "apply-aura",
        scope: "party",
        aura: expect.objectContaining({ absorbs: expect.arrayContaining([expect.any(Object)]) }),
      }),
    ]));
    expect(acceleration.effects.flatMap((effect) => effect.kind === "apply-aura" ? effect.aura.modifiers ?? [] : []))
      .toEqual(expect.arrayContaining([
        expect.objectContaining({ kind: "stat", stat: "attack-speed" }),
        expect.objectContaining({ kind: "stat", stat: "spell-haste" }),
      ]));
  });

  it("applies Coat of Arms defenses to both the caster and selected ally", () => {
    const coatOfArms = ROM_ALL_ABILITIES.find((ability) => ability.dbcSpellId === 494611)!;
    expect(coatOfArms.target).toBe("friendly");
    expect(coatOfArms.effects).toHaveLength(2);
    expect(coatOfArms.effects).toEqual([
      expect.objectContaining({
        kind: "apply-aura",
        recipient: "caster",
        aura: expect.objectContaining({
          durationMs: 20_000,
          modifiers: expect.arrayContaining([
            expect.objectContaining({ kind: "stat", stat: "armor", operation: "percent", value: 0.3 }),
            expect.objectContaining({ kind: "stat", stat: "magical-defense", operation: "percent", value: 0.3 }),
          ]),
        }),
      }),
      expect.objectContaining({ kind: "apply-aura", recipient: "ability-target" }),
    ]);
  });

  it("retains every executable part of multi-effect abilities", () => {
    const kinds = named("Sneak Attack").effects.map((effect) => effect.kind);
    expect(kinds).toEqual(["damage", "apply-aura", "dot"]);
  });

  it("executes one projectile hit for Rogue Throw and Scout Shot", () => {
    for (const name of ["Throw", "Shot"]) {
      const ability = named(name);
      expect(ability.effects).toHaveLength(1);
      expect(ability.effects[0]).toMatchObject({ kind: "damage" });
      for (const version of ability.ranks ?? []) {
        expect(version.effects).toHaveLength(1);
        expect(version.effects[0]).toMatchObject({ kind: "damage" });
      }
    }
  });

  it("implements source-authored immunity and absorbs as named auras", () => {
    const holyAura = named("Holy Aura").effects.find((effect) => effect.kind === "apply-aura");
    expect(holyAura).toMatchObject({
      aura: {
        disposition: "buff",
        modifiers: [{ kind: "damage", direction: "taken", operation: "percent", value: -1 }],
      },
    });
    const electrostatic = named("Electrostatic Charge").effects.find((effect) => (
      effect.kind === "apply-aura" && (effect.aura.absorbs?.length ?? 0) > 0
    ));
    expect(electrostatic).toMatchObject({
      aura: { disposition: "buff", absorbs: [expect.objectContaining({ amount: 30 })] },
    });
  });

  it("never substitutes a generic mark or legacy shield for a RuneWaker mechanic", () => {
    const effects = ROM_ALL_ABILITIES.flatMap((ability) => ability.effects);
    expect(effects.some((effect) => effect.kind === "status" && effect.status === "marked")).toBe(false);
    expect(effects.some((effect) => effect.kind === "shield")).toBe(false);
    expect(generated.skills.some((ability) => ["shield", "status", "utility", "cleanse"].includes(ability.effect.kind))).toBe(false);
  });

  it("executes standard elite cleanses, movement, conversion, and triggered spells", () => {
    expect(named("Antidote").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "dispel", categories: ["poison"] }),
    ]));
    expect(named("Spirit Jump").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "pull", toward: "caster" }),
    ]));
    expect(named("Essence Extraction").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "resource-drain", resource: "mana", amount: 10, percentage: true }),
      expect.objectContaining({ kind: "resource", resource: "nature-power", amount: 4 }),
    ]));
    expect(named("Spreading Pain").effects.filter((effect) => effect.kind === "trigger-spell")).toHaveLength(3);
  });

  it("gives every active base skill and playable rank a concrete runtime effect", () => {
    const generatedSkillIds = new Set(generated.skills.map((skill) => skill.id));
    const runtimeOnly = ROM_ALL_ABILITIES.filter((ability) => !generatedSkillIds.has(ability.id));
    const generatedRankCount = generated.skills.reduce((count, skill) => count + skill.ranks.length, 0);
    // Snapshot accounting is source-backed: 932 generated rows carry 937
    // source ranks. Four explicit runtime additions have no separate ranks:
    // Devotion Halo, CoA Blocking Stance, CoA Probing Attack, and CoA Enraged.
    expect(generated.skills).toHaveLength(932);
    expect(generatedRankCount).toBe(937);
    expect(ROM_ALL_ABILITIES).toHaveLength(936);
    expect(runtimeOnly.map((ability) => ability.id).sort()).toEqual([
      "rom-priest-rom-knight-elite-70-devotion-halo",
      "rom-warlock-rom-warrior-general-coa-499871",
      "rom-warrior-rom-knight-elite-50-coa-493287",
      "rom-warrior-rom-rogue-elite-50-coa-493283",
    ]);
    expect(runtimeOnly.every((ability) => ability.ranks?.length === 0 || ability.ranks === undefined)).toBe(true);

    const versions = ROM_ALL_ABILITIES.flatMap((ability) => [
      { name: ability.name, rank: 0, passive: ability.passive, effects: ability.effects },
      ...(ability.ranks ?? []).map((rank) => ({
        name: ability.name,
        rank: rank.rank,
        passive: ability.passive,
        effects: rank.effects,
      })),
    ]);

    expect(versions).toHaveLength(1_873);
    const scriptOnly = ROM_ALL_ABILITIES
      .filter((ability) => !ability.passive && ability.effects.every((effect) => effect.kind === "scripted"))
      .map((ability) => ability.name)
      .sort();
    expect(scriptOnly).toEqual([]);
    for (const version of versions.filter((entry) => !entry.passive)) {
      expect(
        version.effects.some(isMeaningfulEffect),
        `${version.name} rank ${version.rank}`,
      ).toBe(true);
    }
  });

  it("implements source state for RuneWaker's active transformations", () => {
    expect(named("Frost Arrow").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({
        kind: "apply-aura",
        aura: expect.objectContaining({
          utilityTags: ["rom-frost-arrow"],
          procs: [expect.objectContaining({ action: { kind: "custom", id: "rom-frost-arrow" } })],
        }),
      }),
    ]));
    expect(named("Electric Compression").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "apply-aura", aura: expect.objectContaining({ utilityTags: ["rom-static-field-charge"] }) }),
    ]));
    expect(named("Entling Offering").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({
        kind: "apply-aura",
        aura: expect.objectContaining({
          utilityTags: ["rom-entling-offering"],
          procs: [expect.objectContaining({ action: { kind: "custom", id: "rom-entling-offering" } })],
        }),
      }),
    ]));
    expect(named("Holy Salvation Candle").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "apply-aura", aura: expect.objectContaining({ utilityTags: ["rom-holy-salvation-candle"] }) }),
    ]));
    expect(named("Remodeled Body").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "apply-aura", aura: expect.objectContaining({ utilityTags: ["rom-remodeled-body"] }) }),
    ]));
    expect(named("Revival").effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "utility", action: "class-script" }),
    ]));
  });

  it("marks Briar Shield as the source prerequisite for Thorn Arrow", () => {
    const briarShield = sourceSkill(493642);
    expect(briarShield.effects).toEqual(expect.arrayContaining([
      expect.objectContaining({
        kind: "apply-aura",
        aura: expect.objectContaining({
          durationMs: 900_000,
          modifiers: [{ kind: "stat", stat: "armor", operation: "percent", value: 0.05 }],
          utilityTags: expect.arrayContaining(["rom-briar-shield"]),
        }),
      }),
    ]));
    expect(briarShield.effects.filter((effect) => effect.kind === "damage")).toHaveLength(0);
    expect(sourceSkill(494037).effects).toEqual(expect.arrayContaining([
      expect.objectContaining({ kind: "damage" }),
    ]));
  });

  it("models the Knight's Holy Seal build-and-spend loop", () => {
    expect(named("Holy Strike").effects).toEqual(expect.arrayContaining([
      { kind: "combo", amount: 1 },
    ]));
    expect(named("Holy Seal").effects).toEqual(expect.arrayContaining([
      { kind: "combo", amount: 4 },
    ]));
    expect(named("Charge").effects).toEqual(expect.arrayContaining([
      { kind: "combo", amount: 2 },
    ]));
    expect(named("Punishment").effects).toEqual(expect.arrayContaining([
      { kind: "combo", amount: -5 },
    ]));
    expect(named("Holy Strike").effects.filter((effect) => effect.kind === "dot")).toHaveLength(1);
    expect(named("Holy Seal").effects.filter((effect) => effect.kind === "dot")).toHaveLength(1);
    expect(named("Punishment").effects.filter((effect) => effect.kind === "damage")).toHaveLength(1);
    expect(named("Punishment").effects.filter((effect) => effect.kind === "dot")).toHaveLength(0);
    expect(sourceSkill(499909).effects).toEqual(expect.arrayContaining([
      { kind: "combo", amount: -5 },
      expect.objectContaining({ kind: "damage" }),
    ]));
    expect(sourceSkill(499909).effects.filter((effect) => effect.kind === "dot")).toHaveLength(0);
  });
});