// L'analyse de partie (étape 1e) : les tours, le format durable de
// l'analyse et sa migration, les chiffres du bilan à la manière de gnubg,
// et une partie complète analysée par le vrai moteur.
//
// 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 {
    chanceCurve,
    gameTurns,
    levelOfErrorRate,
    luckRatingOf,
    mainAdvice,
    missingAnalyses,
    readyForSummary,
    replayPoint,
    runAnalysis,
    summarizeAnalysis,
} from "../src/domain/analysis/game-analysis.js";
import { ADVICE_VERSION, type Advice, type CubeAdvice } from "../src/domain/game/advice.js";
import type { Engine } from "../src/domain/game/engine.js";
import {
    appendEvent,
    EMPTY_JOURNAL,
    type GameJournal,
    migrateJournal,
    type NewGameEvent,
    withAnalysesOf,
} from "../src/domain/game/events.js";
import { Game } from "../src/domain/game/game.js";
import { START_POSITION } from "../src/domain/game/position.js";
import { emptyReview, REVIEW_VERSION } from "../src/domain/game/review.js";
import { loadNodeEngine } from "./support/node-engine.js";
import { playToTheEnd, seededDice } from "./support/play.js";

/** Un journal fait d'événements donnés, à la suite. */
function journalOf(events: readonly NewGameEvent[]): GameJournal {
    return events.reduce(appendEvent, EMPTY_JOURNAL);
}

const START: NewGameEvent = {
    type: "GameStarted",
    position: START_POSITION,
    cube: { value: 1, owner: null },
    firstTurn: null,
};
const P = START_POSITION;

/** Une petite partie : ouverture (égalité puis 3-1 pour le joueur), un
 * coup de chaque camp, puis le joueur double et l'ordinateur passe. */
const SHORT: NewGameEvent[] = [
    START,
    { type: "DiceRolled", side: null, roll: [2, 2] },
    { type: "DiceRolled", side: null, roll: [3, 1] },
    { type: "MovePlayed", side: "player", halfMoves: [{ from: 8, to: 5 }], position: P },
    { type: "DiceRolled", side: "computer", roll: [6, 5] },
    { type: "MovePlayed", side: "computer", halfMoves: [{ from: 24, to: 13 }], position: P },
    { type: "CubeOffered", side: "player" },
    { type: "CubeDropped", side: "computer" },
    { type: "GameEnded", winner: "player", kind: "single", points: 1 },
];

test("les tours d'une partie : ouverture, coups, double passé", () => {
    const journal = journalOf(SHORT);
    const turns = gameTurns(journal);
    assert.deepEqual(
        turns.map((t) => [t.number, t.side, t.roll, t.move?.id ?? null, t.end?.id ?? null]),
        [
            [1, "player", [3, 1], "4", null],
            [2, "computer", [6, 5], "6", null],
            [3, "player", null, null, "9"],
        ],
    );
    // L'égalité d'ouverture appartient au premier tour.
    assert.deepEqual(
        turns[0]?.events.map((e) => e.id),
        ["2", "3", "4"],
    );
    // Le jet d'ouverture qui désigne le joueur a une chance, l'égalité non.
    const luck = missingAnalyses(journal).filter((t) => t.kind === "luck");
    assert.deepEqual(
        luck.map((t) => t.eventId),
        ["3", "5"],
    );
});

/** Un conseil fictif sur un coup du joueur. */
function moveAdvice(eventId: string, equityLoss: number, moveCount = 10): Advice {
    const move = { notation: "8/5", halfMoves: [], equity: 0, ply: 2 };
    return {
        version: ADVICE_VERSION,
        kind: "move",
        eventId,
        ply: 2,
        position: P,
        roll: [3, 1],
        opening: true,
        moveCount,
        rank: equityLoss === 0 ? 1 : 2,
        played: move,
        best: move,
        playedFacts: { hits: 0, madePoints: [] },
        bestFacts: { hits: 0, madePoints: [] },
        ranking: [],
        equityLoss,
        skill:
            equityLoss < -0.12
                ? "veryBad"
                : equityLoss < -0.06
                  ? "bad"
                  : equityLoss < -0.03
                    ? "doubtful"
                    : "none",
    };
}

function cubeAdvice(eventId: string, action: CubeAdvice["action"], equityLoss: number): Advice {
    return {
        version: ADVICE_VERSION,
        kind: "cube",
        eventId,
        ply: 2,
        action,
        position: P,
        equities: { noDouble: 0.5, doubleTake: 0.6, doublePass: 1, optimal: 0.6 },
        equityLoss,
        skill: equityLoss < -0.06 ? "bad" : "none",
    };
}

