using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading.Tasks;
using Omika.App.Local.Services;
using Xunit;
using Xunit.Sdk;

namespace Omika.Tests.Mobile;

/// <summary>
/// Conformité du tokeniseur SentencePiece maison à la bibliothèque de référence.
///
/// <para>
/// Le risque propre à un tokeniseur réécrit à la main n'est pas de lever une
/// exception : c'est de découper <b>légèrement autrement</b> que le modèle, donc
/// de dégrader les traductions sans aucun signal. Ces tests comparent les
/// identifiants produits par <see cref="SentencePieceTokenizer"/> à ceux de la
/// bibliothèque <c>sentencepiece</c>, figés dans des fixtures JSON par
/// <c>scripts\Generer-Fixtures-SentencePiece.ps1</c>.
/// </para>
///
/// <para>
/// <b>Sans fixtures, ces tests passent.</b> Ni les fixtures ni les modèles
/// <c>.spm</c> ne sont versionnés (modèles lourds, sous licence, et propres à
/// chaque pack de langue) : une suite rouge sur une machine neuve pour de simples
/// fichiers absents pousserait à désactiver le test — exactement l'inverse du
/// but. L'absence est donc expliquée sur la sortie standard, et seul un écart
/// réellement mesuré fait échouer.
/// </para>
/// </summary>
public sealed class SentencePieceFixturesTests : IDisposable
{
    /// <summary>
    /// Variable d'environnement qui désigne le dossier des fixtures. Elle permet
    /// de vérifier un pack de langue sans rien copier dans le dépôt.
    /// </summary>
    private const string VariableDossierFixtures = "OMIKA_SPM_FIXTURES";

    /// <summary>
    /// Textes témoins du test d'idempotence : ils n'ont besoin d'aucune fixture,
    /// seulement d'un modèle. Volontairement chargés en accents, en espaces
    /// parasites et en alphabet non latin, car ce sont ces entrées qui font
    /// diverger un aller-retour.
    /// </summary>
    private static readonly string[] TextesTemoins =
    [
        "Bonjour le monde.",
        "L'été dernier, j'ai mangé une crêpe à Nîmes.",
        "¿Qué tal? ¡Hola, señor! El niño pequeño añadió más café.",
        "  Bonjour   le    monde  ",
        string.Empty,
        "     ",
        "Traduction hors ligne : 1 234,56 € (soit 42 %).",
        "مرحبا بالعالم",
        "Здравствуйте, мир!"
    ];

    private readonly string _racineTemporaire = Path.Combine(
        Path.GetTempPath(), "omika-spm-tests", Guid.NewGuid().ToString("N"));

    public void Dispose()
    {
        try
        {
            if (Directory.Exists(_racineTemporaire))
            {
                Directory.Delete(_racineTemporaire, recursive: true);
            }
        }
        catch (IOException)
        {
            // Best-effort : un fichier encore verrouillé ne doit pas faire
            // échouer la suite de tests.
        }
    }

    // ===== Comparaison au découpage de référence =====

