using System.Text;
using MaBibli.Api.Services.Souhaits;
using MaBibli.Shared.Dtos;

namespace MaBibli.Tests;

/// <summary>
/// Contenu <b>exact</b> des fichiers d'export. Fonctions pures : rien à simuler.
/// </summary>
public class ExportSouhaitsTests
{
    private static readonly DateTime Jour = new(2026, 8, 18, 10, 0, 0, DateTimeKind.Utc);

    private static SouhaitDto Souhait(
        int id, string titre, string? auteur = null, string? editeur = null,
        string? annee = null, string? isbn = null, string? note = null) =>
        new()
        {
            Id = id,
            Titre = titre,
            Auteur = auteur,
            Editeur = editeur,
            Annee = annee,
            Isbn = isbn,
            Note = note,
            DateAjout = Jour,
        };

    [Fact]
    public void Le_texte_groupe_les_livres_par_auteur()
    {
        var texte = ExportSouhaits.Texte(
            [
                Souhait(1, "La prophétie des abeilles", "Bernard Werber"),
                Souhait(2, "Germinal", "Émile Zola"),
                Souhait(3, "Les fourmis", "Bernard Werber"),
            ],
            [],
            "Mathieu",
            Jour);

        Assert.Contains("Liste d'envies de Mathieu — 18/08/2026", texte);
        Assert.Contains("3 livres", texte);

        // Un seul en-tête par auteur, et ses deux titres regroupés dessous.
        var lignes = texte.Split('\n');
        Assert.Single(lignes, l => l == "Bernard Werber");

        var debutWerber = Array.IndexOf(lignes, "Bernard Werber");
        // Le crochet porte le rang d'envie, que le groupement par auteur ferait sinon
        // disparaître : la liste s'emporte pour savoir par quoi commencer.
        Assert.Equal("  - [1] La prophétie des abeilles", lignes[debutWerber + 1]);
        Assert.Equal("  - [3] Les fourmis", lignes[debutWerber + 2]);

        // Werber avant Zola : les auteurs sont classés alphabétiquement.
        Assert.True(debutWerber < Array.IndexOf(lignes, "Émile Zola"));
    }

    [Fact]
    public void Le_texte_range_les_livres_sans_auteur_en_dernier()
    {
        var texte = ExportSouhaits.Texte(
            [Souhait(1, "Titre orphelin"), Souhait(2, "Germinal", "Émile Zola")],
            [],
            null,
            Jour);

        Assert.True(texte.IndexOf("Émile Zola", StringComparison.Ordinal)
                    < texte.IndexOf("Auteur non précisé", StringComparison.Ordinal));
    }

    [Fact]
    public void Le_texte_porte_les_precisions_utiles_en_librairie()
    {
        var texte = ExportSouhaits.Texte(
            [Souhait(1, "Germinal", "Émile Zola", "Le Livre de poche", "1885", "2253004227", "en poche seulement")],
            [],
            null,
            Jour);

        // ISBN découpé : c'est un numéro qu'on épelle à un libraire. La valeur passée est nue
        // (« 2253004227 »), les tirets n'existent qu'à la sortie.
        Assert.Contains("  - [1] Germinal (Le Livre de poche, 1885, ISBN 2-253-00422-7)", texte);
        Assert.Contains("    en poche seulement", texte);
    }

    /// <summary>
    /// Le découpage du CSV ne sert pas qu'à la lisibilité : <b>un ISBN nu de treize chiffres est
    /// lu comme un nombre par Excel</b>, qui l'affiche « 9,78225E+12 » et perd les derniers
    /// chiffres. Les tirets en font un texte, et le numéro survit à l'ouverture du fichier.
    /// </summary>
    [Fact]
    public void Le_csv_decoupe_lIsbn_pour_quExcel_ne_le_prenne_pas_pour_un_nombre()
    {
        var csv = ExportSouhaits.Csv(
            [Souhait(1, "Germinal", "Émile Zola", "Le Livre de poche", "1885", "9782253004226")], []);

        Assert.Contains("978-2-253-00422-6", csv);
        Assert.DoesNotContain("9782253004226", csv);
    }