test("le taux d'erreur, le niveau et la chance à la manière de gnubg", () => {
    // arThrsRating de gnubg : 0,032, 0,020, 0,013, 0,008, 0,005 ; les six
    // classements de gnubg prennent, dans l'ordre, les noms des six niveaux
    // de l'ordinateur (Advanced de gnubg : Intermédiaire).
    assert.equal(levelOfErrorRate(0.05), "beginner");
    assert.equal(levelOfErrorRate(0.032), "beginner");
    assert.equal(levelOfErrorRate(0.031), "amateur");
    assert.equal(levelOfErrorRate(0.015), "intermediate");
    assert.equal(levelOfErrorRate(0.01), "advanced");
    assert.equal(levelOfErrorRate(0.006), "expert");
    assert.equal(levelOfErrorRate(0.001), "champion");
    // getLuckRating : chance par tour × 10, seuils 0,3 et 0,6.
    assert.equal(luckRatingOf(0.07), "veryLucky");
    assert.equal(luckRatingOf(0.04), "lucky");
    assert.equal(luckRatingOf(0.02), "none");
    assert.equal(luckRatingOf(-0.04), "unlucky");
    assert.equal(luckRatingOf(-0.07), "veryUnlucky");

    const base = journalOf(SHORT);
    const journal: GameJournal = {
        ...base,
        advice: {
            "4": moveAdvice("4", -0.08),
            "7": cubeAdvice("7", "double", 0),
        },
        review: {
            ...emptyReview(2),
            luck: {
                "3": { value: 0.2, rating: "none" },
                "5": { value: -0.1, rating: "none" },
            },
            computer: { "6": moveAdvice("6", 0) },
        },
    };
    assert.ok(readyForSummary(journal));
    const summary = summarizeAnalysis(journal);
    // Un coup non forcé (0,08) et un double (compté toujours) : 0,04 par
    // décision.
    assert.equal(summary.player.errorRate.decisions, 2);
    assert.ok(Math.abs(summary.player.errorRate.perDecision - 0.04) < 1e-9);
    assert.equal(summary.player.errorRate.level, "beginner");
    assert.deepEqual(summary.counts, { good: 1, doubtful: 0, bad: 1, veryBad: 0 });
    assert.equal(summary.toReview?.advice.eventId, "4");
    assert.equal(summary.toReview?.turn, 1);
    // Une seule fois la main pour chacun : chance par tour égale au total.
    assert.equal(summary.player.luck.rolls, 1);
    assert.equal(summary.player.luck.rating, "veryLucky");
    assert.equal(summary.computer.luck.rating, "veryUnlucky");
    // Gagné 1 point, avec 0,2 de chance contre −0,1 pour l'ordinateur :
    // 1 − 0,2 − 0,1.
    assert.equal(summary.result, 1);
    assert.ok(Math.abs(summary.luckAdjustedResult - 0.7) < 1e-9);
    // Rejouer le premier tour : juste avant le coup, avec le même jet.
    const first = gameTurns(journal)[0];
    assert.ok(first !== undefined);
    assert.equal(mainAdvice(journal, first)?.eventId, "4");
    assert.equal(replayPoint(journal, first), "3");
    // La courbe : le dernier tour finit la partie, gagnée.
    assert.deepEqual(
        chanceCurve(journal).map((p) => [p.turn, p.chance, p.verdict]),
        [
            [1, null, "bad"],
            [2, null, null],
            [3, 1, "good"],
        ],
    );
});

test("un jet sans doubler ne compte que si la décision est serrée (isCloseCubedecision)", () => {
    const base = journalOf([
        { ...START, firstTurn: "player" },
        { type: "DiceRolled", side: "player", roll: [3, 1] },
    ]);
    const noDouble = (equities: CubeAdvice["equities"]): GameJournal => ({
        ...base,
        advice: { "2": { ...(cubeAdvice("2", "noDouble", 0) as CubeAdvice), equities } },
    });
    // Doubler coûterait 0,2 par rapport à l'optimum : pas serré.
    const far = noDouble({ noDouble: 0.5, doubleTake: 0.3, doublePass: 1, optimal: 0.5 });
    assert.equal(summarizeAnalysis(far).player.errorRate.decisions, 0);
    // Doubler est l'optimum : serré, compté.
    const close = noDouble({ noDouble: 0.5, doubleTake: 0.6, doublePass: 1, optimal: 0.6 });
    assert.equal(summarizeAnalysis(close).player.errorRate.decisions, 1);
    // Un bon jet sans doubler n'est pas une décision visible du bilan.
    assert.deepEqual(summarizeAnalysis(close).counts, {
        good: 0,
        doubtful: 0,
        bad: 0,
        veryBad: 0,
    });
});

