// Checks the chess page (web/static/chess): the rules helpers, the UCI lines it sends, and the real Stockfish file answering them.
//   node tests/chess/game_test.mjs
import fs from 'node:fs';
import { spawn } from 'node:child_process';
import { pathToFileURL, fileURLToPath } from 'node:url';
import path from 'node:path';

const root = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'web', 'static', 'chess');
const g = await import(pathToFileURL(path.join(root, 'game.js')).href);
let failed = 0;
const ok = (n, v) => { console.log(v ? 'ok  ' : 'FAIL', n); if (!v) failed++; };

// ---- the page ----
const html = fs.readFileSync(path.join(root, 'index.html'), 'utf8');
const script = html.match(/<script type="module">([\s\S]*?)<\/script>/)[1];
const imported = script.match(/import \{([^}]*)\} from '\.\/game\.js'/)[1].split(',').map(s => s.trim());
ok('the page only imports what game.js exports', imported.length > 5 && imported.every(n => n in g));
const ids = [...script.matchAll(/\$\('([a-zA-Z]+)'\)/g)].map(m => m[1]);
ok('every element the page script uses exists', [...new Set(ids)].every(id => html.includes('id="' + id + '"')));
ok('the page carries the cube and a favicon', html.includes('<polygon points="16,3 28,10 16,17 4,10" fill="#8fe8b8"/>') && /rel="icon"/.test(html));
ok('the engine files are next to the page', ['stockfish-19-lite-single.js', 'stockfish-19-lite-single.wasm', 'chess.js', 'COPYING-stockfish.txt'].every(f => fs.existsSync(path.join(root, f))));
ok('the licence of the engine is linked from the page', html.includes('COPYING-stockfish.txt') && /GPL/.test(html));

// ---- levels and UCI ----
ok('seven levels, weakest first', g.LEVELS.length === 7 && g.LEVELS.every((l, i) => l.id === i + 1));
ok('an unknown level falls back to a middle one', g.level('x').id === 3 && g.level(7).id === 7);
const casual = g.strengthLines(g.level(3));
ok('a strength-limited level sets the limiter and the Elo', casual[0] === 'setoption name UCI_LimitStrength value true' && casual[1] === 'setoption name UCI_Elo value 1400');
ok('the top level and the hint switch the limiter off', g.strengthLines(g.level(7))[0].endsWith('false') && g.strengthLines(g.HINT)[0].endsWith('false') && g.strengthLines(g.HINT).pop().endsWith('20'));
ok('the lowest level plays at skill 0 with a one-ply search', g.strengthLines(g.level(1)).includes('setoption name Skill Level value 0') && g.goLine(g.level(1)) === 'go depth 1');
ok('the Elo of every limited level is inside what Stockfish accepts', g.LEVELS.filter(l => l.limit).every(l => l.limit >= 1320 && l.limit <= 3190));
ok('moves are parsed', JSON.stringify(g.parseUci('e2e4')) === '{"from":"e2","to":"e4"}' && g.parseUci('e7e8q').promotion === 'q' && g.parseUci('(none)') === null && g.parseUci('') === null);

// ---- the board ----
const c = new g.Chess();
const sq = g.squares(c, false);
ok('64 squares, a8 first and h1 last for white', sq.length === 64 && sq[0].sq === 'a8' && sq[63].sq === 'h1' && sq[0].piece.type === 'r' && sq[0].piece.color === 'b');
ok('flipped, h1 comes first', g.squares(c, true)[0].sq === 'h1' && g.squares(c, true)[63].sq === 'a8');
ok('a1 is a dark square', sq.find(s => s.sq === 'a1').dark && !sq.find(s => s.sq === 'h1').dark);
ok('pieces use the text presentation of the glyph', g.glyph('p').endsWith('︎') && g.glyph('k').startsWith('♚'));
const t = g.targets(c, 'e2');
ok('a pawn can go one or two squares', t.map(x => x.to).sort().join() === 'e3,e4');
ok('a piece that cannot move has no targets', g.targets(c, 'a1').length === 0);
ok('an illegal move is refused, a legal one made', g.tryMove(c, 'e2', 'e5') === null && g.tryMove(c, 'e2', 'e4').san === 'e4');
const promo = new g.Chess('8/P7/8/8/8/8/k6K/8 w - - 0 1');
ok('a promotion square is marked, and the piece defaults to a queen', g.targets(promo, 'a7')[0].promotion === true && g.tryMove(promo, 'a7', 'a8').promotion === 'q');
const under = new g.Chess('8/P7/8/8/8/8/k6K/8 w - - 0 1');
ok('an under-promotion works', g.tryMove(under, 'a7', 'a8', 'n').promotion === 'n');
const cap = new g.Chess('4k3/8/8/3p4/4P3/8/8/4K3 w - - 0 1');
ok('a capture is marked', g.targets(cap, 'e4').find(x => x.to === 'd5').capture === true);

