import assert from "node:assert/strict";
import { mkdtempSync, readFileSync, rmSync } from "node:fs";
import os from "node:os";
import path from "node:path";
import test from "node:test";
import { DatabaseSync } from "node:sqlite";
import { GameDatabaseError, openGameDatabase } from "./database.mjs";

const routeCatalog = JSON.parse(readFileSync(new URL("../src/game/generated/dungeonRouteCatalog.generated.json", import.meta.url), "utf8"));

function withDatabase(run) {
  const directory = mkdtempSync(path.join(os.tmpdir(), "healer-man-db-test-"));
  const database = openGameDatabase({ dataDir: directory, sessionTtlDays: 1 });
  return Promise.resolve(run(database)).finally(() => {
    database.close();
    rmSync(directory, { recursive: true, force: true });
  });
}

test("registers, authenticates, and revokes an account session", () => withDatabase(async (database) => {
  const registered = await database.register("CaveHealer", "serpent-pass");
  assert.equal(registered.account.username, "CaveHealer");
  assert.equal(database.authenticate(registered.token).id, registered.account.id);

  const loggedIn = await database.login("cavehealer", "serpent-pass");
  assert.equal(loggedIn.account.id, registered.account.id);
  database.logout(loggedIn.token);
  assert.throws(() => database.authenticate(loggedIn.token), (error) => (
    error instanceof GameDatabaseError && error.status === 401
  ));
}));

test("rejects duplicate usernames and incorrect passwords", () => withDatabase(async (database) => {
  await database.register("PartyLead", "eight-plus");
  await assert.rejects(database.register("partylead", "another-pass"), (error) => (
    error instanceof GameDatabaseError && error.status === 409
  ));
  await assert.rejects(database.login("PartyLead", "wrong-pass"), (error) => (
    error instanceof GameDatabaseError && error.status === 401
  ));
}));

test("persists opaque cloud roster data with increasing revisions", () => withDatabase(async (database) => {
  const registered = await database.register("CloudPriest", "cloud-pass");
  assert.equal(database.getCloudSave(registered.account.id).revision, 0);
  const first = database.putCloudSave(registered.account.id, {
    version: 1,
    characters: [{ id: "character-one", name: "Mendwell" }],
  });
  const second = database.putCloudSave(registered.account.id, {
    version: 1,
    characters: [{ id: "character-one", name: "Mendbetter" }],
  });
  assert.equal(first.revision, 1);
  assert.equal(second.revision, 2);
  assert.equal(database.getCloudSave(registered.account.id).data.characters[0].name, "Mendbetter");
}));

test("derives GM authority from the hardcoded developer accounts", () => withDatabase(async (database) => {
  const gm = await database.register("Phenom", "storm-admin");
  const developerGm = await database.register("codex_dev_gm", "developer-admin");
  const player = await database.register("Ordinary", "storm-player");
  assert.deepEqual(gm.account.roles, ["gm"]);
  assert.deepEqual((await database.login("pHeNoM", "storm-admin")).account.roles, ["gm"]);
  assert.deepEqual(developerGm.account.roles, ["gm"]);
  assert.equal(database.isGameMaster(database.authenticate(gm.token)), true);
  assert.equal(database.isGameMaster(database.authenticate(developerGm.token)), true);
  assert.equal(database.isGameMaster(database.authenticate(player.token)), false);
  assert.equal(database.isGameMaster({ ...player.account, roles: ["gm"] }), false);
}));

test("recovers Manastorm configuration after restart and falls back safely from corrupt data", async () => {
  const directory = mkdtempSync(path.join(os.tmpdir(), "healer-man-db-restart-test-"));
  const databasePath = path.join(directory, "game.db");
  try {
    const first = openGameDatabase({ databasePath });
    const gm = await first.register("Phenom", "storm-admin");
    const current = first.getManastormConfig();
    first.putManastormConfig(first.authenticate(gm.token), 0, {
      ...current.config,
      global: { ...current.config.global, enabled: false },
    });
    first.close();

    const restarted = openGameDatabase({ databasePath });
    assert.equal(restarted.getManastormConfig().revision, 1);
    assert.equal(restarted.getManastormConfig().config.global.enabled, false);
    restarted.close();

    const raw = new DatabaseSync(databasePath);
    raw.prepare("UPDATE manastorm_admin_config SET config_json = ? WHERE id = 1").run("{corrupt");
    raw.close();
    const recovered = openGameDatabase({ databasePath });
    assert.equal(recovered.getManastormConfig().revision, 0);
    assert.deepEqual(recovered.getManastormConfig().config.bosses, {});
    recovered.close();
  } finally {
    rmSync(directory, { recursive: true, force: true });
  }
});