    [Fact]
    public async Task Fixtures_LeDecoupageCorrespondAuxIdentifiantsDeReference()
    {
        string? dossier = TrouverDossierFixtures();
        if (dossier is null)
        {
            Console.WriteLine(
                "Aucun dossier de fixtures SentencePiece : comparaison à la référence ignorée. "
                + "Générez-les avec .\\scripts\\Generer-Fixtures-SentencePiece.ps1 -DossierModeles <dossier des .spm>.");
            return;
        }

        string[] fixtures = Directory.GetFiles(dossier, "*.fixtures.json", SearchOption.TopDirectoryOnly);
        Array.Sort(fixtures, StringComparer.OrdinalIgnoreCase);

        if (fixtures.Length == 0)
        {
            Console.WriteLine(
                $"Le dossier de fixtures « {dossier} » ne contient aucun fichier *.fixtures.json : "
                + "comparaison à la référence ignorée (voir tests/fixtures/sentencepiece/LISEZMOI.md).");
            return;
        }

        int modelesCharges = 0;
        int casVerifies = 0;

        foreach (string cheminFixture in fixtures)
        {
            string nomFixture = Path.GetFileName(cheminFixture);
            FixtureSentencePiece fixture = LireFixture(cheminFixture);

            string? cheminModele = TrouverModele(dossier, fixture.Modele);
            if (cheminModele is null)
            {
                // Le vocabulaire n'est pas versionné : son absence est le cas
                // NORMAL d'un dépôt fraîchement cloné, pas une anomalie.
                Console.WriteLine(
                    $"Fixture « {nomFixture} » ignorée : le vocabulaire « {fixture.Modele} » "
                    + $"est absent de {dossier} (copiez-le, ou lancez le générateur avec -CopierModeles).");
                continue;
            }

            SentencePieceTokenizer tokeniseur = SentencePieceTokenizer.Charger(cheminModele);
            modelesCharges++;

            // Une fixture et un modèle de tailles de vocabulaire différentes ne
            // viennent pas du même modèle : comparer leurs découpages n'aurait
            // aucun sens, et le signaler ici évite de chercher une divergence de
            // Viterbi là où il n'y a qu'un mauvais appariement de fichiers.
            Assert.True(
                fixture.VocabSize == tokeniseur.TailleVocabulaire,
                $"Le vocabulaire « {Path.GetFileName(cheminModele)} » compte "
                + $"{tokeniseur.TailleVocabulaire} pièces, alors que la fixture « {nomFixture} » "
                + $"en annonce {fixture.VocabSize} : les deux fichiers ne viennent pas du même modèle.");

            if (fixture.Cas.Count == 0)
            {
                Console.WriteLine($"Fixture « {nomFixture} » ignorée : elle ne décrit aucun cas.");
                continue;
            }

            // Les réglages de la référence sont affichés avant les cas : ils
            // datent la comparaison (une divergence constatée dans six mois ne se
            // confond pas avec un changement de version de la bibliothèque) et
            // disent si le découpage attendu inclut un préfixe factice ou des
            // espaces échappés — deux causes classiques d'écart systématique.
            Console.WriteLine(
                $"Fixture « {nomFixture} » : {fixture.Cas.Count} cas sur « {Path.GetFileName(cheminModele)} » "
                + $"(sentencepiece {fixture.SentencePieceVersion}, normalisation {fixture.NormalizerName}, "
                + $"préfixe factice={fixture.AddDummyPrefix}, espaces superflus={fixture.RemoveExtraWhitespaces}, "
                + $"espaces échappés={fixture.EscapeWhitespaces}).");

            foreach (CasFixture cas in fixture.Cas)
            {
                await VerifierCasAsync(tokeniseur, cas, nomFixture, fixture.SentencePieceVersion);
                casVerifies++;
            }
        }

        Console.WriteLine($"{casVerifies} cas de référence vérifiés sur {modelesCharges} modèle(s).");
    }

