"""Tests unitaires pour le module app.fiches.generer.

Ces tests vérifient les fonctions de transformation Markdown/HTML :
- remplacer_latex_par_mathml
- markdown_to_html_rgaa
- rendu_html
- render_fiche_markdown (via app.fiches.utils.fiche_utils)
"""

import re
from unittest.mock import patch

from bs4 import BeautifulSoup

from app.fiches.generer import (
    markdown_to_html_rgaa,
    remplacer_latex_par_mathml,
    rendu_html,
)
from app.fiches.utils.fiche_utils import render_fiche_markdown


# ──────────────────────────────────────────────
#  remplacer_latex_par_mathml
# ──────────────────────────────────────────────
class TestRemplacerLatexParMathml:
    """Tests pour la fonction remplacer_latex_par_mathml."""

    def test_formule_inline_simple(self):
        """Test la conversion d'une formule LaTeX inline simple."""
        texte = "La valeur est $x^2$ dans le calcul."
        resultat = remplacer_latex_par_mathml(texte)

        assert "$" not in resultat
        assert '<span class="math-inline">' in resultat
        assert "<math" in resultat

    def test_formule_display_simple(self):
        """Test la conversion d'une formule LaTeX display (bloc)."""
        texte = "Voici la formule :\n$$E = mc^2$$\nFin."
        resultat = remplacer_latex_par_mathml(texte)

        assert "$$" not in resultat
        assert '<div class="math-block">' in resultat
        assert "<math" in resultat

    def test_formule_inline_fraction(self):
        """Test la conversion d'une fraction inline."""
        texte = "Le ratio est $\\frac{a}{b}$ ici."
        resultat = remplacer_latex_par_mathml(texte)

        assert "$" not in resultat
        assert '<span class="math-inline">' in resultat
        assert "<math" in resultat

    def test_formule_display_somme(self):
        """Test la conversion d'une somme en mode display."""
        texte = "$$\\sum_{i=1}^{n} x_i$$"
        resultat = remplacer_latex_par_mathml(texte)

        assert "$$" not in resultat
        assert '<div class="math-block">' in resultat

    def test_texte_sans_formule(self):
        """Test qu'un texte sans LaTeX n'est pas modifie."""
        texte = "Un texte normal sans formule."
        resultat = remplacer_latex_par_mathml(texte)

        assert resultat == texte

    def test_formules_multiples_inline(self):
        """Test la conversion de plusieurs formules inline."""
        texte = "Soit $a$ et $b$ deux variables."
        resultat = remplacer_latex_par_mathml(texte)

        assert resultat.count('<span class="math-inline">') == 2
        assert "$" not in resultat

    def test_formule_display_et_inline_combinees(self):
        """Test la combinaison de formules display et inline."""
        texte = "Inline $x$ et display :\n$$y = x + 1$$\nFin."
        resultat = remplacer_latex_par_mathml(texte)

        assert '<span class="math-inline">' in resultat
        assert '<div class="math-block">' in resultat
        assert "$" not in resultat

    def test_formule_display_multilignes(self):
        """Test une formule display sur plusieurs lignes."""
        texte = "$$\na^2 +\nb^2 = c^2\n$$"
        resultat = remplacer_latex_par_mathml(texte)

        assert "$$" not in resultat
        assert '<div class="math-block">' in resultat

    def test_dollar_simple_non_latex(self):
        """Test que le texte entre doubles dollars est traite en display et non en inline."""
        texte = "Le prix est de 100 dollars."
        resultat = remplacer_latex_par_mathml(texte)

        # Pas de dollar LaTeX, pas de conversion
        assert resultat == texte

    def test_formule_latex_invalide_inline(self):
        """Test qu'une formule LaTeX invalide renvoie un message d'erreur inline."""
        texte = "Formule $\\invalid_command_xyz{}$ ici."
        resultat = remplacer_latex_par_mathml(texte)

        # Soit converti, soit message d'erreur encapsule dans <code>
        assert "$" not in resultat or "Erreur LaTeX" in resultat

    def test_formule_latex_invalide_display(self):
        """Test qu'une formule LaTeX display invalide renvoie un message d'erreur."""
        texte = "$$\\invalid_command_xyz{}$$"
        resultat = remplacer_latex_par_mathml(texte)

        # Soit converti, soit message d'erreur encapsule dans <pre>
        assert "$$" not in resultat or "Erreur LaTeX" in resultat

    def test_indice_et_exposant(self):
        """Test les indices et exposants LaTeX."""
        texte = "La formule $x_i^2$ est simple."
        resultat = remplacer_latex_par_mathml(texte)

        assert '<span class="math-inline">' in resultat
        assert "<math" in resultat

    def test_texte_vide(self):
        """Test avec un texte vide."""
        resultat = remplacer_latex_par_mathml("")
        assert resultat == ""


