import test from "node:test";
import assert from "node:assert/strict";
import fs from "node:fs";
import path from "node:path";
import {fileURLToPath} from "node:url";
import {
  applyEffects, createStore, freshState, normalizeState, relationshipStage,
  resolveEnding, requirementMet, RELATIONSHIPS
} from "../../assets/scripts/games/two-rivers/core/state.mjs";
import {validateContent} from "../../assets/scripts/games/two-rivers/core/content.mjs";
import {createSaveService, SAVE_KEY} from "../../assets/scripts/games/two-rivers/core/save.mjs";

const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
const read = (file) => fs.readFileSync(path.join(root, file), "utf8");
const json = (file) => JSON.parse(read(file));
const content = {
  assets: json("assets/games/two-rivers/data/assets.json"),
  characters: json("assets/games/two-rivers/data/characters.json"),
  locations: json("assets/games/two-rivers/data/locations.json"),
  items: json("assets/games/two-rivers/data/items.json"),
  quests: json("assets/games/two-rivers/data/quests.json"),
  achievements: json("assets/games/two-rivers/data/achievements.json"),
  endings: json("assets/games/two-rivers/data/endings.json"),
  dialogue: {
    ...json("assets/games/two-rivers/data/dialogue/story.json"),
    ...json("assets/games/two-rivers/data/dialogue/scenes.json"),
    ...json("assets/games/two-rivers/data/dialogue/chapters.json")
  }
};