    /// <summary>
    /// Vérifie un cas de référence : les identifiants d'encodage, puis le texte
    /// reconstruit à partir de ces <b>mêmes</b> identifiants.
    /// </summary>
    private static async Task VerifierCasAsync(
        SentencePieceTokenizer tokeniseur, CasFixture cas, string nomFixture, string? versionReference)
    {
        string texte = cas.Texte ?? string.Empty;
        IReadOnlyList<int> attendus = cas.Ids ?? [];
        string decodeAttendu = cas.Decode ?? string.Empty;

        IReadOnlyList<int> obtenus = await tokeniseur.EncodeAsync(texte);

        int index = PremierEcart(attendus, obtenus);
        if (index >= 0)
        {
            // Comparaison détaillée plutôt que Assert.Equal sur les séquences :
            // « expected [1, 2, 3], actual [1, 2, 7] » sur des dizaines
            // d'identifiants ne dit ni OÙ le découpage diverge, ni sur quelle
            // pièce — c'est pourtant la seule information exploitable.
            Assert.True(false,
                $"Découpage divergent pour {DecrireTexte(texte)} "
                + $"(fixture {nomFixture}, référence sentencepiece {versionReference}).{Environment.NewLine}"
                + $"Premier écart à l'index {index} : référence {Valeur(attendus, index)} "
                + $"{DecrirePiece(tokeniseur, attendus, index)}, tokeniseur {Valeur(obtenus, index)} "
                + $"{DecrirePiece(tokeniseur, obtenus, index)}.{Environment.NewLine}"
                + $"Identifiants de référence ({attendus.Count}) : {AbregerListe(attendus)}{Environment.NewLine}"
                + $"Identifiants obtenus ({obtenus.Count})   : {AbregerListe(obtenus)}{Environment.NewLine}"
                + $"Texte reconstruit par la référence : « {decodeAttendu} ».");
        }

        // Le décodage est comparé sur les identifiants de la RÉFÉRENCE : c'est la
        // seule façon de tester la reconstruction sans que l'encodage maison
        // puisse masquer une erreur de décodage.
        string decode = tokeniseur.Decode(attendus);
        if (!string.Equals(decodeAttendu, decode, StringComparison.Ordinal))
        {
            Assert.True(false,
                $"Décodage divergent pour {DecrireTexte(texte)} "
                + $"(fixture {nomFixture}, référence sentencepiece {versionReference}).{Environment.NewLine}"
                + $"Référence : « {decodeAttendu} »{Environment.NewLine}"
                + $"Obtenu    : « {decode} »{Environment.NewLine}"
                + $"Identifiants décodés : {AbregerListe(attendus)}.");
        }
    }

    // ===== Idempotence de l'aller-retour (aucune fixture requise) =====

    [Fact]
    public async Task AllerRetour_DecoderDeuxFois_DonneToujoursLeMemeTexte()
    {
        // Ce test ne lit AUCUNE fixture : il lui faut seulement un modèle .spm
        // pour construire un tokeniseur. Il vérifie la seule propriété de
        // l'aller-retour qui ne dépende pas du vocabulaire : l'idempotence, soit
        // f(f(x)) = f(x) avec f = Decode ∘ Encode.
        //
        // Il serait FAUX d'exiger f(x) == x : un modèle peut légitimement replier
        // une casse, réduire des espaces multiples ou rendre <unk> pour un
        // caractère hors vocabulaire. Exiger l'égalité au texte d'entrée ferait
        // échouer le test sur un tokeniseur pourtant correct.
        string? cheminModele = TrouverPremierModele(TrouverDossierFixtures());
        if (cheminModele is null)
        {
            Console.WriteLine(
                "Aucun modèle .spm dans le dossier des fixtures : test d'idempotence de l'aller-retour ignoré "
                + "(voir tests/fixtures/sentencepiece/LISEZMOI.md).");
            return;
        }

        SentencePieceTokenizer tokeniseur = SentencePieceTokenizer.Charger(cheminModele);
        Console.WriteLine($"Idempotence de l'aller-retour vérifiée sur le modèle « {Path.GetFileName(cheminModele)} ».");

        foreach (string texte in TextesTemoins)
        {
            IReadOnlyList<int> ids = await tokeniseur.EncodeAsync(texte);
            string premier = tokeniseur.Decode(ids);

            IReadOnlyList<int> idsReencodes = await tokeniseur.EncodeAsync(premier);
            string second = tokeniseur.Decode(idsReencodes);

            if (!string.Equals(premier, second, StringComparison.Ordinal))
            {
                Assert.True(false,
                    $"Aller-retour non idempotent pour {DecrireTexte(texte)} : "
                    + $"premier décodage « {premier} », décodage du texte réencodé « {second} ».");
            }
        }
    }

    // ===== Diagnostic de chargement (aucune fixture requise) =====