// ---- the state of the game ----
const fool = new g.Chess();
['f3', 'e5', 'g4', 'Qh4#'].forEach(m => fool.move(m));
ok('checkmate: black wins', JSON.stringify(g.status(fool)) === '{"over":true,"key":"mate","winner":"b"}');
ok('stalemate', g.status(new g.Chess('7k/5Q2/6K1/8/8/8/8/8 b - - 0 1')).key === 'stalemate');
ok('not enough pieces', g.status(new g.Chess('8/8/4k3/8/8/3K4/8/8 w - - 0 1')).key === 'material');
ok('check is reported while the game goes on', g.status(new g.Chess('4k3/8/8/8/8/8/4r3/4K3 w - - 0 1')).key === 'check');
ok('a new game: white to move', JSON.stringify(g.status(new g.Chess())) === '{"over":false,"key":"turn","turn":"w"}');
const rep = new g.Chess();
['Nf3', 'Nf6', 'Ng1', 'Ng8', 'Nf3', 'Nf6', 'Ng1', 'Ng8'].forEach(m => rep.move(m));
ok('three times the same position is a draw', g.status(rep).key === 'repetition');
const mv = new g.Chess(); ['e4', 'e5', 'Nf3'].forEach(m => mv.move(m));
ok('the move list is in pairs', JSON.stringify(g.moveRows(mv)) === '[[1,"e4","e5"],[2,"Nf3",""]]');

// ---- taking moves back ----
const u = new g.Chess(); ['e4', 'e5'].forEach(m => u.move(m));
ok('on the player\'s turn two moves go', g.undoMove(u, 'w') === 2 && u.history().length === 0);
const u2 = new g.Chess(); ['e4'].forEach(m => u2.move(m));
ok('while the engine thinks only the player\'s move goes', g.undoMove(u2, 'w') === 1 && u2.turn() === 'w');
const u3 = new g.Chess(); u3.move('e4');
ok('a black player who takes back everything leaves the engine to move', g.undoMove(u3, 'b') === 1 && u3.turn() === 'w' && u3.history().length === 0);
ok('nothing to take back', g.undoMove(new g.Chess(), 'w') === 0);

// ---- the real engine ----
const sf = spawn(process.execPath, [path.join(root, 'stockfish-19-lite-single.js')], { stdio: ['pipe', 'pipe', 'ignore'] });
let buf = '';
const waiters = [];
sf.stdout.on('data', d => {
  buf += d;
  let i;
  while ((i = buf.indexOf('\n')) >= 0) { const line = buf.slice(0, i).trim(); buf = buf.slice(i + 1); waiters.splice(0).forEach(w => w(line)); }
});
const lines = [];
const send = s => sf.stdin.write(s + '\n');
const until = (pred, ms = 15000) => new Promise((res, rej) => {
  const to = setTimeout(() => rej(new Error('engine timeout')), ms);
  const on = line => { lines.push(line); if (pred(line)) { clearTimeout(to); res(line); } else waiters.push(on); };
  waiters.push(on);
});
async function bestmove(fen, lv) {
  g.strengthLines(lv).forEach(send);
  send('position fen ' + fen);
  const p = until(l => l.startsWith('bestmove'));
  send(g.goLine(lv));
  return (await p).split(' ')[1];
}
try {
  const ready = until(l => l === 'readyok');
  send('uci'); send('isready');
  await ready;
  ok('the engine says it is ready', true);
  ok('it knows the options the page sets', lines.some(l => l.includes('UCI_Elo')) && lines.some(l => l.includes('Skill Level')) && lines.some(l => l.includes('UCI_LimitStrength')));

  // mate in one: the strongest level must find it
  const mateFen = '6k1/5ppp/8/8/8/8/5PPP/R5K1 w - - 0 1';
  ok('the top level finds mate in one (Ra8#)', await bestmove(mateFen, g.level(7)) === 'a1a8');

  // a whole game of the engine against the rules helper: every move it makes must be legal, at every level
  for (const lv of g.LEVELS) {
    const game = new g.Chess();
    let legal = true, plies = 0;
    while (!g.status(game).over && plies < 16) {
      const mvs = game.moves({ verbose: true });
      if (plies % 2 === 0) { const m = mvs[Math.floor(Math.random() * mvs.length)]; game.move(m); }
      else {
        const u = g.parseUci(await bestmove(game.fen(), lv));
        if (!u || !g.tryMove(game, u.from, u.to, u.promotion)) { legal = false; break; }
      }
      plies++;
    }
    ok('level ' + lv.id + ' (' + lv.name.en + ') only plays legal moves against a random player', legal);
  }
} catch (e) {
  ok('the engine answered: ' + e.message, false);
} finally {
  send('quit'); sf.kill();
}
process.exit(failed ? 1 : 0);