/**
 * The rules. Everything a turn can be: a step, a blow, a stair, a climb out.
 * The dungeon is pure (`dungeon.ts`) and the memory is a database (`db.ts`);
 * this is the layer that puts one against the other, and the only place that
 * decides what a delver is allowed to do.
 *
 * One turn of the world happens per delver action, so a busy dungeon moves
 * faster than a quiet one — which is the right way round for a game several
 * people wander into at different hours.
 */

import type { Database } from "bun:sqlite";
import * as store from "./db.ts";
import type { Delver, Monster } from "./db.ts";
import {
  DEPTHS, LANTERN, at, distance, floorAt, openCells, seesFrom, stepToward,
  visibleFrom, walkable, xy, type Floor,
} from "./dungeon.ts";
import { epitaphFor, nameFor } from "./names.ts";

export type Direction = "north" | "south" | "east" | "west";
export type Action = Direction | "wait" | "descend" | "ascend";

export const DIRECTIONS: Record<Direction, { dx: number; dy: number }> = {
  north: { dx: 0, dy: -1 },
  south: { dx: 0, dy: 1 },
  east: { dx: 1, dy: 0 },
  west: { dx: -1, dy: 0 },
};

export const isAction = (value: string): value is Action =>
  value === "wait" || value === "descend" || value === "ascend" || value in DIRECTIONS;

interface Breed {
  kind: string;
  glyph: string;
  hp: number;
  bite: number;
  gold: number;
  /** How far it notices a lantern. */
  notice: number;
}

/** Deeper is worse. The rat is a tutorial; the wight is not. */
export const BREEDS: Breed[] = [
  { kind: "rat", glyph: "r", hp: 2, bite: 1, gold: 2, notice: 4 },
  { kind: "goblin", glyph: "g", hp: 4, bite: 2, gold: 5, notice: 6 },
  { kind: "ghoul", glyph: "G", hp: 6, bite: 3, gold: 9, notice: 7 },
  { kind: "shade", glyph: "S", hp: 8, bite: 4, gold: 14, notice: 8 },
  { kind: "wight", glyph: "W", hp: 12, bite: 5, gold: 22, notice: 9 },
];

export const breedOf = (kind: string): Breed =>
  BREEDS.find((b) => b.kind === kind) ?? (BREEDS[0] as Breed);

function noise(a: number, b: number, c: number): number {
  let h = (a * 2654435761) ^ (b * 40503) ^ (c * 2246822519);
  h = Math.imul(h ^ (h >>> 15), 2246822519);
  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;
}

/** Where the caches of coin sit on a floor. Deterministic, like everything. */
export function cacheCells(floor: Floor): number[] {
  const open = openCells(floor);
  const count = 3 + floor.depth;
  const cells: number[] = [];
  for (let i = 0; i < count; i += 1) {
    const cell = open[Math.floor(noise(floor.depth, i, 97) * open.length)];
    if (cell !== undefined && !cells.includes(cell)) cells.push(cell);
  }
  return cells;
}

/** Fill a floor's monsters the first time anyone sets foot on it. */
export function populate(db: Database, depth: number): void {
  const already = db
    .query<{ n: number }, [number]>("SELECT count(*) AS n FROM monster WHERE depth = ?1")
    .get(depth)?.n ?? 0;
  if (already > 0) return;
  const floor = floorAt(depth);
  const open = openCells(floor);
  const count = 5 + depth * 2;
  const insert = db.query(
    "INSERT OR IGNORE INTO monster (depth, spawn, cell, kind, hp) VALUES (?1, ?2, ?2, ?3, ?4)",
  );
  for (let i = 0; i < count; i += 1) {
    const cell = open[Math.floor(noise(depth, i, 31) * open.length)];
    if (cell === undefined) continue;
    // A landing you arrive on has to be survivable: nothing spawns within
    // sight of the stair. A first playtest put two rats on the entrance and
    // a fresh delver was at 3 of 12 hp inside seven turns, having done
    // nothing wrong.
    if (distance(cell, floor.entrance) <= 8) continue;
    // A floor's roster is mostly its own tier, with the occasional visitor
    // from one below — the first ghoul on floor 2 is the moment it lands.
    const tier = Math.min(BREEDS.length - 1, depth - 1 + (noise(depth, i, 53) < 0.2 ? 1 : 0));
    const breed = BREEDS[Math.max(0, tier)] as Breed;
    insert.run(depth, cell, breed.kind, breed.hp);
  }
}

export interface TurnResult {
  delver: Delver;
  /** What to tell the player, newest last. */
  log: string[];
  died: boolean;
  climbedOut: boolean;
}

/** The delver a hand is currently playing, made if there is none. */
export function delverFor(db: Database, hand: string): Delver {
  const active = store.activeDelver(db, hand);
  if (active) return active;
  const past = db
    .query<{ n: number }, [string]>("SELECT count(*) AS n FROM delver WHERE hand = ?1")
    .get(hand)?.n ?? 0;
  const floor = floorAt(1);
  populate(db, 1);
  const made = store.createDelver(db, hand, nameFor(hand, past), floor.entrance);
  store.markSeen(db, 1, visibleFrom(floor, made.cell));
  return made;
}

