// Point d'entrée de l'application dans le navigateur (index.html) : le seul
// endroit qui assemble le domaine, le moteur, le stockage et l'interface
// (ADR 0007, vérifié par dependency-cruiser).
//
// Copyright (C) 2026 les auteurs d'Ustagammon.
// Licence : GPLv3 ou ultérieure (voir LICENSE).

import { Game } from "./domain/game/game.js";
import { exportSgf } from "./domain/game/sgf.js";
import { createWasmEngine } from "./engine/wasm-engine.js";
import { startEngineWorker } from "./engine/worker-run.js";
import { createGameSession } from "./storage/game-session.js";
import { memoryStorage, openGameLibrary } from "./storage/open-library.js";
import { createSettingsStore } from "./storage/settings-store.js";
import { startApp } from "./ui/app.js";

// Ce fichier est servi sous app/ ; le Worker et le service worker sont à la
// racine du site.
const worker = startEngineWorker(new URL("../engine-worker.mjs", import.meta.url));
const engine = createWasmEngine(worker.run);

// Chaque accès au stockage du navigateur peut lever une exception (stockage
// interdit) : on fait alors sans.
const localStorage = attempt(() => window.localStorage);
const settings = createSettingsStore(localStorage ?? memoryStorage());

// Les parties enregistrées (IndexedDB, ou localStorage en repli), ouvertes
// pendant que le moteur se charge : le plateau est dessiné sans les
// attendre. L'écran de jeu ne s'en sert qu'une fois engineReady résolue.
const opening = (async () => {
    const { library } = await openGameLibrary({
        indexedDB: attempt(() => window.indexedDB),
        localStorage,
    });
    // Le niveau de l'ordinateur : celui de Game.start (STANDARD_PLY).
    const session = createGameSession(
        library,
        { start: () => Game.start(engine), resume: (journal) => Game.resume(engine, journal) },
        "2ply",
    );
    const saved = await session.restore();
    return { library, session, saved };
})();
let stored: Awaited<typeof opening> | null = null;
/** Le stockage, ouvert (toujours le cas une fois engineReady résolue). */
function storage(): Awaited<typeof opening> {
    if (stored === null) {
        throw new Error("stockage pas encore ouvert");
    }
    return stored;
}

startApp({
    engineReady: Promise.all([
        worker.ready,
        opening.then((opened) => {
            stored = opened;
        }),
    ]),
    newGame: () => storage().session.newGame(),
    savedGame: () => storage().saved,
    resumePrevious: () => storage().session.resumePrevious(),
    saveGame: (journal) => storage().session.save(journal),
    games: {
        list: () => storage().library.list(),
        journal: async (id) => (await storage().library.load(id))?.journal ?? null,
        shownId: () => storage().session.shownId,
        open: (id, branchHead) => storage().session.open(id, branchHead),
        remove: (id) => storage().library.remove(id),
        exportSgf: async (id) => {
            const game = await storage().library.load(id);
            if (game === null) {
                throw new Error("partie introuvable");
            }
            const started = new Date(game.summary.startedAt);
            const two = (n: number) => String(n).padStart(2, "0");
            const date = `${started.getFullYear()}-${two(started.getMonth() + 1)}-${two(started.getDate())}`;
            const text = await exportSgf(engine, game.journal, {
                playerName: "Vous",
                computerName: "Ustagammon",
                date,
            });
            const time = `${two(started.getHours())}${two(started.getMinutes())}`;
            return { fileName: `ustagammon-${date}-${time}.sgf`, text };
        },
    },
    cachedBoard: () => settings.loadBoard(),
    saveBoard: (board) => settings.saveBoard(board),
    loadSettings: () => settings.loadSettings(),
    saveSettings: (json) => settings.saveSettings(json),
});

// Hors ligne : le service worker met tout le site en cache. Le navigateur le
// refuse hors https (sauf localhost) : l'application marche alors sans.
// Il est enregistré une fois le moteur chargé : si le Worker et le service
// worker téléchargent les données du moteur (8,7 Mo) en même temps, Chromium
// fait échouer l'installation (« Cache.add() encountered a network error »),
// et l'application n'est pas disponible hors ligne. Cela évite aussi de
// télécharger deux fois ces données à la première visite.
if ("serviceWorker" in navigator) {
    const sw = new URL("../sw.js", import.meta.url);
    worker.ready.then(() => navigator.serviceWorker.register(sw)).catch(() => {});
}

/** La valeur, ou undefined si l'obtenir lève une exception. */
function attempt<T>(get: () => T): T | undefined {
    try {
        return get();
    } catch {
        return undefined;
    }
}