# ──────────────────────────────────────────────
#  markdown_to_html_rgaa
# ──────────────────────────────────────────────
class TestMarkdownToHtmlRgaa:
    """Tests pour la fonction markdown_to_html_rgaa."""

    def test_paragraphe_simple(self):
        """Test la conversion d'un paragraphe simple."""
        md = "Un paragraphe simple."
        resultat = markdown_to_html_rgaa(md, None)

        assert "<p>" in resultat
        assert "Un paragraphe simple." in resultat

    def test_tableau_avec_caption(self):
        """Test qu'un tableau reçoit un caption RGAA."""
        md = "| Col1 | Col2 |\n| --- | --- |\n| A | B |"
        resultat = markdown_to_html_rgaa(md, "Mon tableau")

        soup = BeautifulSoup(resultat, "html.parser")
        table = soup.find("table")

        assert table is not None
        assert table.get("role") == "table"
        assert table.get("summary") == "Mon tableau"

        caption = table.find("caption")
        assert caption is not None
        assert caption.string == "Mon tableau"

    def test_tableau_scope_col_sur_th(self):
        """Test que les en-tetes de tableau ont scope=col."""
        md = "| Nom | Valeur |\n| --- | --- |\n| A | 1 |"
        resultat = markdown_to_html_rgaa(md, "Donnees")

        soup = BeautifulSoup(resultat, "html.parser")
        for th in soup.find_all("th"):
            assert th.get("scope") == "col"

    def test_tableau_sans_caption(self):
        """Test un tableau sans caption (caption_text=None)."""
        md = "| X | Y |\n| --- | --- |\n| 1 | 2 |"
        resultat = markdown_to_html_rgaa(md, None)

        soup = BeautifulSoup(resultat, "html.parser")
        table = soup.find("table")

        assert table is not None
        assert table.get("role") == "table"
        # Pas de caption quand caption_text est None
        caption = table.find("caption")
        assert caption is None

    def test_tableau_summary_avec_caption_none(self):
        """Test que summary est vide quand caption_text est None."""
        md = "| A | B |\n| --- | --- |\n| 1 | 2 |"
        resultat = markdown_to_html_rgaa(md, None)

        soup = BeautifulSoup(resultat, "html.parser")
        table = soup.find("table")
        assert table.get("summary") == ""

    def test_titre_h2(self):
        """Test la conversion d'un titre de niveau 2."""
        md = "## Titre niveau 2"
        resultat = markdown_to_html_rgaa(md, None)

        assert "<h2>" in resultat
        assert "Titre niveau 2" in resultat

    def test_liste_a_puces(self):
        """Test la conversion d'une liste a puces."""
        md = "- item 1\n- item 2\n- item 3"
        resultat = markdown_to_html_rgaa(md, None)

        assert "<ul>" in resultat
        assert "<li>" in resultat
        assert resultat.count("<li>") == 3

    def test_texte_en_gras_et_italique(self):
        """Test le formatage gras et italique."""
        md = "Du texte **gras** et *italique*."
        resultat = markdown_to_html_rgaa(md, None)

        assert "<strong>" in resultat
        assert "<em>" in resultat

    def test_lien_html(self):
        """Test la conversion d'un lien Markdown."""
        md = "[FabNum](https://fabnum.peccini.fr)"
        resultat = markdown_to_html_rgaa(md, None)

        soup = BeautifulSoup(resultat, "html.parser")
        lien = soup.find("a")
        assert lien is not None
        assert lien.get("href") == "https://fabnum.peccini.fr"
        assert lien.string == "FabNum"

    def test_tableaux_multiples(self):
        """Test avec plusieurs tableaux dans le meme contenu."""
        md = (
            "| A | B |\n| --- | --- |\n| 1 | 2 |\n\n"
            "| C | D |\n| --- | --- |\n| 3 | 4 |"
        )
        resultat = markdown_to_html_rgaa(md, "Donnees")

        soup = BeautifulSoup(resultat, "html.parser")
        tables = soup.find_all("table")

        assert len(tables) == 2
        for table in tables:
            assert table.get("role") == "table"

    def test_texte_vide(self):
        """Test avec un texte vide."""
        resultat = markdown_to_html_rgaa("", None)
        assert resultat == ""

    def test_contenu_mixte_texte_et_tableau(self):
        """Test avec du texte et un tableau melanges."""
        md = "Paragraphe avant.\n\n| X | Y |\n| --- | --- |\n| 1 | 2 |\n\nParagraphe apres."
        resultat = markdown_to_html_rgaa(md, "Tableau")

        assert "<p>" in resultat
        assert "<table" in resultat
        assert "Paragraphe avant." in resultat
        assert "Paragraphe apres." in resultat