test("l'analyse de partie enregistrée : migration du format durable", () => {
    const journal = journalOf(SHORT);
    const review = {
        ...emptyReview(2),
        luck: { "3": { value: 0.1, rating: "none" as const } },
        winChances: { "4": 0.55, "99": 0.5 },
        unanalysed: ["5", "98"],
    };
    // Un journal d'avant l'étape 1e se reprend tel quel.
    assert.equal(migrateJournal(journal), journal);
    // Les entrées rattachées à un événement absent sont oubliées.
    const migrated = migrateJournal({ ...journal, review });
    assert.deepEqual(migrated.review?.winChances, { "4": 0.55 });
    assert.deepEqual(migrated.review?.unanalysed, ["5"]);
    assert.deepEqual(migrated.review?.luck, review.luck);
    // Une analyse complète et connue ne change pas.
    const clean = { ...journal, review: migrated.review };
    assert.equal(migrateJournal(clean), clean);
    // Une autre version, ou une analyse mal formée, est oubliée.
    const other = migrateJournal({ ...journal, review: { ...review, version: REVIEW_VERSION + 1 } });
    assert.equal(other.review, undefined);
    const broken = { ...journal, review: { version: REVIEW_VERSION } } as unknown as GameJournal;
    assert.equal(migrateJournal(broken).review, undefined);
    // Les analyses d'une copie s'ajoutent au journal sans toucher aux
    // conseils déjà là.
    const live: GameJournal = { ...journal, advice: { "4": moveAdvice("4", 0) } };
    const copy: GameJournal = {
        ...journal,
        advice: { "4": moveAdvice("4", -0.5), "7": cubeAdvice("7", "double", 0) },
        review,
    };
    const merged = withAnalysesOf(live, copy);
    assert.equal(merged.advice?.["4"]?.equityLoss, 0);
    assert.ok(merged.advice?.["7"] !== undefined);
    assert.equal(merged.review, review);
});

/** Toutes les analyses qui manquent, une à une. */
async function analyseAll(engine: Engine, journal: GameJournal): Promise<GameJournal> {
    let current = journal;
    for (let i = 0; i < 500; i++) {
        const next = missingAnalyses(current)[0];
        if (next === undefined) {
            return current;
        }
        current = await runAnalysis(engine, current, next);
    }
    throw new Error("l'analyse ne finit pas");
}

test("une partie complète analysée par le moteur, comme une partie d'avant 1d", async () => {
    const engine = await loadNodeEngine();
    // Une course courte (tests/reference/positions.json, race-1).
    const game = Game.start(engine, {
        setup: { position: "trsXAADs7mwAAA", firstTurn: "player" },
        level: "2ply",
        dice: seededDice(7),
    });
    await playToTheEnd(game, engine, 1);
    // Aucun conseil n'a été rangé pendant la partie (comme avant l'étape
    // 1d) : tout est à analyser.
    assert.equal(game.journal.advice, undefined);
    assert.ok(!readyForSummary(game.journal));
    const analysed = await analyseAll(engine, game.journal);
    assert.ok(readyForSummary(analysed));
    assert.deepEqual(missingAnalyses(analysed), []);

    const summary = summarizeAnalysis(analysed);
    const advices = Object.values(analysed.advice ?? {});
    assert.ok(advices.length > 0);
    // Le coup à revoir est la plus grosse perte d'équité du joueur, s'il en
    // a une.
    const worst = advices
        .filter((a) => a.skill !== "none")
        .reduce<Advice | null>((w, a) => (w === null || a.equityLoss < w.equityLoss ? a : w), null);
    assert.equal(summary.toReview?.advice.eventId, worst?.eventId);
    // La chance de chaque tour d'un camp est comptée.
    const moves = game.events.filter((e) => e.type === "MovePlayed");
    assert.equal(
        summary.player.luck.rolls + summary.computer.luck.rolls,
        moves.length,
    );
    // Les chances de gagner sont des probabilités, et la courbe finit sur
    // le résultat.
    const curve = chanceCurve(analysed);
    assert.ok(curve.every((p) => p.chance !== null && p.chance >= 0 && p.chance <= 1));
    const won = game.state.result?.winner === "player";
    assert.equal(curve.at(-1)?.chance, won ? 1 : 0);
    // Les coups de l'ordinateur sont analysés aussi.
    assert.ok(Object.keys(analysed.review?.computer ?? {}).length > 0);
    // Le journal analysé se reprend : l'analyse fait partie du format.
    const resumed = Game.resume(engine, JSON.parse(JSON.stringify(analysed)));
    assert.deepEqual(resumed.journal.review, analysed.review);
});