import { createHash } from "node:crypto";
import { readFile } from "node:fs/promises";
import { describe, expect, it } from "vitest";
import {
  createDungeonEncounterSnapshot,
  reduceDungeonEncounter,
  resetDungeonEncounterSnapshot,
  validateDungeonEncounterDefinition,
} from "./dungeonEncounterRuntime";
import type {
  DungeonEncounterDefinition,
  DungeonEncounterSnapshot,
} from "./dungeonEncounterTypes";
import { DUNGEON_REGISTRY } from "./dungeonRegistry";
import type { DungeonDefinition } from "./dungeonTypes";
import { validateDungeonWorldObject } from "./dungeonWorldObjects";
import {
  WOW_WRATH_ENCOUNTER_CONTENT_REVIEWS,
  withWowWrathEncounterContent,
} from "./wowWrathEncounterContentCatalog";

const TARGETS = [
  "halls-of-reflection",
  "the-oculus",
  "trial-of-the-champion",
] as const;

const START_OBJECT_BY_DUNGEON = Object.freeze({
  "halls-of-reflection": "halls-of-reflection:wave-start",
  "the-oculus": "the-oculus:expedition-start",
  "trial-of-the-champion": "trial-of-the-champion:announcer-start",
});

function adaptedDefinition(id: typeof TARGETS[number]): DungeonDefinition {
  const source = DUNGEON_REGISTRY[id];
  if (!source) throw new Error(`Missing generated dungeon ${id}`);
  return withWowWrathEncounterContent(source);
}

function adaptedEncounter(definition: DungeonDefinition): DungeonEncounterDefinition {
  const encounter = definition.encounters?.find((candidate) => candidate.id === `${definition.id}:wrath-instance`);
  if (!encounter) throw new Error(`Missing Wrath encounter for ${definition.id}`);
  return encounter;
}

function activeSpawnIds(
  definition: DungeonDefinition,
  snapshot: DungeonEncounterSnapshot,
): readonly string[] {
  const active = new Set(snapshot.activeSpawnGroupIds);
  return (definition.encounterSpawnGroups ?? [])
    .filter((group) => active.has(group.id))
    .flatMap((group) => group.spawns.map((spawn) => spawn.id));
}

function advanceOneStep(
  definition: DungeonDefinition,
  encounter: DungeonEncounterDefinition,
  snapshot: DungeonEncounterSnapshot,
  now: number,
): DungeonEncounterSnapshot {
  if (snapshot.phase === "ready") {
    return reduceDungeonEncounter(encounter, snapshot, {
      kind: "interact",
      objectId: START_OBJECT_BY_DUNGEON[definition.id as keyof typeof START_OBJECT_BY_DUNGEON],
      now,
    }).snapshot;
  }
  if (snapshot.phase === "escape-ready") {
    return reduceDungeonEncounter(encounter, snapshot, {
      kind: "interact",
      objectId: "halls-of-reflection:escape-start",
      now,
    }).snapshot;
  }
  const spawnIds = activeSpawnIds(definition, snapshot);
  if (spawnIds.length) {
    return reduceDungeonEncounter(encounter, snapshot, {
      kind: "tick",
      now,
      facts: { registeredEntityIds: spawnIds, deadEntityIds: spawnIds },
    }).snapshot;
  }
  return reduceDungeonEncounter(encounter, snapshot, {
    kind: "tick",
    now: Math.max(now, snapshot.phaseStartedAt + 1_000_000),
    facts: { registeredEntityIds: [], deadEntityIds: [] },
  }).snapshot;
}

