/**
 * val, in a terminal. The forge runs this on a pty when somebody ssh-es to
 * the app; it takes a seat over the same socket the browser uses, so what a
 * person can do on the page they can do here: walk, shoot, cast, plant,
 * defuse and buy.
 *
 * The map is the same grid, one character a tile. Plain ANSI, no dependencies.
 */

import { choosePrompt, REACH } from "../static/prompt.js";

const base =
  process.env.VAL_URL ??
  (process.env.PORT ? `http://127.0.0.1:${process.env.PORT}` : undefined) ??
  process.env.FORGE_APP_URL ??
  "http://127.0.0.1:8080";

const esc = "\x1b[";
const out = (s: string): void => void process.stdout.write(s);

type Snapshot = {
  phase: string;
  clock: number;
  round: number;
  score: { red: number; blue: number };
  attackers: string;
  result: string | null;
  me: Record<string, any>;
  players: Record<string, any>[];
  zones: { k: string; x: number; y: number; r: number }[];
  spike: { planted: boolean; fuse: number; defuse: number; x: number | null; y: number | null };
  board: Record<string, any>[];
  events: string[];
};

let map: { rows: string[]; tile: number } | null = null;
let snap: Snapshot | null = null;
let socket: WebSocket | null = null;
let status = "connecting";
let aim = -Math.PI / 2;
let move = { mx: 0, my: 0, until: 0 };
let firing = 0;
let helping = false;
let using = 0;
let buying = false;

const send = (message: unknown): void => {
  if (socket && socket.readyState === 1) socket.send(JSON.stringify(message));
};

async function connect(): Promise<void> {
  try {
    const page = await fetch(base + "/");
    const cookie = (page.headers.get("set-cookie") ?? "").split(";")[0] ?? "";
    map = (await (await fetch(base + "/map.json")).json()) as { rows: string[]; tile: number };
    const ws = new WebSocket(base.replace(/^http/, "ws") + "/ws", {
      headers: { cookie, origin: new URL(base).origin },
    } as unknown as string[]);
    socket = ws;
    ws.onopen = () => (status = "live");
    ws.onclose = () => {
      status = "reconnecting";
      socket = null;
      setTimeout(connect, 2000);
    };
    ws.onmessage = (event) => {
      const next = JSON.parse(String(event.data)) as Snapshot;
      // The scoreboard comes only when it changes; keep the last one otherwise.
      if (next.board === undefined) next.board = snap?.board ?? [];
      snap = next;
    };
  } catch (error) {
    status = `cannot reach ${base}`;
    setTimeout(connect, 3000);
  }
}

const colour = (s: string, code: number): string => `${esc}${code}m${s}${esc}0m`;

/** The same line the page shows, from the same function. */
function prompt(s: Snapshot): string {
  const row = map ? map.rows[Math.floor(s.me.y / map.tile)] : "";
  const cell = row ? row[Math.floor(s.me.x / map.tile)] : "";
  return choosePrompt(s, {
    input: "keys",
    onSite: cell === "A" || cell === "B",
    nearSpike:
      s.spike.x !== null && s.spike.y !== null && Math.hypot(s.spike.x - s.me.x, s.spike.y - s.me.y) < REACH,
  });
}

const HOW_TO = [
  "How to play — attackers carry the spike to site A or B and plant it (hold f);",
  "defenders stop them, or hold f on a planted spike to defuse it. 45s fuse, first to 13.",
  "· wasd walks, ←/→ turns the aim, space fires, r reloads",
  "· c q e x cast the kit: c and q are bought in the buy phase, e is free on a cooldown, x is the ultimate",
  "· b opens the buy — the same prices the page charges, refused server-side if you cannot afford them",
  "· A and B on the map are the sites, @ is you, cyan is a team mate, red is an enemy you can see",
  "h closes this.",
];