    [Fact]
    public void Chargement_UnFichierInexploitable_LeveUneErreurEnFrancais()
    {
        string dossier = Path.Combine(_racineTemporaire, "invalides");
        Directory.CreateDirectory(dossier);

        // Octets DÉTERMINISTES plutôt qu'un tirage aléatoire : un vrai tirage
        // pourrait, avec une probabilité faible mais non nulle, former un
        // protobuf exploitable (une suite d'octets est un protobuf valide plus
        // souvent qu'on ne le croit) et faire passer le test au vert pour de
        // mauvaises raisons. Ici, le premier octet annonce un champ « pieces »
        // dont la longueur dépasse le fichier : la troncature est certaine.
        byte[] bruit = [0x0A, 0xFF, 0xFF, 0xFF, 0x7F, 0xC3, 0x28, 0x9A, 0x51];
        string cheminBruit = Path.Combine(dossier, "bruit.spm");
        File.WriteAllBytes(cheminBruit, bruit);

        SentencePieceException erreurBruit = Assert.Throws<SentencePieceException>(
            () => { _ = SentencePieceTokenizer.Charger(cheminBruit); });

        // Le message est destiné à l'utilisateur : il doit être en français et
        // nommer le fichier, jamais exposer un détail binaire ni un chemin de
        // sandbox. Une erreur de lecture protobuf brute (IndexOutOfRange,
        // ArgumentOutOfRange) signalerait une lecture hors bornes non maîtrisée.
        Assert.Contains("vocabulaire", erreurBruit.Message, StringComparison.Ordinal);

        // Un fichier qui n'est pas un protobuf du tout : la même erreur métier,
        // pas un plantage du lecteur minimal.
        string cheminTexte = Path.Combine(dossier, "texte.spm");
        File.WriteAllBytes(cheminTexte, Encoding.UTF8.GetBytes("ceci n'est pas un modèle SentencePiece"));

        SentencePieceException erreurTexte = Assert.Throws<SentencePieceException>(
            () => { _ = SentencePieceTokenizer.Charger(cheminTexte); });

        Assert.Contains("vocabulaire", erreurTexte.Message, StringComparison.Ordinal);

        // Modèle absent : l'utilisateur doit lire qu'il faut réinstaller le pack
        // de langue, pas voir remonter le FileNotFoundException du système (que
        // l'application ne saurait pas traduire en conseil).
        string cheminAbsent = Path.Combine(dossier, "absent.spm");
        Assert.False(File.Exists(cheminAbsent));

        SentencePieceException erreurAbsente = Assert.Throws<SentencePieceException>(
            () => { _ = SentencePieceTokenizer.Charger(cheminAbsent); });

        Assert.Contains("introuvable", erreurAbsente.Message, StringComparison.Ordinal);
    }

    // ===== Localisation des fichiers =====

    /// <summary>
    /// Dossier des fixtures : <c>OMIKA_SPM_FIXTURES</c> s'il est défini et
    /// existe, sinon <c>tests/fixtures/sentencepiece</c> sous la racine du
    /// dépôt. <see langword="null"/> quand aucun des deux n'existe.
    /// </summary>
    private static string? TrouverDossierFixtures()
    {
        string? variable = Environment.GetEnvironmentVariable(VariableDossierFixtures);
        if (!string.IsNullOrWhiteSpace(variable) && Directory.Exists(variable))
        {
            return variable;
        }

        string? racine = TrouverRacineDepot();
        if (racine is null)
        {
            return null;
        }

        string dossier = Path.Combine(racine, "tests", "fixtures", "sentencepiece");
        return Directory.Exists(dossier) ? dossier : null;
    }

    /// <summary>
    /// Racine du dépôt, trouvée en remontant depuis le dossier de l'assembly de
    /// test jusqu'au premier dossier contenant <c>Omika.slnx</c>.
    ///
    /// <para>
    /// Le chemin n'est ni codé en dur ni pris dans le dossier courant :
    /// <c>dotnet test</c> s'exécute depuis <c>bin\Debug\net10.0</c>, un
    /// exécuteur d'IDE depuis la racine, et un test lancé depuis un autre dossier
    /// ne doit pas changer le résultat. La marche ascendante est la seule
    /// méthode qui fonctionne dans tous ces cas.
    /// </para>
    /// </summary>
    private static string? TrouverRacineDepot()
    {
        DirectoryInfo? dossier = new(AppContext.BaseDirectory);
        while (dossier is not null)
        {
            if (File.Exists(Path.Combine(dossier.FullName, "Omika.slnx")))
            {
                return dossier.FullName;
            }

            dossier = dossier.Parent;
        }

        return null;
    }