function finishEncounter(
  definition: DungeonDefinition,
  encounter: DungeonEncounterDefinition,
  initial = createDungeonEncounterSnapshot(encounter),
): { readonly snapshot: DungeonEncounterSnapshot; readonly phases: readonly string[] } {
  let snapshot = initial;
  const phases = [snapshot.phase];
  let now = snapshot.phaseStartedAt + 1;
  for (let step = 0; step < 80 && snapshot.phase !== "complete"; step += 1) {
    const previous = snapshot;
    snapshot = advanceOneStep(definition, encounter, snapshot, now);
    now = Math.max(now + 1, snapshot.phaseStartedAt + 1);
    if (snapshot.phase !== phases.at(-1)) phases.push(snapshot.phase);
    if (snapshot === previous) {
      throw new Error(`${definition.id} soft locked in ${snapshot.phase}`);
    }
  }
  if (snapshot.phase !== "complete") throw new Error(`${definition.id} did not complete`);
  return { snapshot, phases };
}

function expectOrderedPhases(phases: readonly string[], expected: readonly string[]): void {
  let cursor = -1;
  for (const phase of expected) {
    cursor = phases.indexOf(phase, cursor + 1);
    expect(cursor, `missing ordered phase ${phase}`).toBeGreaterThanOrEqual(0);
  }
}