    [Fact]
    public void Le_texte_le_dit_quand_la_liste_est_vide()
    {
        var texte = ExportSouhaits.Texte([], [], "Mathieu", Jour);

        Assert.Contains("(aucune envie dans la liste)", texte);
    }

    [Fact]
    public void Le_csv_porte_un_en_tete_et_une_ligne_par_envie()
    {
        var csv = ExportSouhaits.Csv([Souhait(1, "Germinal", "Émile Zola", "Le Livre de poche", "1885")], []);

        var lignes = csv.Split("\r\n", StringSplitOptions.RemoveEmptyEntries);

        Assert.Equal("Rang;Type;Titre;Auteur;Éditeur;Année;ISBN / ISSN;Note;Ajouté le", lignes[0]);
        Assert.Equal("1;Livre;Germinal;Émile Zola;Le Livre de poche;1885;;;2026-08-18", lignes[1]);
    }

    /// <summary>
    /// Sans échappement, une note contenant le séparateur décalerait toutes les colonnes
    /// suivantes — et une note est du texte parfaitement libre.
    /// </summary>
    [Fact]
    public void Le_csv_echappe_le_separateur_et_les_guillemets()
    {
        var csv = ExportSouhaits.Csv(
            [Souhait(1, "Titre; piégé", note: "il a dit \"oui\"")], []);

        var ligne = csv.Split("\r\n")[1];

        Assert.StartsWith("1;Livre;\"Titre; piégé\";", ligne);
        Assert.Contains("\"il a dit \"\"oui\"\"\"", ligne);

        // Neuf colonnes une fois l'échappement respecté, pas dix.
        Assert.Equal(9, ColonnesCsv(ligne).Count);
    }

    /// <summary>
    /// Le rang imprimé est la <b>position dans la liste reçue</b>, qui vient déjà triée par
    /// <c>Rang</c>. Le texte la regroupe par auteur, ce qui casse l'ordre à l'affichage : le
    /// crochet est alors la seule trace de « par quoi commencer ».
    /// </summary>
    [Fact]
    public void Le_rang_suit_lordre_recu_et_non_lalphabet()
    {
        IReadOnlyList<SouhaitDto> liste =
        [
            Souhait(7, "Zorro", "Émile Zola"),
            Souhait(3, "Abécédaire", "Émile Zola"),
        ];

        var texte = ExportSouhaits.Texte(liste, [], null, Jour);
        Assert.Contains("  - [1] Zorro", texte);
        Assert.Contains("  - [2] Abécédaire", texte);

        // Le CSV, lui, garde l'ordre : le rang y est croissant ligne après ligne.
        var lignes = ExportSouhaits.Csv(liste, []).Split("\r\n", StringSplitOptions.RemoveEmptyEntries);
        Assert.StartsWith("1;Livre;Zorro;", lignes[1]);
        Assert.StartsWith("2;Livre;Abécédaire;", lignes[2]);
    }

    [Fact]
    public void Le_csv_echappe_les_sauts_de_ligne()
    {
        var csv = ExportSouhaits.Csv([Souhait(1, "Titre", note: "ligne 1\nligne 2")], []);

        Assert.Contains("\"ligne 1\nligne 2\"", csv);
    }

    /// <summary>
    /// Sans BOM, Excel affiche « Émile Zola » — sur un fonds français, à peu près chaque ligne.
    /// </summary>
    [Fact]
    public void Le_bom_precede_le_csv()
    {
        var octets = ExportSouhaits.Bom
            .Concat(Encoding.UTF8.GetBytes(ExportSouhaits.Csv([Souhait(1, "Émile")], [])))
            .ToArray();

        Assert.Equal([0xEF, 0xBB, 0xBF], octets[..3]);
    }

    [Theory]
    [InlineData(FormatExportSouhaits.Texte, "liste-envies-2026-08-18.txt", "text/plain; charset=utf-8")]
    [InlineData(FormatExportSouhaits.Csv, "liste-envies-2026-08-18.csv", "text/csv; charset=utf-8")]
    public void Le_fichier_est_date_et_typé(FormatExportSouhaits format, string nom, string mime)
    {
        Assert.Equal(nom, ExportSouhaits.NomFichier(format, Jour));
        Assert.Equal(mime, ExportSouhaits.TypeMime(format));
    }

