import re
import os
import yaml
import markdown
from bs4 import BeautifulSoup
from latex2mathml.converter import convert as latex_to_mathml
from .utils.fiche_utils import render_fiche_markdown
import pypandoc
import streamlit as st

from .utils.dynamic import (
    build_dynamic_sections,
    build_ivc_sections,
    build_ihh_sections,
    build_isg_sections,
    build_production_sections,
    build_minerai_sections
)

# === Fonctions de transformation ===
def remplacer_latex_par_mathml(markdown_text):
    def remplacer_bloc_display(match):
        formule_latex = match.group(1).strip()
        try:
            mathml = latex_to_mathml(formule_latex, display='block')
            return f'<div class="math-block">{mathml}</div>'
        except Exception as e:
            return f"<pre>Erreur LaTeX block: {e}</pre>"

    def remplacer_bloc_inline(match):
        formule_latex = match.group(1).strip()
        try:
            mathml = latex_to_mathml(formule_latex, display='inline')
            return f'<span class="math-inline">{mathml}</span>'
        except Exception as e:
            return f"<code>Erreur LaTeX inline: {e}</code>"

    markdown_text = re.sub(r"\$\$(.*?)\$\$", remplacer_bloc_display, markdown_text, flags=re.DOTALL)
    markdown_text = re.sub(r"(?<!\$)\$(.+?)\$(?!\$)", remplacer_bloc_inline, markdown_text, flags=re.DOTALL)
    return markdown_text

def markdown_to_html_rgaa(markdown_text, caption_text=None):
    html = markdown.markdown(markdown_text, extensions=['tables'])
    soup = BeautifulSoup(html, "html.parser")
    for i, table in enumerate(soup.find_all("table"), start=1):
        table["role"] = "table"
        table["summary"] = caption_text
        if caption_text:
            caption = soup.new_tag("caption")
            caption.string = caption_text
            table.insert(len(table.contents), caption)
        for th in table.find_all("th"):
            th["scope"] = "col"
    return str(soup)

def rendu_html(contenu_md):
    lignes = contenu_md.split('\n')
    sections_n1 = []
    section_n1_actuelle = {"titre": None, "intro": [], "sections_n2": {}}
    section_n2_actuelle = None
    for ligne in lignes:
        if re.match(r'^#[^#]', ligne):
            if section_n1_actuelle["titre"] or section_n1_actuelle["intro"] or section_n1_actuelle["sections_n2"]:
                sections_n1.append(section_n1_actuelle)
            section_n1_actuelle = {"titre": ligne.strip('# ').strip(), "intro": [], "sections_n2": {}}
            section_n2_actuelle = None
        elif re.match(r'^##[^#]', ligne):
            section_n2_actuelle = ligne.strip('# ').strip()
            section_n1_actuelle["sections_n2"][section_n2_actuelle] = [f"## {section_n2_actuelle}"]
        elif section_n2_actuelle:
            section_n1_actuelle["sections_n2"][section_n2_actuelle].append(ligne)
        else:
            section_n1_actuelle["intro"].append(ligne)

    if section_n1_actuelle["titre"] or section_n1_actuelle["intro"] or section_n1_actuelle["sections_n2"]:
        sections_n1.append(section_n1_actuelle)

    bloc_titre = sections_n1[0]["titre"] if sections_n1 and sections_n1[0]["titre"] else "fiche"
    titre_id = re.sub(r'\W+', '-', bloc_titre.lower()).strip('-')

    html_output = [f'<section role="region" aria-labelledby="{titre_id}">', f'<h1 id="{titre_id}">{bloc_titre}</h1>']
    for bloc in sections_n1:
        if bloc["titre"] and bloc["titre"] != bloc_titre:
            html_output.append(f"<h2>{bloc['titre']}</h2>")
        if bloc["intro"]:
            intro_md = remplacer_latex_par_mathml("\n".join(bloc["intro"]))
            html_intro = markdown_to_html_rgaa(intro_md)
            html_output.append(html_intro)
        for sous_titre, contenu in bloc["sections_n2"].items():
            contenu_md = remplacer_latex_par_mathml("\n".join(contenu))
            contenu_html = markdown_to_html_rgaa(contenu_md, caption_text=sous_titre)
            html_output.append(f"<details><summary>{sous_titre}</summary>{contenu_html}</details>")

    html_output.append("</section>")

    return html_output

def generer_fiche(md_source, dossier, nom_fichier, seuils):
    front_match = re.match(r"(?s)^---\n(.*?)\n---\n", md_source)
    context = yaml.safe_load(front_match.group(1)) if front_match else {}

    type_fiche = context.get("type_fiche")
    if type_fiche == "indice":
        indice = context.get("indice_court")
        if indice == "ICS":
            md_source = build_dynamic_sections(md_source)
        elif indice == "IVC":
            md_source = build_ivc_sections(md_source)
        elif indice == "IHH":
            md_source = build_ihh_sections(md_source)
        elif indice == "ISG":
            md_source = build_isg_sections(md_source)
    elif type_fiche in ["assemblage", "fabrication"]:
        md_source = build_production_sections(md_source)
    elif type_fiche == "minerai":
        md_source = build_minerai_sections(md_source)

    contenu_md = render_fiche_markdown(md_source, seuils, license_path="assets/licence.md")

    md_path = os.path.join("Fiches", dossier, nom_fichier)
    os.makedirs(os.path.dirname(md_path), exist_ok=True)
    with open(md_path, "w", encoding="utf-8") as f:
        f.write(contenu_md)

    # Génération automatique du PDF
    pdf_dir = os.path.join("static", "Fiches", dossier)
    os.makedirs(pdf_dir, exist_ok=True)

    # Construire le chemin PDF correspondant (même nom que .md, mais .pdf)
    nom_pdf = os.path.splitext(nom_fichier)[0] + ".pdf"
    pdf_path = os.path.join(pdf_dir, nom_pdf)

    try:
        pypandoc.convert_file(
            md_path,
            to="pdf",
            outputfile=pdf_path,
            extra_args=["--pdf-engine=xelatex", "-V", "geometry:margin=2cm"]
        )
    except Exception as e:
        st.error(f"[ERREUR] Génération PDF échouée pour {md_path}: {e}")

    html_output = rendu_html(contenu_md)

    html_dir = os.path.join("HTML", dossier)
    os.makedirs(html_dir, exist_ok=True)
    html_path = os.path.join(html_dir, os.path.splitext(nom_fichier)[0] + ".html")
    with open(html_path, "w", encoding="utf-8") as f:
        f.write("\n".join(html_output))

    return html_path