describe("source-reviewed Wrath instance adapters", () => {
  it("keeps immutable file hashes and source anchors beside every adapter", async () => {
    expect(WOW_WRATH_ENCOUNTER_CONTENT_REVIEWS.map((review) => review.dungeonId)).toEqual(TARGETS);
    for (const review of WOW_WRATH_ENCOUNTER_CONTENT_REVIEWS) {
      expect(review.fidelity).toBe("source-backed-adapted");
      expect(review.sourceFiles.length).toBeGreaterThanOrEqual(3);
      expect(review.adaptations.length).toBeGreaterThan(0);
      expect(review.remainingGaps.length).toBeGreaterThan(0);
      for (const source of review.sourceFiles) {
        expect(source.sha256).toMatch(/^[a-f0-9]{64}$/);
        expect(source.anchors.length).toBeGreaterThan(0);
        expect(createHash("sha256").update(await readFile(source.path)).digest("hex"), source.path)
          .toBe(source.sha256);
      }
    }
  });

  it("validates definitions, group references, safety timeouts, and reviewed blocker geometry", () => {
    for (const id of TARGETS) {
      const source = DUNGEON_REGISTRY[id];
      const definition = adaptedDefinition(id);
      const encounter = adaptedEncounter(definition);
      validateDungeonEncounterDefinition(encounter);
      definition.serverGameObjects.forEach(validateDungeonWorldObject);

      const groupIds = new Set((definition.encounterSpawnGroups ?? []).map((group) => group.id));
      const objectIds = new Set(definition.serverGameObjects.map((object) => object.id));
      for (const rule of encounter.rules) {
        if (rule.trigger.kind === "entities-dead") {
          expect(rule.trigger.timeoutMs, `${id}:${rule.id}`).toBeGreaterThan(0);
        }
        for (const action of rule.actions) {
          if (action.kind === "activate-spawn-group" || action.kind === "deactivate-spawn-group") {
            expect(groupIds.has(action.spawnGroupId), `${id}:${action.id}`).toBe(true);
          }
          if (action.kind === "set-world-object-state") {
            expect(objectIds.has(action.objectId), `${id}:${action.id}`).toBe(true);
          }
        }
      }

      const reviewedBlockers = definition.serverGameObjects.filter((object) => (
        object.id.includes(":reviewed-") || object.id.includes(":ice-wall-")
      ));
      expect(reviewedBlockers.length).toBeGreaterThan(0);
      for (const blocker of reviewedBlockers) {
        const closed = blocker.states.find((state) => state.id === "closed");
        const open = blocker.states.find((state) => state.id === "open");
        expect(closed).toMatchObject({ visible: true, blocksMovement: true });
        expect(open).toMatchObject({ blocksMovement: false });
      }

      const originalImportedObjects = definition.serverGameObjects.filter((object) => (
        object.source?.spawnId !== undefined && !object.id.includes(":reviewed-")
      ));
      const originalImportedObjectIds = new Set(originalImportedObjects.map((object) => object.id));
      for (const object of source.serverGameObjects.filter((candidate) => (
        candidate.source?.spawnId !== undefined && !candidate.id.includes(":reviewed-")
      ))) {
        expect(originalImportedObjectIds.has(object.id), `${id} dropped imported object ${object.id}`).toBe(true);
      }
      expect(originalImportedObjects.every((object) => object.visual?.hidden === true)).toBe(true);
      expect(originalImportedObjects.every((object) => object.states.every((state) => !state.blocksMovement))).toBe(true);
      expect(withWowWrathEncounterContent(definition)).toBe(definition);
    }
  });

  it("removes every unsafe static event boss and preserves exact sourced stage cardinality", () => {
    const expectations = {
      "halls-of-reflection": [38_112, 38_113],
      "the-oculus": [27_447, 27_654, 27_655, 27_656],
      "trial-of-the-champion": [30_188, 35_451, 35_569, 35_571, 35_572],
    } as const;
    for (const id of TARGETS) {
      const definition = adaptedDefinition(id);
      const staticEntries = definition.staticSpawns.map((spawn) => definition.entities[spawn.entityId]?.combat?.serverEntry);
      for (const entry of expectations[id]) expect(staticEntries).not.toContain(entry);
      expect(definition.bosses.every((boss) => boss.eventOnly)).toBe(true);
      const staticSpawnIds = new Set(definition.staticSpawns.map((spawn) => spawn.id));
      for (const boss of definition.bosses) {
        expect(staticSpawnIds.has(boss.id), `${id} left event boss ${boss.name} statically spawned`).toBe(false);
      }
    }

    const halls = adaptedDefinition("halls-of-reflection");
    expect([1, 2, 3, 4, 6, 7, 8, 9].map((wave) => (
      halls.encounterSpawnGroups?.find((group) => group.id === `halls-of-reflection:wave-${String(wave).padStart(2, "0")}`)?.spawns.length
    ))).toEqual([3, 3, 4, 4, 5, 5, 5, 5]);

    const oculus = adaptedDefinition("the-oculus");
    expect(oculus.encounterSpawnGroups?.find((group) => group.id === "the-oculus:centrifuge-constructs")?.spawns).toHaveLength(10);
    expect([1, 2, 3].map((wave) => (
      oculus.encounterSpawnGroups?.find((group) => group.id === `the-oculus:urom-menagerie-${wave}`)?.spawns.length
    ))).toEqual([4, 4, 4]);

    const trial = adaptedDefinition("trial-of-the-champion");
    expect([1, 2, 3].map((wave) => (
      trial.encounterSpawnGroups?.find((group) => group.id.startsWith(`trial-of-the-champion:minions-${wave}-`))?.spawns.length
    ))).toEqual([3, 3, 3]);
    expect(trial.encounterSpawnGroups?.find((group) => group.id === "trial-of-the-champion:argent-soldiers")?.spawns).toHaveLength(9);
    expect([1, 2, 3].map((phase) => (
      trial.encounterSpawnGroups?.find((group) => group.id === `trial-of-the-champion:black-knight-phase-${phase}`)?.spawns.length
    ))).toEqual([1, 1, 1]);
  });

  it("gives every Trial event boss its pinned phase-specific combat schedule", () => {
    const trial = adaptedDefinition("trial-of-the-champion");
    const trialReview = WOW_WRATH_ENCOUNTER_CONTENT_REVIEWS.find(
      (review) => review.dungeonId === "trial-of-the-champion",
    );
    expect(trialReview?.adaptations.join(" ")).toContain(
      "six-second, one-charge +100% critical chance modifier",
    );
    const entity = (id: string) => trial.entities[id];
    const specials = (id: string) => entity(id).combat?.attacks.filter((attack) => attack.id !== "basic-attack") ?? [];

    for (const id of [
      "wrath-event-mounted-mokra",
      "wrath-event-mounted-eressea",
      "wrath-event-mounted-runok",
    ]) {
      expect(specials(id).map((attack) => attack.id)).toEqual([
        "mounted-charge-63010",
        "shield-breaker-68504",
        "thrust-68505",
      ]);
      expect(specials(id).map((attack) => [attack.initialCooldownMs, attack.repeatCooldownMs])).toEqual([
        [[2_500, 4_000], [4_500, 6_000]],
        [[5_000, 8_000], [6_000, 8_000]],
        [[3_000, 5_000], [3_000, 5_000]],
      ]);
    }

    expect(specials("wrath-event-eadric").map((attack) => attack.spellId)).toEqual([
      66_865,
      66_935,
      66_867,
    ]);
    expect(specials("wrath-event-eadric").find((attack) => attack.id === "vengeance-66865")?.effect)
      .toEqual({
        kind: "aura",
        aura: "vengeance",
        durationMs: 0,
        meleeAutoCriticalProc: {
          chance: 1,
          triggeredAura: "vengeance-next-melee-critical-66889",
          durationMs: 6_000,
          criticalChancePercent: 100,
          charges: 1,
        },
      });
    expect(specials("wrath-event-eadric").find((attack) => attack.id === "radiance-66935")?.repeatCooldownMs)
      .toEqual([16_000, 16_000]);
    expect(specials("wrath-event-eadric").find((attack) => attack.id === "radiance-66935"))
      .toMatchObject({
        school: "holy",
        damageMultiplier: 0.9,
        effect: { kind: "control", mechanic: "confuse", durationMs: 2_000, damageMultiplier: 0.9 },
      });
    expect(specials("wrath-event-eadric").find((attack) => attack.id === "hammer-of-justice-and-righteous-66863-66867"))
      .toMatchObject({
        name: "Hammer of Justice + Hammer of the Righteous",
        target: "random-party",
        initialCooldownMs: [25_000, 25_000],
        repeatCooldownMs: [25_000, 25_000],
        effect: { kind: "control", mechanic: "stun", durationMs: 6_000, damageMultiplier: 1.3 },
      });
    expect(specials("wrath-event-eadric").some((attack) => attack.id === "hammer-of-justice-66863")).toBe(false);

    for (const id of ["wrath-event-mounted-eressea", "wrath-event-black-knight-phase-3"]) {
      expect(entity(id).combat?.attacks[0]).toMatchObject({
        id: "basic-attack",
        name: "Basic Attack",
        delivery: "melee",
        school: "physical",
        animation: "attack",
        range: 4.5,
      });
    }

    expect(specials("wrath-event-black-knight-phase-1").map((attack) => attack.id)).toEqual([
      "plague-strike-67724",
      "icy-touch-67718",
      "death-respite-67745",
      "obliterate-67725",
    ]);
    expect(specials("wrath-event-black-knight-phase-1")[0]).toMatchObject({
      id: "plague-strike-67724",
      school: "physical",
    });
    expect(specials("wrath-event-black-knight-phase-2").map((attack) => attack.id)).toEqual([
      "plague-strike-67724",
      "icy-touch-67718",
      "obliterate-67725",
      "desecration-67778",
    ]);
    expect(specials("wrath-event-black-knight-phase-2")[0]).toMatchObject({
      id: "plague-strike-67724",
      school: "physical",
    });
    expect(specials("wrath-event-black-knight-phase-3").map((attack) => ({
      id: attack.id,
      initial: attack.initialCooldownMs,
      repeat: attack.repeatCooldownMs,
    }))).toEqual([
      { id: "death-bite-67808", initial: [2_000, 2_000], repeat: [2_000, 4_000] },
      { id: "marked-for-death-67823", initial: [1_000, 1_000], repeat: [9_000, 9_000] },
    ]);
    expect(specials("wrath-event-black-knight-phase-3")[1].effect)
      .toEqual({ kind: "target-aura", aura: "marked-for-death", durationMs: 9_000 });
  });

  it("reduces every complete source-ordered lifecycle without renderer state", () => {
    const halls = adaptedDefinition("halls-of-reflection");
    const hallsRun = finishEncounter(halls, adaptedEncounter(halls));
    expectOrderedPhases(hallsRun.phases, [
      "wave-01-active", "wave-05-active", "wave-06-source-pause", "wave-06-active",
      "wave-10-active", "general-active", "escape-ready", "escape-1-active", "escape-4-active", "complete",
    ]);

    const oculus = adaptedDefinition("the-oculus");
    const oculusRun = finishEncounter(oculus, adaptedEncounter(oculus));
    expectOrderedPhases(oculusRun.phases, [
      "drakos-active", "constructs-active", "varos-active", "urom-menagerie-1-active",
      "urom-menagerie-3-active", "urom-active", "eregos-active", "complete",
    ]);

    const trial = adaptedDefinition("trial-of-the-champion");
    const trialRun = finishEncounter(trial, adaptedEncounter(trial));
    expectOrderedPhases(trialRun.phases, [
      "champion-minions-1-active", "champion-minions-3-active", "mounted-champions-active",
      "foot-champions-active", "argent-soldiers-active", "eadric-active",
      "black-knight-phase-1-active", "black-knight-phase-3-active", "complete",
    ]);

    for (const [definition, result] of [
      [halls, hallsRun],
      [oculus, oculusRun],
      [trial, trialRun],
    ] as const) {
      expect(result.snapshot.flags["dungeon-complete"]).toBe(true);
      expect(result.snapshot.completedObjectiveIds).toEqual(
        expect.arrayContaining(definition.bosses.filter((boss) => !boss.optional).map((boss) => boss.id)),
      );
      expect(result.snapshot.activeSpawnGroupIds).toEqual([]);
    }
  });

  it("recovers from every non-final persistent checkpoint without a soft lock", () => {
    const expectedCheckpointCounts = {
      "halls-of-reflection": 3,
      "the-oculus": 3,
      "trial-of-the-champion": 2,
    } as const;
    for (const id of TARGETS) {
      const definition = adaptedDefinition(id);
      const encounter = adaptedEncounter(definition);
      let snapshot = createDungeonEncounterSnapshot(encounter);
      let now = 1;
      const checkpointSnapshots: DungeonEncounterSnapshot[] = [];
      const seenCheckpoints = new Set<string>();
      for (let step = 0; step < 80 && snapshot.phase !== "complete"; step += 1) {
        snapshot = advanceOneStep(definition, encounter, snapshot, now);
        now = Math.max(now + 1, snapshot.phaseStartedAt + 1);
        if (snapshot.checkpointId && !seenCheckpoints.has(snapshot.checkpointId) && snapshot.phase !== "complete") {
          seenCheckpoints.add(snapshot.checkpointId);
          checkpointSnapshots.push(snapshot);
        }
      }
      expect(checkpointSnapshots, id).toHaveLength(expectedCheckpointCounts[id]);
      for (const checkpoint of checkpointSnapshots) {
        const reset = resetDungeonEncounterSnapshot(encounter, checkpoint, "boss-wipe", now + 1);
        expect(reset.phase).toBe("resume");
        expect(reset.activeSpawnGroupIds).toEqual([]);
        expect(reset.completedObjectiveIds).toEqual(checkpoint.completedObjectiveIds);

        const resumed = reduceDungeonEncounter(encounter, reset, { kind: "tick", now: now + 2 }).snapshot;
        expect(resumed.phase).not.toBe("resume");
        expect(
          resumed.activeSpawnGroupIds.length > 0 || resumed.phase === "escape-ready",
          `${id}:${checkpoint.checkpointId}`,
        ).toBe(true);
        expect(finishEncounter(definition, encounter, resumed).snapshot.flags["dungeon-complete"]).toBe(true);
      }
    }
  });
});