# ──────────────────────────────────────────────
#  rendu_html
# ──────────────────────────────────────────────
class TestRenduHtml:
    """Tests pour la fonction rendu_html."""

    def test_structure_section_region(self):
        """Test que le HTML genere contient une section avec role=region."""
        md = "# Titre principal\n\nContenu intro."
        resultat = rendu_html(md)

        html = "\n".join(resultat)
        assert '<section role="region"' in html
        assert "</section>" in html

    def test_titre_h1_genere(self):
        """Test que le titre h1 est genere correctement."""
        md = "# Mon titre\n\nContenu."
        resultat = rendu_html(md)

        html = "\n".join(resultat)
        assert "<h1" in html
        assert "Mon titre" in html

    def test_aria_labelledby_sur_section(self):
        """Test que aria-labelledby est lie au titre."""
        md = "# Titre Test\n\nContenu."
        resultat = rendu_html(md)

        html = "\n".join(resultat)
        assert 'aria-labelledby="titre-test"' in html
        assert 'id="titre-test"' in html

    def test_titre_id_normalise(self):
        """Test que l'ID du titre est normalise (minuscules, tirets)."""
        md = "# Mon Titre Complexe !\n\nContenu."
        resultat = rendu_html(md)

        html = "\n".join(resultat)
        # L'ID doit etre en minuscules avec des tirets, ponctuation supprimee
        assert 'id="mon-titre-complexe"' in html

    def test_section_n2_dans_details(self):
        """Test que les sous-sections (h2) sont dans des balises details."""
        md = "# Titre\n\n## Sous-section\n\nContenu sous-section."
        resultat = rendu_html(md)

        html = "\n".join(resultat)
        assert "<details>" in html
        assert "<summary>" in html
        assert "Sous-section" in html

    def test_intro_avant_sections(self):
        """Test que le texte d'introduction est place avant les sous-sections."""
        md = "# Titre\n\nIntroduction texte.\n\n## Section\n\nContenu."
        resultat = rendu_html(md)

        html = "\n".join(resultat)
        idx_intro = html.find("Introduction texte")
        idx_details = html.find("<details>")

        assert idx_intro != -1
        assert idx_details != -1
        assert idx_intro < idx_details

    def test_sections_multiples_n2(self):
        """Test le rendu de plusieurs sous-sections h2."""
        md = "# Titre\n\n## Section A\n\nContenu A.\n\n## Section B\n\nContenu B."
        resultat = rendu_html(md)

        html = "\n".join(resultat)
        assert html.count("<details>") == 2
        assert "Section A" in html
        assert "Section B" in html

    def test_retour_type_liste(self):
        """Test que la fonction retourne bien une liste de chaines."""
        md = "# Titre\n\nContenu."
        resultat = rendu_html(md)

        assert isinstance(resultat, list)
        assert all(isinstance(item, str) for item in resultat)

    def test_premier_element_est_section(self):
        """Test que le premier element est la balise section ouvrante."""
        md = "# Titre\n\nContenu."
        resultat = rendu_html(md)

        assert resultat[0].startswith('<section role="region"')

    def test_dernier_element_est_section_fermante(self):
        """Test que le dernier element est la balise section fermante."""
        md = "# Titre\n\nContenu."
        resultat = rendu_html(md)

        assert resultat[-1] == "</section>"

    def test_section_h1_multiples(self):
        """Test avec plusieurs titres h1 (sections de niveau 1)."""
        md = "# Titre 1\n\nContenu 1.\n\n# Titre 2\n\nContenu 2."
        resultat = rendu_html(md)

        html = "\n".join(resultat)
        # Le premier h1 est dans la balise <h1>, les suivants en <h2>
        assert "<h1" in html
        assert "<h2>" in html
        assert "Titre 2" in html

    def test_contenu_sans_titre_h1(self):
        """Test avec un contenu sans titre h1 explicite."""
        md = "Juste du contenu sans titre."
        resultat = rendu_html(md)

        html = "\n".join(resultat)
        # Doit utiliser 'fiche' comme titre par defaut
        assert '<h1 id="fiche">fiche</h1>' in html

    def test_latex_dans_intro_converti(self):
        """Test que le LaTeX dans l'introduction est converti en MathML."""
        md = "# Titre\n\nFormule : $x^2$ dans le texte."
        resultat = rendu_html(md)

        html = "\n".join(resultat)
        assert "$" not in html or "<math" in html

    def test_latex_dans_section_n2_converti(self):
        """Test que le LaTeX dans une sous-section est converti en MathML."""
        md = "# Titre\n\n## Calcul\n\nLa formule est $a + b$."
        resultat = rendu_html(md)

        html = "\n".join(resultat)
        assert "<math" in html

    def test_tableau_dans_section_n2(self):
        """Test qu'un tableau dans une sous-section est accessible."""
        md = "# Titre\n\n## Donnees\n\n| A | B |\n| --- | --- |\n| 1 | 2 |"
        resultat = rendu_html(md)

        html = "\n".join(resultat)
        soup = BeautifulSoup(html, "html.parser")
        table = soup.find("table")

        assert table is not None
        assert table.get("role") == "table"