    /// <summary>
    /// Chemin du <c>.spm</c> annoncé par une fixture : d'abord le nom tel quel
    /// dans le dossier des fixtures (ce qui accepte un sous-dossier), puis le nom
    /// simple à la racine de ce dossier.
    /// </summary>
    private static string? TrouverModele(string dossierFixtures, string? nomAnnonce)
    {
        if (string.IsNullOrWhiteSpace(nomAnnonce))
        {
            return null;
        }

        string nomSimple = Path.GetFileName(nomAnnonce);
        if (string.IsNullOrEmpty(nomSimple))
        {
            return null;
        }

        // Un chemin annoncé qui remonterait hors du dossier des fixtures est
        // refusé : ces JSON sont produits par notre propre script, mais ils ne
        // constituent pas pour autant une source de confiance.
        bool cheminInterne = !Path.IsPathRooted(nomAnnonce)
            && !nomAnnonce.Split('/', '\\').Contains("..");

        if (cheminInterne)
        {
            string dansSousDossier = Path.Combine(dossierFixtures, nomAnnonce);
            if (File.Exists(dansSousDossier))
            {
                return dansSousDossier;
            }
        }

        string aLaRacine = Path.Combine(dossierFixtures, nomSimple);
        return File.Exists(aLaRacine) ? aLaRacine : null;
    }

    /// <summary>Premier <c>.spm</c> trouvé sous le dossier des fixtures, ou <see langword="null"/>.</summary>
    private static string? TrouverPremierModele(string? dossierFixtures)
    {
        if (dossierFixtures is null || !Directory.Exists(dossierFixtures))
        {
            return null;
        }

        string[] modeles = Directory.GetFiles(dossierFixtures, "*.spm", SearchOption.AllDirectories);
        Array.Sort(modeles, StringComparer.OrdinalIgnoreCase);

        return modeles.Length == 0 ? null : modeles[0];
    }

    /// <summary>
    /// Lit une fixture. Un fichier illisible ou vide est une <b>anomalie</b>, pas
    /// une absence : il est signalé comme un échec, car il ferait passer le test
    /// au vert en n'ayant rien vérifié.
    /// </summary>
    private static FixtureSentencePiece LireFixture(string chemin)
    {
        string json = File.ReadAllText(chemin);

        try
        {
            return JsonSerializer.Deserialize<FixtureSentencePiece>(json)
                ?? throw new XunitException(
                    $"La fixture « {Path.GetFileName(chemin)} » est vide : régénérez-la avec "
                    + "scripts\\Generer-Fixtures-SentencePiece.ps1.");
        }
        catch (JsonException erreur)
        {
            throw new XunitException(
                $"La fixture « {Path.GetFileName(chemin)} » n'est pas un JSON valide : {erreur.Message}");
        }
    }

    // ===== Aides de diagnostic =====

    /// <summary>
    /// Index du premier identifiant qui diffère, ou -1 si les deux séquences sont
    /// identiques. Une séquence plus courte diverge dès le premier identifiant
    /// manquant : le retourner évite un accès hors bornes dans le message.
    /// </summary>
    private static int PremierEcart(IReadOnlyList<int> attendus, IReadOnlyList<int> obtenus)
    {
        int commun = Math.Min(attendus.Count, obtenus.Count);
        for (int i = 0; i < commun; i++)
        {
            if (attendus[i] != obtenus[i])
            {
                return i;
            }
        }

        return attendus.Count == obtenus.Count ? -1 : commun;
    }