/** Everything the monsters do, once, after the delver has acted. */
function monsterTurn(db: Database, delver: Delver, now: number, log: string[]): Delver {
  const floor = floorAt(delver.depth);
  const monsters = store.monstersOn(db, delver.depth, now);
  const others = store.delversOn(db, delver.depth).filter((d) => d.id !== delver.id);
  let hp = delver.hp;
  for (const monster of monsters) {
    const breed = breedOf(monster.kind);
    // It goes for whoever is closest and in sight — which may not be you.
    const targets = [delver, ...others];
    let target: Delver | undefined;
    let best = Infinity;
    for (const candidate of targets) {
      const d = distance(monster.cell, candidate.cell);
      if (d <= breed.notice && d < best && seesFrom(floor, monster.cell, candidate.cell)) {
        best = d;
        target = candidate;
      }
    }
    if (target === undefined) continue;
    if (best <= 1) {
      if (target.id === delver.id) {
        hp -= breed.bite;
        log.push(`The ${monster.kind} bites you for ${breed.bite}.`);
      }
      continue;
    }
    // Chasers move at two thirds of a delver's pace. At equal speed nothing
    // pursued can ever reach a stair or rest, so every fight on a floor with
    // more than one monster was a death sentence — two goblins took a fresh
    // delver from 12 to 2 with no legal way to disengage. Deterministic in
    // the turn and the monster, so it is not luck either.
    if ((now + monster.id) % 3 === 0) continue;
    const next = stepToward(floor, monster.cell, target.cell);
    const occupied = monsters.some((m) => m.id !== monster.id && m.cell === next);
    if (!occupied && next !== monster.cell) {
      db.query("UPDATE monster SET cell = ?2 WHERE id = ?1").run(monster.id, next);
      monster.cell = next;
    }
  }
  return { ...delver, hp };
}

function die(db: Database, delver: Delver, log: string[]): Delver {
  const epitaph = epitaphFor(delver.name, delver.depth, delver.cell, delver.turns);
  db.query(
    "INSERT INTO grave (depth, cell, name, epitaph, gold) VALUES (?1, ?2, ?3, ?4, ?5)",
  ).run(delver.depth, delver.cell, delver.name, epitaph, delver.gold);
  log.push(`${delver.name} dies on floor ${delver.depth}, carrying ${delver.gold} gold.`);
  return {
    ...delver,
    hp: 0,
    state: "dead",
    ended_at: new Date().toISOString(),
    epitaph,
  };
}