# ──────────────────────────────────────────────
#  render_fiche_markdown
# ──────────────────────────────────────────────
class TestRenderFicheMarkdown:
    """Tests pour la fonction render_fiche_markdown (fiche_utils)."""

    def _make_md(self, meta: dict, body: str) -> str:
        """Construit un document Markdown avec frontmatter YAML."""
        lines = ["---"]
        for k, v in meta.items():
            lines.append(f"{k}: {v}")
        lines.append("---")
        lines.append(body)
        return "\n".join(lines)

    def test_titre_auto_insere(self, tmp_path):
        """Test que le titre h1 est insere automatiquement si absent."""
        licence = tmp_path / "licence.md"
        licence.write_text("Licence test", encoding="utf-8")

        md = self._make_md(
            {"indice": "Mon Indice", "indice_court": "MI"},
            "Contenu de la fiche."
        )
        resultat = render_fiche_markdown(md, {}, license_path=str(licence))

        assert resultat.startswith("# Mon Indice (MI)")

    def test_titre_existant_non_duplique(self, tmp_path):
        """Test que le titre n'est pas duplique s'il est deja present."""
        licence = tmp_path / "licence.md"
        licence.write_text("Licence test", encoding="utf-8")

        md = self._make_md(
            {"indice": "Mon Indice", "indice_court": "MI"},
            "# Titre existant\n\nContenu."
        )
        resultat = render_fiche_markdown(md, {}, license_path=str(licence))

        # Ne doit pas avoir deux titres h1
        h1_count = len(re.findall(r"^# ", resultat, re.M))
        assert h1_count == 1

    def test_licence_inseree_avant_h2(self, tmp_path):
        """Test que la licence est inseree avant le premier h2."""
        licence = tmp_path / "licence.md"
        licence.write_text("LICENCE_MARKER", encoding="utf-8")

        md = self._make_md(
            {"titre": "Fiche test"},
            "# Fiche test\n\n## Section 1\n\nContenu."
        )
        resultat = render_fiche_markdown(md, {}, license_path=str(licence))

        idx_licence = resultat.find("LICENCE_MARKER")
        idx_h2 = resultat.find("## Section 1")

        assert idx_licence != -1
        assert idx_h2 != -1
        assert idx_licence < idx_h2

    def test_licence_en_fin_sans_h2(self, tmp_path):
        """Test que la licence est ajoutee a la fin s'il n'y a pas de h2."""
        licence = tmp_path / "licence.md"
        licence.write_text("LICENCE_FIN", encoding="utf-8")

        md = self._make_md(
            {"titre": "Fiche simple"},
            "# Fiche simple\n\nContenu sans sous-sections."
        )
        resultat = render_fiche_markdown(md, {}, license_path=str(licence))

        assert resultat.rstrip().endswith("LICENCE_FIN")

    def test_placeholders_jinja_remplaces(self, tmp_path):
        """Test que les placeholders Jinja2 sont remplaces."""
        licence = tmp_path / "licence.md"
        licence.write_text("", encoding="utf-8")

        md = self._make_md(
            {"titre": "Test", "valeur": "42"},
            "# Test\n\nLa valeur est {{ valeur }}."
        )
        resultat = render_fiche_markdown(md, {}, license_path=str(licence))

        assert "42" in resultat
        assert "{{ valeur }}" not in resultat

    def test_seuils_accessibles_dans_template(self, tmp_path):
        """Test que les seuils sont accessibles dans le template Jinja2."""
        licence = tmp_path / "licence.md"
        licence.write_text("", encoding="utf-8")

        seuils = {"ISG": {"vert": {"max": 40}}}
        md = self._make_md(
            {"titre": "Test"},
            "# Test\n\nSeuil ISG vert max = {{ seuils.ISG.vert.max }}."
        )
        resultat = render_fiche_markdown(md, seuils, license_path=str(licence))

        assert "40" in resultat

    @patch("streamlit.error")
    def test_licence_manquante_ne_plante_pas(self, mock_st_error):
        """Test que l'absence du fichier de licence ne provoque pas d'erreur."""
        md = self._make_md(
            {"titre": "Test"},
            "# Test\n\nContenu."
        )
        # Chemin inexistant pour la licence
        resultat = render_fiche_markdown(md, {}, license_path="/inexistant/licence.md")

        # La fonction doit retourner un resultat meme sans licence
        assert "Test" in resultat
        assert "Contenu." in resultat
        # streamlit.error doit avoir ete appele
        mock_st_error.assert_called_once()

    def test_migration_metadata_sheet_type(self, tmp_path):
        """Test la migration des anciennes cles YAML (sheet_type -> type_fiche)."""
        licence = tmp_path / "licence.md"
        licence.write_text("", encoding="utf-8")

        md = self._make_md(
            {"sheet_type": "indice", "titre": "Test Migration"},
            "# Test Migration\n\nType = {{ type_fiche }}."
        )
        resultat = render_fiche_markdown(md, {}, license_path=str(licence))

        assert "indice" in resultat

    def test_retour_type_str(self, tmp_path):
        """Test que la fonction retourne bien une chaine."""
        licence = tmp_path / "licence.md"
        licence.write_text("", encoding="utf-8")

        md = self._make_md({"titre": "Test"}, "# Test\n\nContenu.")
        resultat = render_fiche_markdown(md, {}, license_path=str(licence))

        assert isinstance(resultat, str)