    // ─────────────────────────────────────────────────────────────────────────
    // La table sœur : les revues souhaitées doivent traverser les DEUX exports.
    // C'est là que le sujet se rate — un fichier emporté sans ses revues ne le dit pas.
    // ─────────────────────────────────────────────────────────────────────────

    private static RevueSouhaiteeDto Revue(
        int id, string titre, string? numero = null, string? issn = null, string? note = null) =>
        new()
        {
            Id = id,
            Titre = titre,
            Numero = numero,
            Issn = issn,
            Note = note,
            DateAjout = Jour,
        };

    [Fact]
    public void Le_texte_porte_les_revues_dans_une_section_apres_les_livres()
    {
        var texte = ExportSouhaits.Texte(
            [Souhait(1, "Germinal", "Émile Zola")],
            [Revue(1, "Médor", "43", "2466-6718"), Revue(2, "XXI")],
            "Mathieu",
            Jour);

        Assert.Contains("1 livre", texte);
        Assert.Contains("2 revues", texte);

        // ⚠️ Section à part, APRÈS les livres : une revue n'a pas d'auteur, elle n'a donc rien
        // à faire dans un fichier groupé par auteur — et surtout pas sous « Auteur non précisé »,
        // qui désigne des livres dont l'auteur est simplement inconnu.
        Assert.True(texte.IndexOf("Émile Zola", StringComparison.Ordinal)
                    < texte.IndexOf("Médor", StringComparison.Ordinal));

        Assert.Contains("  - [1] Médor n° 43 (ISSN 2466-6718)", texte);

        // Sans numéro, on n'invente pas de « n° » : c'est la revue entière qui est souhaitée.
        Assert.Contains("  - [2] XXI", texte);
        Assert.DoesNotContain("XXI n°", texte);
    }

    [Fact]
    public void Le_texte_porte_les_revues_meme_sans_aucun_livre()
    {
        var texte = ExportSouhaits.Texte([], [Revue(1, "Médor", "43")], null, Jour);

        Assert.DoesNotContain("(aucune envie dans la liste)", texte);
        Assert.Contains("  - [1] Médor n° 43", texte);
    }

    /// <summary>
    /// La colonne « Type » n'est pas décorative : sans elle, une revue et un livre deviennent
    /// indiscernables dès que le tableur est trié par titre, et la colonne des codes mêle deux
    /// numéros de nature différente sans le dire.
    /// </summary>
    [Fact]
    public void Le_csv_distingue_les_revues_des_livres_et_les_range_ensuite()
    {
        var csv = ExportSouhaits.Csv(
            [Souhait(1, "Germinal", "Émile Zola")],
            [Revue(1, "Médor", "43", "2466-6718", "au kiosque de la gare")]);

        var lignes = csv.Split("\r\n", StringSplitOptions.RemoveEmptyEntries);

        Assert.StartsWith("1;Livre;Germinal;", lignes[1]);
        Assert.Equal("1;Revue;Médor n° 43;;;;2466-6718;au kiosque de la gare;2026-08-18", lignes[2]);

        // Le nombre de colonnes est le même pour les deux natures, sinon le tableau se décale.
        Assert.Equal(ColonnesCsv(lignes[1]).Count, ColonnesCsv(lignes[2]).Count);
    }

    /// <summary>Découpe une ligne CSV en respectant les guillemets (lecteur minimal, pour le test).</summary>
    private static List<string> ColonnesCsv(string ligne)
    {
        var colonnes = new List<string>();
        var courante = new StringBuilder();
        var dansGuillemets = false;

        for (var i = 0; i < ligne.Length; i++)
        {
            var c = ligne[i];

            if (c == '"')
            {
                if (dansGuillemets && i + 1 < ligne.Length && ligne[i + 1] == '"')
                {
                    courante.Append('"');
                    i++;
                    continue;
                }

                dansGuillemets = !dansGuillemets;
                continue;
            }

            if (c == ExportSouhaits.SeparateurCsv && !dansGuillemets)
            {
                colonnes.Add(courante.ToString());
                courante.Clear();
                continue;
            }

            courante.Append(c);
        }

        colonnes.Add(courante.ToString());
        return colonnes;
    }
}