// Ce que l'interface propose au joueur, sur le vrai moteur WebAssembly : les
// demi-coups possibles (mis en évidence quand il touche un pion) et le
// plateau affiché pendant la saisie d'un coup.
//
// Copyright (C) 2026 les auteurs d'Ustagammon.
// Licence : GPLv3 ou ultérieure (voir LICENSE).

import assert from "node:assert/strict";
import { test } from "node:test";
import { Game } from "../src/domain/game/game.js";
import { formatHalfMoves, type HalfMove } from "../src/domain/game/position.js";
import { fixedDice } from "../src/domain/game/roll.js";
import { loadNodeEngine } from "./support/node-engine.js";

// Le joueur, au trait, n'a plus que deux pions, sur ses cases 6 et 5
// (même position que dans les étapes du scénario).
const PLAYER_ALMOST_DONE = "/38AAABQAAAAAA";

/** Les demi-coups en notation, triés : « 13/10 13/12… ». */
function text(halfMoves: readonly HalfMove[]): string {
    return halfMoves
        .map((h) => formatHalfMoves([h]))
        .sort()
        .join(" ");
}

test("au départ avec 3-1 : chaque pion jouable, avec chaque dé", async () => {
    const engine = await loadNodeEngine();
    const game = Game.start(engine, { dice: fixedDice([3, 1]) });
    assert.equal(text(await game.nextHalfMoves()), "13/10 24/21 24/23 6/3 6/5 8/5 8/7");
    // 13/12 manque : votre case 12 est tenue par l'ordinateur. Après 8/5,
    // il ne reste que le 1.
    assert.equal(await game.playHalfMove({ from: 8, to: 5 }), true);
    assert.equal(text(await game.nextHalfMoves()), "24/23 5/4 6/5 8/7");
});

test("en fin de partie, les demi-coups vers la sortie viennent du moteur", async () => {
    const engine = await loadNodeEngine();
    const game = Game.start(engine, {
        dice: fixedDice([6, 5]),
        setup: { position: PLAYER_ALMOST_DONE, firstTurn: "player" },
    });
    await game.roll();
    assert.equal(text(await game.nextHalfMoves()), "5/off 6/1 6/off");
});

test("hors du tour de jeu du joueur, rien n'est proposé", async () => {
    const engine = await loadNodeEngine();
    const game = Game.start(engine, { dice: fixedDice([1, 3]) });
    assert.equal(game.state.turn, "computer");
    assert.deepEqual(await game.nextHalfMoves(), []);
});

test("le plateau affiché suit les demi-coups saisis", async () => {
    const engine = await loadNodeEngine();
    const game = Game.start(engine, { dice: fixedDice([3, 1]) });
    const before = await game.displayedBoard();
    assert.equal(before.player.points[7], 3);
    assert.equal(before.computer.points[23], 2);
    await game.playHalfMove({ from: 8, to: 5 });
    const after = await game.displayedBoard();
    assert.equal(after.player.points[7], 2);
    assert.equal(after.player.points[4], 1);
    assert.equal(after.player.pipCount, before.player.pipCount - 3);
});