import { readdirSync } from 'node:fs';
import { GAME_DIR } from './paths';
import type { Difficulty } from './menu';

/**
 * The saved games, read off disk rather than out of the game.
 *
 * Minesweeper X names a recording `<Lvl> <seconds> - <date> <time>[ (Lost)].mvr` and keeps no index, so
 * the filename IS the metadata. That is fine here — it is the game's own format, not one we chose, and
 * parsing it beats the alternative of a sidecar database that has to be kept in step with a directory
 * the game writes to behind our back.
 *
 * A name that does not parse is skipped rather than guessed at. Something the user dropped in the folder
 * by hand should not appear in a ranked list with an invented time.
 */

const LEVELS: Record<string, Difficulty> = { Beg: 'beginner', Int: 'intermediate', Exp: 'expert' };

/** `Exp 58.63 - Feb 4 2026 00.16.29 AM.mvr`, with an optional ` (Lost)` before the extension. */
const NAME = /^(Beg|Int|Exp) (\d+(?:\.\d+)?) - (.+?)( \(Lost\))?\.mvr$/;

export type Replay = {
  /** The filename, which is also the id. Never built by the client — see the guard in `index.ts`. */
  file: string;
  level: Difficulty;
  /** Seconds, as the game recorded them. */
  time: number;
  /** The game's own date string, kept verbatim rather than parsed into something with a timezone. */
  played: string;
  lost: boolean;
};

export function listReplays(level?: Difficulty): Replay[] {
  let names: string[];
  try {
    names = readdirSync(GAME_DIR);
  } catch {
    return []; // no prefix yet, which is the same answer as no replays
  }

  const replays: Replay[] = [];
  for (const file of names) {
    const match = NAME.exec(file);
    if (!match) continue;
    const parsed = LEVELS[match[1]!];
    if (!parsed || (level && parsed !== level)) continue;
    replays.push({ file, level: parsed, time: Number(match[2]), played: match[3]!, lost: !!match[4] });
  }

  // Best first, and a loss is never "best" however short it was — a 0.32s loss is a misclick, not a
  // record. So wins rank by time and losses fall to the end, most recent first, still watchable.
  return replays.sort((a, b) => {
    if (a.lost !== b.lost) return a.lost ? 1 : -1;
    if (a.lost) return b.played.localeCompare(a.played);
    return a.time - b.time;
  });
}

/** Whether a name is a replay this directory actually holds. The only way a client-supplied name is used. */
export const isKnownReplay = (file: unknown): file is string =>
  typeof file === 'string' && listReplays().some((r) => r.file === file);