    /// <summary>Identifiant à un index, ou un tiret quand la séquence est plus courte.</summary>
    private static string Valeur(IReadOnlyList<int> ids, int index)
        => index < ids.Count ? ids[index].ToString(CultureInfo.InvariantCulture) : "—";

    /// <summary>
    /// Texte lisible d'un identifiant, pour le message d'échec.
    ///
    /// <para>
    /// <see cref="SentencePieceTokenizer.Decode"/> sur un identifiant isolé donne
    /// une indication suffisante (le marqueur ▁ devient une espace et les bords
    /// sont rognés) : c'est une aide au diagnostic, pas une restitution fidèle du
    /// texte exact de la pièce, qui n'est pas exposé par l'interface publique.
    /// </para>
    /// </summary>
    private static string DecrirePiece(
        SentencePieceTokenizer tokeniseur, IReadOnlyList<int> ids, int index)
    {
        if (index >= ids.Count)
        {
            return "(aucun identifiant de ce côté)";
        }

        int id = ids[index];
        if (id < 0 || id >= tokeniseur.TailleVocabulaire)
        {
            return "(hors vocabulaire)";
        }

        return $"« {tokeniseur.Decode([id])} »";
    }

    /// <summary>
    /// Texte d'un cas, rendu lisible dans un message d'échec : retour à la ligne,
    /// tabulation et longueur bornée, sinon une phrase de référence rendrait le
    /// message illisible.
    /// </summary>
    private static string DecrireTexte(string? texte)
    {
        if (string.IsNullOrEmpty(texte))
        {
            return "le cas « chaîne vide »";
        }

        string lisible = texte
            .Replace("\r", "\\r", StringComparison.Ordinal)
            .Replace("\n", "\\n", StringComparison.Ordinal)
            .Replace("\t", "\\t", StringComparison.Ordinal);

        string tronque = lisible.Length <= 80 ? lisible : lisible[..80] + "…";
        return $"le cas « {tronque} »";
    }

    /// <summary>Début d'une longue séquence d'identifiants, suivi d'une ellipse.</summary>
    private static string AbregerListe(IReadOnlyList<int> ids)
    {
        const int maximum = 24;

        var texte = new StringBuilder();
        for (int i = 0; i < Math.Min(maximum, ids.Count); i++)
        {
            if (i > 0)
            {
                texte.Append(", ");
            }

            texte.Append(ids[i].ToString(CultureInfo.InvariantCulture));
        }

        if (ids.Count > maximum)
        {
            texte.Append(", …");
        }

        return texte.ToString();
    }

    // ===== Forme du fixture écrit par le générateur =====

    /// <summary>
    /// Fixture de référence. Les noms JSON sont écrits explicitement en camelCase
    /// plutôt que déduits d'une politique de nommage : le schéma est un contrat
    /// partagé avec le script Python, il ne doit pas pouvoir changer en silence.
    /// </summary>
    private sealed class FixtureSentencePiece
    {
        [JsonPropertyName("modele")]
        public string? Modele { get; set; }

        [JsonPropertyName("sentencepieceVersion")]
        public string? SentencePieceVersion { get; set; }

        [JsonPropertyName("vocabSize")]
        public int VocabSize { get; set; }

        [JsonPropertyName("addDummyPrefix")]
        public bool AddDummyPrefix { get; set; }

        [JsonPropertyName("removeExtraWhitespaces")]
        public bool RemoveExtraWhitespaces { get; set; }

        [JsonPropertyName("escapeWhitespaces")]
        public bool EscapeWhitespaces { get; set; }

        [JsonPropertyName("normalizerName")]
        public string? NormalizerName { get; set; }

        [JsonPropertyName("cas")]
        public List<CasFixture> Cas { get; set; } = [];
    }

    /// <summary>Un texte de référence, ses identifiants et la reconstruction de la référence.</summary>
    private sealed class CasFixture
    {
        [JsonPropertyName("texte")]
        public string? Texte { get; set; }

        [JsonPropertyName("ids")]
        public List<int>? Ids { get; set; }

        [JsonPropertyName("decode")]
        public string? Decode { get; set; }
    }
}