function draw(): void {
  if (!map) {
    out(`${esc}2J${esc}Hval — ${status}\r\n`);
    return;
  }
  const rows = map.rows.map((row) => row.split("").map((c) => (c === "#" ? colour("▓", 90) : c === "A" || c === "B" ? colour(c, 33) : c === "a" || c === "d" ? colour("·", 90) : " ")));
  const put = (x: number, y: number, ch: string): void => {
    const col = Math.floor(x / map!.tile);
    const row = Math.floor(y / map!.tile);
    if (rows[row] && rows[row]![col] !== undefined) rows[row]![col] = ch;
  };

  const lines: string[] = [];
  if (snap) {
    for (const zone of snap.zones) put(zone.x, zone.y, colour(zone.k === "smoke" ? "▒" : zone.k === "molly" ? "≈" : zone.k === "wall" ? "█" : "*", zone.k === "molly" ? 31 : 37));
    if (snap.spike.x !== null && snap.spike.y !== null)
      put(snap.spike.x, snap.spike.y, colour(snap.spike.planted ? "◈" : "◇", 33));
    for (const player of snap.players) {
      if (!player.alive) continue;
      const mark = player.id === snap.me.id ? colour("@", 97) : colour(player.name[0] ?? "?", player.mate ? 36 : 31);
      put(player.x, player.y, mark);
    }
    const me = snap.me;
    const phase = snap.phase === "live" && snap.spike.planted ? `spike ${Math.ceil(snap.spike.fuse)}s` : snap.phase;
    lines.push(
      `${colour("val", 1)}  ${colour("red " + snap.score.red, 31)} — ${colour(snap.score.blue + " blue", 36)}  round ${snap.round}  ${phase} ${Math.ceil(snap.clock)}s  ${snap.attackers} attacking  [${status}]`,
    );
    lines.push(
      `${me.alive ? colour(`${me.hp}hp${me.armour ? "+" + me.armour : ""}`, 32) : colour("dead", 90)}  ${me.weapon} ${me.ammo}  ${me.credits}cr  ult ${me.ult}/${me.ultNeeds}  C${me.charges.c} Q${me.charges.q} E${me.charges.e}${me.spike ? colour("  SPIKE", 33) : ""}${me.blind > 0 ? colour("  BLIND", 97) : ""}  aim ${((aim * 180) / Math.PI).toFixed(0)}°`,
    );
    lines.push(colour("› " + prompt(snap), 93));
  } else lines.push(`val — ${status}`);
  lines.push("");
  for (const row of rows) lines.push(" " + row.join(""));
  lines.push("");
  if (snap) {
    for (const side of ["atk", "def"] as const) {
      const team = snap.board
        .filter((p) => p.side === side)
        .map((p) => `${p.alive ? "" : colour("✕", 90)}${p.name}${p.bot ? "" : "*"} ${p.kills}/${p.deaths}`)
        .join("  ");
      lines.push(colour(side === "atk" ? "atk " : "def ", side === "atk" ? 31 : 36) + team);
    }
    lines.push("");
    for (const event of snap.events.slice(0, 3)) lines.push(colour("· " + event, 90));
  }
  lines.push("");
  if (helping) for (const line of HOW_TO) lines.push(colour(line, 96));
  lines.push(
    buying
      ? colour("buy: 1 Classic 2 Ghost 3 Sheriff 4 Spectre 5 Phantom 6 Vandal 7 Operator · 8 light 9 heavy · c/q ability · b closes", 33)
      : colour("wasd move · ←/→ aim · space fire · f plant/defuse · c q e x cast · b buy · r reload · h how to play · q quit", 90),
  );
  out(`${esc}H${esc}J` + lines.join("\r\n"));
}

const BUYS: Record<string, string> = {
  "1": "classic", "2": "ghost", "3": "sheriff", "4": "spectre", "5": "phantom", "6": "vandal", "7": "operator",
  "8": "light", "9": "heavy",
};

process.stdin.setRawMode?.(true);
process.stdin.resume();
process.stdin.setEncoding("utf8");
process.stdin.on("data", (key: string) => {
  const now = Date.now();
  if (key === "\x03" || (key === "q" && !buying)) {
    out(`${esc}2J${esc}H`);
    process.exit(0);
  }
  if (buying) {
    if (BUYS[key]) send({ t: "buy", what: BUYS[key] });
    else if (key === "c" || key === "q") send({ t: "buy", what: key });
    else if (key === "b" || key === "\x1b") buying = false;
    return;
  }
  if (key === "b") return void (buying = true);
  if (key === "h" || key === "?") return void (helping = !helping);
  if (key === "w") move = { mx: move.mx, my: -1, until: now + 400 };
  if (key === "s") move = { mx: move.mx, my: 1, until: now + 400 };
  if (key === "a") move = { mx: -1, my: move.my, until: now + 400 };
  if (key === "d") move = { mx: 1, my: move.my, until: now + 400 };
  if (key === "\x1b[D") aim -= Math.PI / 12;
  if (key === "\x1b[C") aim += Math.PI / 12;
  if (key === "\x1b[A") move = { mx: move.mx, my: -1, until: now + 400 };
  if (key === "\x1b[B") move = { mx: move.mx, my: 1, until: now + 400 };
  if (key === " ") firing = now + 220;
  if (key === "f") using = now + 700;
  if (key === "r") send({ t: "i", r: true });
  if (key === "c" || key === "e" || key === "x") send({ t: "i", c: key });
});

// Twenty times a second, the same intent the browser sends.
setInterval(() => {
  const now = Date.now();
  if (now > move.until) move = { mx: 0, my: 0, until: 0 };
  send({ t: "i", mx: move.mx, my: move.my, a: aim, f: firing > now, u: using > now, r: false });
}, 50);
setInterval(draw, 120);
process.stdout.on("resize", draw);

out(`${esc}2J`);
draw();
void connect();