test("persists revisioned Manastorm GM configuration and rejects stale or unauthorized writes", () => withDatabase(async (database) => {
  const gm = await database.register("Phenom", "storm-admin");
  const player = await database.register("Ordinary", "storm-player");
  const gmAccount = database.authenticate(gm.token);
  const playerAccount = database.authenticate(player.token);
  const initial = database.getManastormConfig();
  assert.equal(initial.revision, 0);
  assert.deepEqual(initial.config.bosses, {});

  const configured = {
    ...initial.config,
    global: { ...initial.config.global, affixesEnabled: false },
    dungeons: {
      deadmines: {
        status: "not-ready",
        note: "The final door trigger needs fixing.",
        reviewedAt: 1,
        reviewedBy: "SpoofedGM",
      },
    },
  };
  const saved = database.putManastormConfig(gmAccount, 0, configured);
  assert.equal(saved.revision, 1);
  assert.equal(saved.config.global.affixesEnabled, false);
  assert.deepEqual(saved.config.dungeons.deadmines, {
    status: "not-ready",
    note: "The final door trigger needs fixing.",
    reviewedAt: saved.updatedAt,
    reviewedBy: "Phenom",
  });
  assert.equal(database.getManastormConfig().updatedBy, "Phenom");
  assert.throws(() => database.putManastormConfig(gmAccount, 0, configured), (error) => (
    error instanceof GameDatabaseError && error.status === 409
  ));
  assert.throws(() => database.putManastormConfig(playerAccount, 1, configured), (error) => (
    error instanceof GameDatabaseError && error.status === 403
  ));
  assert.throws(() => database.putManastormConfig(gmAccount, 1, {
    ...configured,
    bosses: { "boss:incomplete": { status: "ready" } },
  }), (error) => error instanceof GameDatabaseError && error.status === 400);
}));

test("persists revisioned companion cooldown policy and rejects stale or unauthorized writes", () => withDatabase(async (database) => {
  const gm = await database.register("Phenom", "cooldown-admin");
  const player = await database.register("Ordinary", "cooldown-player");
  const initial = database.getCompanionCooldownPolicy();
  const configured = {
    ...initial.config,
    generic: { ...initial.config.generic, defensiveHealthPercent: 61 },
    mechanics: [{
      id: "tank-buster", enabled: true, bossKey: "test/boss", bossName: "Test Boss",
      bossServerEntry: 123, attackId: "heavy-strike", attackName: "Heavy Strike",
      scope: "tank", leadTimeMs: 2_500, minimumCooldownSeconds: 20,
    }],
  };
  const saved = database.putCompanionCooldownPolicy(database.authenticate(gm.token), 0, configured);
  assert.equal(saved.revision, 1);
  assert.equal(database.getCompanionCooldownPolicy().config.generic.defensiveHealthPercent, 61);
  assert.throws(() => database.putCompanionCooldownPolicy(database.authenticate(gm.token), 0, configured), (error) => (
    error instanceof GameDatabaseError && error.status === 409
  ));
  assert.throws(() => database.putCompanionCooldownPolicy(database.authenticate(player.token), 1, configured), (error) => (
    error instanceof GameDatabaseError && error.status === 403
  ));
}));