test("content contracts, asset paths, and dialogue graphs are complete", () => {
  assert.deepEqual(validateContent(content), []);
  assert.equal(Object.keys(content.locations).length, 5);
  assert.equal(Object.keys(content.endings).length, 4);
  assert.equal(Object.keys(content.achievements).length, 12);
  assert.equal(content.assets.images.filter((asset) => asset.type === "npc").length, 6);
  assert.equal(content.assets.images.filter((asset) => asset.type === "item").length, 18);
  assert.equal(new Set(content.assets.images.map((asset) => asset.id)).size, content.assets.images.length);
  content.assets.images.forEach((asset) => assert.ok(fs.existsSync(path.join(root, asset.url))));
  content.assets.images.forEach((asset) => {
    const promptFile = asset.prompt?.split("#")[0];
    assert.ok(promptFile && fs.existsSync(path.join(root, "assets/games/two-rivers", promptFile)), `missing prompt for ${asset.id}`);
  });
  content.assets.audio.forEach((asset) => {
    assert.deepEqual(asset.urls.map((url) => path.extname(url)), [".webm", ".mp3"]);
    asset.urls.forEach((url) => assert.ok(fs.existsSync(path.join(root, url))));
    assert.ok(asset.source && asset.licence);
  });
  Object.values(content.dialogue).forEach((dialogue) => {
    const reachable = new Set();
    const visit = (id) => {
      if (!id || reachable.has(id)) return;
      reachable.add(id);
      const node = dialogue.nodes[id];
      visit(node.next);
      node.choices?.forEach((choice) => visit(choice.next));
    };
    visit(dialogue.start);
    assert.deepEqual([...reachable].sort(), Object.keys(dialogue.nodes).sort());
  });
  const authoredWords = Object.values(content.dialogue).flatMap((dialogue) => Object.values(dialogue.nodes))
    .reduce((total, node) => total + (node.text.match(/\b[\w’'-]+\b/g) || []).length +
      (node.choices || []).reduce((choiceTotal, choice) => choiceTotal + (choice.text.match(/\b[\w’'-]+\b/g) || []).length, 0), 0);
  assert.ok(authoredWords >= 5000, `expected a feature-length script, found ${authoredWords} words`);
});

test("seven relationship values are independent, clamped, and qualitative", () => {
  const store = createStore(freshState());
  const before = store.get().relationships;
  store.dispatch({type: "relationship", key: "trust", amount: 200});
  assert.equal(store.get().relationships.trust, 100);
  RELATIONSHIPS.filter((key) => key !== "trust").forEach((key) => assert.equal(store.get().relationships[key], before[key]));
  assert.deepEqual([0, 25, 50, 75].map(relationshipStage), ["New", "Growing", "Warm", "Deep"]);
});

test("quest rewards are idempotent and requirements unlock deterministically", () => {
  const store = createStore(freshState());
  const quest = content.quests.garland;
  content.items.flowers.forEach((item) => store.dispatch({
    type: "questProgress", id: "garland", item, target: quest.target, reward: quest.reward
  }));
  const complete = store.get();
  assert.equal(complete.quests.garland.status, "complete");
  assert.ok(complete.unlockedCGs.includes("garland"));
  const approval = complete.relationships.familyApproval;
  store.dispatch({type: "questProgress", id: "garland", item: "jasmine", target: quest.target, reward: quest.reward});
  assert.equal(store.get().relationships.familyApproval, approval);
  store.dispatch({type: "puzzle", id: "cipher"});
  assert.equal(requirementMet(store.get(), "flag:cipher_solved"), true);
});

test("all four guaranteed-romance endings are reachable", () => {
  const profiles = {
    scholar: {respect: 100, trust: 100, comfort: 90},
    laughter: {humour: 100, comfort: 100, adventure: 80},
    road: {adventure: 100, trust: 95, humour: 90},
    families: {familyApproval: 100, respect: 90, comfort: 90}
  };
  Object.entries(profiles).forEach(([expected, values]) => {
    const state = freshState();
    Object.assign(state.relationships, {
      trust: 5, respect: 5, comfort: 5, humour: 5,
      adventure: 5, romance: 90, familyApproval: 5, ...values
    });
    state.endingBias[expected] = 12;
    assert.equal(resolveEnding(state, content.endings), expected);
  });
});

test("save slots validate and reject corruption", () => {
  class MemoryStorage {
    constructor() { this.values = new Map(); }
    getItem(key) { return this.values.has(key) ? this.values.get(key) : null; }
    setItem(key, value) { this.values.set(key, String(value)); }
    removeItem(key) { this.values.delete(key); }
  }
  const storage = new MemoryStorage();
  const saves = createSaveService(storage);
  const state = freshState();
  state.location = "garden";
  saves.save("auto", state);
  assert.equal(saves.load("auto").location, "garden");
  saves.save("slot1", state);
  assert.ok(saves.list().slot1);
  const envelope = JSON.parse(storage.getItem(SAVE_KEY));
  envelope.slots.auto.state.location = "unknown";
  storage.setItem(SAVE_KEY, JSON.stringify(envelope));
  assert.equal(saves.load("auto"), null);
});

test("page uses local pinned libraries and production source is clean", () => {
  const page = read("play/two-rivers.org");
  assert.match(page, /phaser-3\.90\.0\.min\.js/);
  assert.match(page, /gsap-3\.13\.0\.min\.js/);
  assert.match(page, /howler-2\.2\.4\.min\.js/);
  assert.doesNotMatch(page, /https?:\/\//);
  const source = [
    page,
    read("assets/scripts/games/two-rivers/main.js"),
    read("assets/scripts/games/two-rivers/core/state.mjs"),
    read("assets/scripts/games/two-rivers/ui/interface.mjs"),
    read("assets/scripts/games/two-rivers/scenes/game-scenes.mjs")
  ].join("\n");
  assert.doesNotMatch(source, /\bTODO\b|placeholder implementation|lorem ipsum/i);
  assert.doesNotMatch(source, /\bReact\b|\bVue\b|\bAngular\b|\bjQuery\b/);
  assert.ok(read("assets/styles/pages/two-rivers.css").length > 15000);
});

test("normalization rejects hostile IDs and caps collections", () => {
  const state = freshState();
  state.inventory = ["valid_item", "<script>", ...Array.from({length: 100}, (_, index) => `item_${index}`)];
  const normalized = normalizeState(state);
  assert.equal(normalized.inventory.includes("<script>"), false);
  assert.ok(normalized.inventory.length <= 80);
});

test("minigame results improve but story rewards cannot be ground repeatedly", () => {
  const store = createStore(freshState());
  store.dispatch({type: "minigame", id: "archery", score: 35});
  applyEffects(store, [{type: "relationship", key: "adventure", amount: 4}]);
  const rewarded = store.get().relationships.adventure;
  store.dispatch({type: "minigame", id: "archery", score: 82});
  assert.equal(store.get().minigames.archery.score, 82);
  assert.equal(store.get().relationships.adventure, rewarded);
  assert.equal(store.get().minigames.archery.attempts, 2);
});

test("a deterministic complete route reaches a guaranteed romantic ending", () => {
  const store = createStore(freshState());
  const finishDialogue = (id, choiceIndex = 0) => {
    const graph = content.dialogue[id];
    let nodeId = graph.start;
    const visited = new Set();
    while (nodeId) {
      assert.ok(!visited.has(nodeId), `cycle in ${id}/${nodeId}`);
      visited.add(nodeId);
      const node = graph.nodes[nodeId];
      applyEffects(store, node.effects);
      if (node.choices?.length) {
        const choice = node.choices[Math.min(choiceIndex, node.choices.length - 1)];
        applyEffects(store, choice.effects);
        store.dispatch({type: "choice", id: `${id}:${nodeId}:${choice.next}`});
        nodeId = choice.next;
      } else nodeId = node.next;
    }
    store.dispatch({type: "flag", id: `dialogue_${id}`});
  };
  const exitReady = (location, hotspot) => {
    const definition = content.locations[location].hotspots.find((spot) => spot.id === hotspot);
    assert.ok(definition.requires.every((requirement) => requirementMet(store.get(), requirement)), `${location}/${hotspot} is blocked`);
  };

  ["arrival", "delegation_walk", "courtyard_preparations", "ishan_protocol"].forEach((id) => finishDialogue(id));
  exitReady("courtyard", "to_library");
  store.dispatch({type: "goto", location: "library", position: 0.1});
  ["anwara_memory", "missing_folio", "library_search", "library_balcony"].forEach((id) => finishDialogue(id));
  store.dispatch({type: "puzzle", id: "cipher"});
  exitReady("library", "to_garden");
  store.dispatch({type: "goto", location: "garden", position: 0.08});
  ["mira_garland", "garden_confidence", "garden_walk", "garden_history"].forEach((id) => finishDialogue(id));
  store.dispatch({type: "puzzle", id: "flower_sequence"});
  store.dispatch({type: "minigame", id: "archery", score: 70});
  finishDialogue("archery_after");
  exitReady("garden", "to_market");
  store.dispatch({type: "goto", location: "market", position: 0.08});
  content.items.flowers.forEach((item) => store.dispatch({type: "questProgress", id: "garland", item, target: 5, reward: content.quests.garland.reward}));
  content.items.letters.forEach((item) => store.dispatch({type: "questProgress", id: "letters", item, target: 3, reward: content.quests.letters.reward}));
  ["nadia_letters", "market_walk", "market_founders", "rayhan_kitchen"].forEach((id) => finishDialogue(id));
  store.dispatch({type: "minigame", id: "cooking", score: 60});
  finishDialogue("anwara_truth");
  exitReady("market", "to_festival");
  store.dispatch({type: "goto", location: "pavilion", position: 0.08});
  ["ishan_stage", "pavilion_waiting", "resolution"].forEach((id) => finishDialogue(id));
  store.dispatch({type: "minigame", id: "dance", score: 60});
  ["dance_after", "moonrise"].forEach((id) => finishDialogue(id));
  const ending = resolveEnding(store.get(), content.endings);
  assert.ok(["scholar", "laughter", "road", "families"].includes(ending));
  assert.ok(store.get().relationships.romance > 0);
});

test("save recovery reports unknown versions and restores the previous valid envelope", () => {
  class MemoryStorage {
    constructor() { this.values = new Map(); }
    getItem(key) { return this.values.has(key) ? this.values.get(key) : null; }
    setItem(key, value) { this.values.set(key, String(value)); }
    removeItem(key) { this.values.delete(key); }
  }
  const storage = new MemoryStorage();
  const saves = createSaveService(storage);
  saves.save("auto", freshState());
  storage.setItem(`${SAVE_KEY}:backup`, storage.getItem(SAVE_KEY));
  storage.setItem(SAVE_KEY, JSON.stringify({version: 99, slots: {}}));
  assert.ok(saves.hasSave());
  assert.equal(saves.recoveryInfo().source, "backup");
});