/** One action. The only way the world moves. */
export function act(db: Database, hand: string, action: Action): TurnResult {
  let delver = delverFor(db, hand);
  const log: string[] = [];
  const floor = floorAt(delver.depth);
  const now = store.tick(db);
  delver = { ...delver, turns: delver.turns + 1 };
  let climbedOut = false;

  if (action === "descend" || action === "ascend") {
    const tile = floor.tiles[delver.cell];
    if (action === "descend" && tile === ">") {
      const next = floorAt(delver.depth + 1);
      populate(db, next.depth);
      delver = { ...delver, depth: next.depth, cell: next.entrance };
      log.push(`You climb down to floor ${next.depth}. The air is colder.`);
    } else if (action === "ascend" && tile === "<" && delver.depth === 1) {
      db.query(
        "INSERT INTO score (name, gold, depth, turns) VALUES (?1, ?2, ?3, ?4)",
      ).run(delver.name, delver.gold, delver.depth, delver.turns);
      delver = { ...delver, state: "returned", ended_at: new Date().toISOString() };
      log.push(`${delver.name} climbs out with ${delver.gold} gold. It is banked.`);
      climbedOut = true;
    } else if (action === "ascend" && tile === "<") {
      const up = floorAt(delver.depth - 1);
      delver = { ...delver, depth: up.depth, cell: up.descent ?? up.entrance };
      log.push(`You climb back up to floor ${up.depth}.`);
    } else {
      log.push("There is no stair here.");
    }
  } else if (action !== "wait") {
    const watchedBefore = store
      .monstersOn(db, delver.depth, now)
      .some((m) => distance(m.cell, delver.cell) <= LANTERN && seesFrom(floor, delver.cell, m.cell));
    const here = xy(delver.cell);
    const step = DIRECTIONS[action];
    const nx = here.x + step.dx;
    const ny = here.y + step.dy;
    const target = at(nx, ny);
    const monsters = store.monstersOn(db, delver.depth, now);
    const monster = monsters.find((m) => m.cell === target);
    if (monster) {
      // Bump to attack. Damage is 2–4, decided by the turn, not by luck the
      // client could re-roll.
      const breed = breedOf(monster.kind);
      const hit = 2 + Math.floor(noise(now, delver.id, monster.id) * 3);
      const left = monster.hp - hit;
      if (left <= 0) {
        db.query("UPDATE monster SET hp = 0, dead_until = ?2, cell = spawn WHERE id = ?1").run(
          monster.id,
          now + 150,
        );
        delver = { ...delver, gold: delver.gold + breed.gold };
        log.push(`You put the ${monster.kind} down. ${breed.gold} gold.`);
      } else {
        db.query("UPDATE monster SET hp = ?2 WHERE id = ?1").run(monster.id, left);
        log.push(`You hit the ${monster.kind} for ${hit}.`);
      }
    } else if (!walkable(floor.tiles[target])) {
      log.push("Stone.");
    } else {
      delver = { ...delver, cell: target };
      // A cache pays out once, then refills slowly — so a floor someone
      // stripped an hour ago is worth walking again tomorrow.
      if (cacheCells(floor).includes(target)) {
        const taken = db
          .query<{ until_turn: number }, [number, number]>(
            "SELECT until_turn FROM cache_taken WHERE depth = ?1 AND cell = ?2",
          )
          .get(delver.depth, target);
        if (!taken || taken.until_turn <= now) {
          const coin = 4 + Math.floor(noise(delver.depth, target, 17) * 9);
          db.query(
            `INSERT INTO cache_taken (depth, cell, until_turn) VALUES (?1, ?2, ?3)
             ON CONFLICT (depth, cell) DO UPDATE SET until_turn = excluded.until_turn`,
          ).run(delver.depth, target, now + 400);
          delver = { ...delver, gold: delver.gold + coin };
          log.push(`A cache of ${coin} gold, tucked into the wall.`);
        }
      }
      const under = floor.tiles[target];
      if (under === ">") log.push("A stair down, here.");
      else if (under === "<")
        log.push(delver.depth === 1 ? "The way out, here. Climb and the gold is yours." : "A stair up, here.");
      const watchedNow = store
        .monstersOn(db, delver.depth, now)
        .some((m) => distance(m.cell, target) <= LANTERN && seesFrom(floor, target, m.cell));
      if (watchedNow && !watchedBefore) log.push("Something moves at the edge of your lantern.");
      const grave = store.graveAt(db, delver.depth, target);
      if (grave && grave.looted === 0) {
        const share = Math.floor(grave.gold / 2);
        db.query("UPDATE grave SET looted = 1 WHERE id = ?1").run(grave.id);
        if (share > 0) delver = { ...delver, gold: delver.gold + share };
        log.push(`${grave.epitaph}${share > 0 ? ` You take ${share} of their gold.` : ""}`);
      } else if (grave) {
        log.push(grave.epitaph);
      }
    }
  } else {
    // Waiting is the only medicine. It works when nothing can see you, which
    // makes retreating into a cleared room a real decision rather than a
    // pause — every turn spent resting is a turn the floor keeps moving.
    const monsters = store.monstersOn(db, delver.depth, now);
    const watched = monsters.some(
      (m) => distance(m.cell, delver.cell) <= 6 && seesFrom(floor, m.cell, delver.cell),
    );
    if (watched) log.push("You wait. Something is still moving out there.");
    else if (delver.hp < delver.max_hp) {
      delver = { ...delver, hp: Math.min(delver.max_hp, delver.hp + 1) };
      log.push(`You catch your breath. ${delver.hp} of ${delver.max_hp}.`);
    } else log.push("You wait, and listen. Nothing comes.");
  }

  if (!climbedOut) {
    delver = monsterTurn(db, delver, now, log);
    if (delver.hp <= 0) delver = die(db, delver, log);
    store.markSeen(db, delver.depth, visibleFrom(floorAt(delver.depth), delver.cell));
  }
  store.saveDelver(db, delver);
  // Dated by the delver's own turn, so the screen can tell what happened
  // *this* turn from what it is still remembering.
  store.say(db, delver.id, delver.turns, log);
  return { delver, log, died: delver.state === "dead", climbedOut };
}

/** What the delver can see right now, and what the dungeon remembers. */
export interface View {
  floor: Floor;
  visible: Set<number>;
  seen: Set<number>;
  monsters: Monster[];
  graves: Map<number, string>;
  others: Map<number, string>;
}

export function viewFor(db: Database, delver: Delver): View {
  const floor = floorAt(delver.depth);
  const now = store.turn(db);
  const visible = new Set(visibleFrom(floor, delver.cell, LANTERN));
  const graves = new Map<number, string>();
  for (const grave of store.gravesOn(db, delver.depth)) graves.set(grave.cell, grave.name);
  const others = new Map<number, string>();
  for (const other of store.delversOn(db, delver.depth))
    if (other.id !== delver.id) others.set(other.cell, other.name);
  return {
    floor,
    visible,
    seen: store.seenOn(db, delver.depth),
    monsters: store.monstersOn(db, delver.depth, now).filter((m) => visible.has(m.cell)),
    graves,
    others,
  };
}

export { DEPTHS, LANTERN };