test("persists validated companion readiness with authorization, revisions, and corrupt-data fallback", () => withDatabase(async (database) => {
  const gm = await database.register("Phenom", "readiness-admin");
  const player = await database.register("ReadinessPlayer", "readiness-player");
  const initial = database.getCompanionSpecReadiness();
  assert.equal(initial.revision, 0);
  assert.equal(initial.config.statuses["warrior:protection"], "ready");
  assert.equal(Object.values(initial.config.statuses).filter((status) => status === "ready").length, 5);

  const configured = {
    ...initial.config,
    statuses: { ...initial.config.statuses, "paladin:retribution": "beta" },
  };
  const account = database.authenticate(gm.token);
  const saved = database.putCompanionSpecReadiness(account, 0, configured);
  assert.equal(saved.revision, 1);
  assert.equal(database.getCompanionSpecReadiness().config.statuses["paladin:retribution"], "beta");
  assert.throws(() => database.putCompanionSpecReadiness(account, 0, configured), (error) => (
    error instanceof GameDatabaseError && error.status === 409
  ));
  assert.throws(() => database.putCompanionSpecReadiness(database.authenticate(player.token), 1, configured), (error) => (
    error instanceof GameDatabaseError && error.status === 403
  ));
  assert.throws(() => database.putCompanionSpecReadiness(account, 1, {
    schemaVersion: 1,
    statuses: { ...configured.statuses, "warrior:protection": "needs-testing" },
  }), (error) => error instanceof GameDatabaseError && error.status === 400);

  const raw = new DatabaseSync(database.databasePath);
  raw.prepare("UPDATE companion_spec_readiness SET config_json = ? WHERE id = 1").run("{not-json");
  raw.close();
  const fallback = database.getCompanionSpecReadiness();
  assert.equal(fallback.revision, 0);
  assert.equal(fallback.config.statuses["warrior:protection"], "ready");
}));

test("stores GM simulation replays and gates exact-hash route approval", () => withDatabase(async (database) => {
  const gmAuth = await database.register("Phenom", "storm-admin");
  const playerAuth = await database.register("RoutePlayer", "route-player");
  const gm = database.authenticate(gmAuth.token);
  const player = database.authenticate(playerAuth.token);
  const routeHash = routeCatalog.routes.find((route) => route.dungeonId === "deadmines").hash;
  const replay = {
    schemaVersion: 1,
    dungeonId: "deadmines",
    routeId: "primary",
    routeHash,
    mode: "navigation-only",
    seed: "deadmines:primary",
    result: "completed",
    startedAt: 1_700_000_000_000,
    durationMs: 42_000,
    report: { schemaVersion: 1, findings: [] },
    frames: [{ atMs: 0, actors: [] }],
    events: [],
  };

  assert.throws(() => database.saveDungeonSimulationReplay(player, replay), (error) => (
    error instanceof GameDatabaseError && error.status === 403
  ));
  assert.throws(() => database.putDungeonRouteReview(gm, "deadmines", "primary", {
    routeHash, status: "Approved", expectedRevision: 0,
  }), (error) => error instanceof GameDatabaseError && error.code === "route_run_required");

  const saved = database.saveDungeonSimulationReplay(gm, replay);
  assert.equal(saved.criticalFindings, 0);
  assert.equal(database.getDungeonSimulationReplay(gm, saved.id).frames.length, 1);
  assert.equal(database.getDungeonSimulationReport(gm, saved.id).schemaVersion, 1);

  const review = database.putDungeonRouteReview(gm, "deadmines", "primary", {
    routeHash, status: "Approved", expectedRevision: 0, note: "Clean navigation-only pass.",
  });
  assert.equal(review.revision, 1);
  assert.deepEqual(database.listDungeonRouteApprovals().approvals.map(({ reviewedAt: _reviewedAt, ...entry }) => entry), [{
    dungeonId: "deadmines", routeId: "primary", routeHash,
  }]);
  assert.throws(() => database.putDungeonRouteReview(gm, "deadmines", "primary", {
    routeHash, status: "NeedsWork", expectedRevision: 0,
  }), (error) => error instanceof GameDatabaseError && error.status === 409);
  assert.equal(database.deleteDungeonSimulationReplay(gm, saved.id).ok, true);
}));

test("requires an override note when the latest exact-hash route run has critical findings", () => withDatabase(async (database) => {
  const gmAuth = await database.register("Phenom", "storm-admin");
  const gm = database.authenticate(gmAuth.token);
  const routeHash = routeCatalog.routes.find((route) => route.dungeonId === "blackfathom-deeps").hash;
  database.saveDungeonSimulationReplay(gm, {
    schemaVersion: 1,
    dungeonId: "blackfathom-deeps",
    routeId: "primary",
    routeHash,
    mode: "navigation-only",
    seed: "route-seed",
    result: "completed",
    startedAt: 1_700_000_000_000,
    durationMs: 10_000,
    report: { schemaVersion: 1, findings: [{ severity: "critical", code: "no-path" }] },
    frames: [],
    events: [],
  });
  assert.throws(() => database.putDungeonRouteReview(gm, "blackfathom-deeps", "primary", {
    routeHash, status: "Approved", expectedRevision: 0,
  }), (error) => error instanceof GameDatabaseError && error.code === "route_override_required");
  const review = database.putDungeonRouteReview(gm, "blackfathom-deeps", "primary", {
    routeHash, status: "Approved", expectedRevision: 0, criticalOverrideNote: "Known scripted lift gap.",
  });
  assert.equal(review.status, "Approved");
  assert.equal(review.criticalOverrideNote, "Known scripted lift gap.");
}));

test("requires the latest exact-hash route run to be completed before approval", () => withDatabase(async (database) => {
  const gmAuth = await database.register("Phenom", "storm-admin");
  const gm = database.authenticate(gmAuth.token);
  const routeHash = routeCatalog.routes.find((route) => route.dungeonId === "razorfen-downs").hash;
  database.saveDungeonSimulationReplay(gm, {
    schemaVersion: 1,
    dungeonId: "razorfen-downs",
    routeId: "primary",
    routeHash,
    mode: "full-combat",
    seed: "incomplete-route-seed",
    result: "stopped",
    startedAt: 1_700_000_000_000,
    durationMs: 10_000,
    report: { schemaVersion: 1, findings: [] },
    frames: [],
    events: [],
  });
  assert.throws(() => database.putDungeonRouteReview(gm, "razorfen-downs", "primary", {
    routeHash, status: "Approved", expectedRevision: 0,
  }), (error) => error instanceof GameDatabaseError && error.code === "route_completed_run_required");
}));

test("creates online groups through invitations and transfers leadership when the leader leaves", () => withDatabase(async (database) => {
  const leaderAuth = await database.register("GroupLeader", "group-pass");
  const healerAuth = await database.register("GroupHealer", "healer-pass");
  const leader = database.authenticate(leaderAuth.token);
  const healer = database.authenticate(healerAuth.token);

  const invitation = database.inviteOnlineGroupMember(leader, "grouphealer");
  assert.equal(invitation.state.group.members.length, 1);
  const incoming = database.onlineGroupState(healer.id).invitations;
  assert.equal(incoming.length, 1);
  assert.equal(incoming[0].inviterUsername, "GroupLeader");

  const accepted = database.respondToOnlineGroupInvite(healer.id, incoming[0].id, true);
  assert.equal(accepted.group.members.length, 2);
  assert.equal(accepted.group.leaderAccountId, leader.id);

  database.leaveOnlineGroup(leader.id);
  const transferred = database.onlineGroupState(healer.id);
  assert.equal(transferred.group.leaderAccountId, healer.id);
  assert.deepEqual(transferred.group.members.map((member) => member.username), ["GroupHealer"]);
}));

test("keeps RoM and WoW characters in separate online groups", () => withDatabase(async (database) => {
  const leaderAuth = await database.register("SourceLeader", "group-pass");
  const memberAuth = await database.register("SourceMember", "member-pass");
  const leader = database.authenticate(leaderAuth.token);
  const member = database.authenticate(memberAuth.token);
  database.inviteOnlineGroupMember(leader, member.username);
  const invite = database.onlineGroupState(member.id).invitations[0];
  database.respondToOnlineGroupInvite(member.id, invite.id, true);

  const wowCharacter = { id: "wow-priest", name: "Wow Priest", classId: "priest", categoryId: "wow", level: 20 };
  const romCharacter = { id: "rom-priest", name: "RoM Priest", classId: "rom-priest", categoryId: "rom", level: 20 };
  database.updateOnlineGroupMember(leader.id, wowCharacter, "healer");
  assert.throws(() => database.updateOnlineGroupMember(member.id, romCharacter, "healer"),
    (error) => error instanceof GameDatabaseError && error.code === "mixed_group_sources");
  assert.equal(database.onlineGroupState(member.id).group.members[1].character, null);

  database.updateOnlineGroupMember(leader.id, romCharacter, "healer");
  assert.throws(() => database.updateOnlineGroupMember(member.id, wowCharacter, "healer"),
    (error) => error instanceof GameDatabaseError && error.code === "mixed_group_sources");
  database.updateOnlineGroupMember(member.id, { ...romCharacter, id: "rom-mage", name: "RoM Mage", classId: "rom-mage" }, "damage");
  assert.throws(() => database.startOnlineGroupActivity(leader.id, {
    type: "dungeon", contentId: "randomized-bite-sized-stormwind-stockade", fillWithAi: true, partySize: 5,
  }), (error) => error instanceof GameDatabaseError && error.code === "group_source_incompatible");
  const started = database.startOnlineGroupActivity(leader.id, {
    type: "dungeon", contentId: "wailing-caverns", fillWithAi: true, partySize: 5,
  });
  assert.equal(started.group.activity.partySize, 2);
  assert.equal(started.group.activity.fillWithAi, false);
  assert.deepEqual(started.group.activity.companionSpecializationIds, []);
}));

test("launches players-only and AI-filled group activities only when every member is ready", () => withDatabase(async (database) => {
  const leaderAuth = await database.register("ReadyLeader", "group-pass");
  const memberAuth = await database.register("ReadyMember", "member-pass");
  const leader = database.authenticate(leaderAuth.token);
  const member = database.authenticate(memberAuth.token);
  database.inviteOnlineGroupMember(leader, member.username);
  const invite = database.onlineGroupState(member.id).invitations[0];
  database.respondToOnlineGroupInvite(member.id, invite.id, true);

  database.updateOnlineGroupMember(leader.id, {
    id: "leader-character", name: "Leadwell", classId: "warrior", specializationId: "warrior:protection", raceId: "human", gender: "male", level: 20,
  }, "tank");
  assert.equal(database.onlineGroupState(leader.id).group.members[0].character.specializationId, "warrior:protection");
  assert.throws(() => database.startOnlineGroupActivity(leader.id, {
    type: "dungeon", contentId: "wailing-caverns", fillWithAi: true, partySize: 5,
  }), (error) => error instanceof GameDatabaseError && error.code === "group_not_ready");

  database.updateOnlineGroupMember(member.id, {
    id: "member-character", name: "Mendwell", classId: "priest", specializationId: "priest:holy", raceId: "human", gender: "female", level: 20,
  }, "healer");
  const playersOnly = database.startOnlineGroupActivity(leader.id, {
    type: "dungeon", contentId: "wailing-caverns", fillWithAi: false, partySize: 5,
  });
  assert.equal(playersOnly.group.activity.partySize, 2);
  assert.equal(playersOnly.group.activity.fillWithAi, false);

  const filled = database.startOnlineGroupActivity(leader.id, {
    type: "manastorm", contentId: "manastorm", fillWithAi: true, includeBetaSpecs: true, partySize: 5, startingLevel: 10,
  });
  assert.equal(filled.group.activity.partySize, 5);
  assert.equal(filled.group.activity.startingLevel, 10);
  assert.equal(filled.group.activity.includeBetaSpecs, true);
  const randomized = database.startOnlineGroupActivity(leader.id, {
    type: "dungeon",
    contentId: "randomized-bite-sized-stormwind-stockade",
    fillWithAi: false,
    includeBetaSpecs: true,
    partySize: 2,
  });
  assert.equal(randomized.group.activity.partySize, 5);
  assert.equal(randomized.group.activity.fillWithAi, true);
  assert.equal(randomized.group.activity.includeBetaSpecs, false);
  assert.equal(randomized.group.activity.companionReadinessRevision, 0);
  assert.deepEqual(randomized.group.activity.companionSpecializationIds.sort(), [
    "hunter:marksmanship",
    "mage:fire",
    "priest:discipline",
    "rogue:assassination",
    "warrior:protection",
  ]);
  assert.throws(() => database.startOnlineGroupActivity(member.id, {
    type: "dungeon", contentId: "wailing-caverns",
  }), (error) => error instanceof GameDatabaseError && error.status === 403);
}));