from __future__ import annotations

import os
import json
import subprocess
import shutil
import platform
import sys
from pathlib import Path
from typing import Any, Dict
import uuid

from jinja2 import Environment, FileSystemLoader
from pydantic import ValidationError

from pydantic_model import Resume

# Import conditionnel de gradio pour éviter les erreurs si non installé
try:
    import gradio as gr
except ImportError:
    gr = None

PROJECT_ROOT = Path(__file__).parent
TEMPLATES_DIR = PROJECT_ROOT / "templates"
# Par défaut, toujours utiliser le template classic
TEMPLATE_NAME = "classic.tex.j2"
OUTPUT_DIR = PROJECT_ROOT / "build"

# Activer explicitement le serveur MCP via variable d'environnement (équivalent à mcp_server=True)
os.environ["GRADIO_MCP_SERVER"] = "True"

def escape_latex_special_chars(text: str) -> str:
    """Escape special LaTeX characters in text."""
    if not isinstance(text, str):
        return text
    
    # Il faut traiter \ en premier pour éviter d'échapper les échappements
    # Puis traiter les autres caractères spéciaux
    text = text.replace('\\', r'\textbackslash{}')
    
    latex_special_chars = {
        '&': r'\&',
        '%': r'\%',
        '$': r'\$',
        '#': r'\#',
        '^': r'\textasciicircum{}',
        '_': r'\_',
        '{': r'\{',
        '}': r'\}',
        '~': r'\textasciitilde{}',
    }
    
    for char, escape in latex_special_chars.items():
        text = text.replace(char, escape)
    
    return text

def escape_resume_data(data: Dict[str, Any]) -> Dict[str, Any]:
    """Recursively escape LaTeX special characters in resume data."""
    if isinstance(data, dict):
        return {k: escape_resume_data(v) for k, v in data.items()}
    elif isinstance(data, list):
        return [escape_resume_data(item) for item in data]
    elif isinstance(data, str):
        return escape_latex_special_chars(data)
    else:
        return data

def render_tex(resume_data: Dict[str, Any], output_tex_path: Path, template_name: str = TEMPLATE_NAME) -> None:
    try:
        resume = Resume.model_validate(resume_data)
    except ValidationError as e:
        # En mode serveur (Gradio/MCP), il ne faut pas quitter le process
        # Propager une erreur explicite pour que l'UI / MCP l'affiche correctement
        raise ValueError(f"Validation Pydantic échouée: {e}") from e

    env = Environment(
        loader=FileSystemLoader(str(TEMPLATES_DIR)),
        autoescape=False,
        trim_blocks=True,
        lstrip_blocks=True,
    )
    # Configure custom delimiters to avoid clashes with LaTeX
    env.block_start_string = "<<%"
    env.block_end_string = "%>>"
    env.variable_start_string = "<<"
    env.variable_end_string = ">>"
    env.comment_start_string = "<#!"
    env.comment_end_string = "!#>"
    template = env.get_template(template_name)
    
    # Échapper les caractères spéciaux LaTeX dans les données
    escaped_data = escape_resume_data(resume.model_dump())
    rendered = template.render(resume=escaped_data)

    output_tex_path.parent.mkdir(parents=True, exist_ok=True)
    output_tex_path.write_text(rendered, encoding="utf-8")


def run_tectonic(tex_path: Path, outdir: Path) -> None:
    cmd = [
        "tectonic",
        "--outdir",
        str(outdir),
        str(tex_path),
    ]
    subprocess.run(cmd, check=True)


def run_latexmk(tex_path: Path, outdir: Path, *, xelatex: bool = False) -> None:
    # latexmk -pdf -synctex=1 -interaction=nonstopmode -output-directory=outdir tex
    cmd = ["latexmk"]
    if xelatex:
        cmd.append("-xelatex")
    else:
        cmd.append("-pdf")
    cmd += [
        "-halt-on-error",
        "-file-line-error",
        "-synctex=1",
        "-interaction=nonstopmode",
        f"-output-directory={outdir}",
        str(tex_path),
    ]
    subprocess.run(cmd, check=True)


def compile_pdf(output_tex_path: Path, output_pdf_path: Path, engine_preference: str = "tectonic") -> None:
    outdir = output_pdf_path.parent
    outdir.mkdir(parents=True, exist_ok=True)

    def tool_available(cmd: str) -> bool:
        return shutil.which(cmd) is not None

    def read_latex_log_tail() -> str:
        try:
            base = output_tex_path.stem
            log_path = outdir / f"{base}.log"
            if log_path.exists():
                content = log_path.read_text(errors="ignore")
                tail = "\n".join(content.splitlines()[-120:])
                return tail
            # tenter aussi le .xdv log de xelatex
            xdv_path = outdir / f"{base}.xdv"
            if xdv_path.exists():
                return "(fichier .xdv présent, pas de .log généré)"
        except Exception:
            pass
        return "(pas de log disponible)"

    if engine_preference == "latexmk":
        try:
            # Sur Linux (HF Spaces), privilégier XeLaTeX pour éviter les soucis de polices (lmodern)
            use_xelatex = platform.system() == "Linux"
            run_latexmk(output_tex_path, outdir, xelatex=use_xelatex)
        except (FileNotFoundError, subprocess.CalledProcessError) as e:
            if tool_available("tectonic"):
                run_tectonic(output_tex_path, outdir)
            else:
                log_tail = read_latex_log_tail()
                raise RuntimeError(
                    "Compilation LaTeX échouée avec latexmk et aucun fallback 'tectonic' disponible.\n"
                    f"Commande: {e}\n\nDernières lignes du .log:\n{log_tail}"
                ) from e
    else:
        # default: try tectonic first, then fallback if available
        try:
            run_tectonic(output_tex_path, outdir)
        except (FileNotFoundError, subprocess.CalledProcessError) as e:
            if tool_available("latexmk"):
                try:
                    run_latexmk(output_tex_path, outdir)
                except subprocess.CalledProcessError as e2:
                    log_tail = read_latex_log_tail()
                    raise RuntimeError(
                        "Compilation LaTeX échouée avec tectonic puis latexmk.\n"
                        f"Erreur latexmk: {e2}\n\nDernières lignes du .log:\n{log_tail}"
                    ) from e2
            else:
                raise RuntimeError(
                    f"Compilation LaTeX échouée avec tectonic et aucun fallback 'latexmk' disponible. "
                    f"Erreur tectonic: {e}"
                ) from e

    if not output_pdf_path.exists():
        raise RuntimeError(f"PDF introuvable après compilation: {output_pdf_path}")


@gr.mcp.prompt()
def resume_generation_system_prompt() -> str:
    """
    System prompt complet pour gérer tout le workflow de génération de CV professionnel.
    
    Ce prompt système fournit des instructions détaillées à l'assistant IA pour gérer
    efficacement tout le processus de création de CV, de la collecte d'informations
    à la génération du PDF final.

    Returns:
        str: Instructions système complètes pour l'assistant IA
    """
    return """Tu es un assistant spécialisé dans l'onboarding pour la génération de CV. Ton rôle est de guider l'utilisateur pour remplir toutes les informations nécessaires à la création de son CV, de manière claire, structurée et conviviale.

## TES RÈGLES FONDAMENTALES

1. **Pose une seule question à la fois** - Ne jamais submerger l'utilisateur
2. **Fournis un exemple concret** pour chaque question afin de guider l'utilisateur
3. **Valide chaque réponse** et reformule la question si la réponse est vide ou invalide
4. **Ne fais jamais de supposition** sur l'utilisateur - Toujours demander et confirmer
5. **Utilise un ton convivial, simple et naturel** - Pas de jargon technique

## DÉMARRAGE OBLIGATOIRE

Commence TOUJOURS par cette question :
"Bonjour ! 👋 Je vais t'aider à créer ton CV professionnel.

Pour commencer, dis-moi : est-ce que tu crées ton **premier CV** ou tu veux **mettre à jour un CV existant** ?

Si c'est une mise à jour, peux-tu uploader ton ancien CV (fichier PDF, Word, etc.) pour que je puisse m'en inspirer ?"

## INFORMATIONS À COLLECTER (DANS CET ORDRE)

### 1. INFORMATIONS DE BASE
- **pdf_title** 
  - Question : "Quel titre veux-tu donner à ton CV ?"
  - Exemple : "CV - Marie Dupont" ou "Candidature Développeur - Pierre Martin"

- **name** (sera automatiquement utilisé comme pdf_author)
  - Question : "Quel est ton nom complet ?"
  - Exemple : "Marie Dupont" ou "Pierre Martin"

- **location**
  - Question : "Où habites-tu actuellement ?"
  - Exemple : "Paris, France" ou "Lyon, France"

- **email**
  - Question : "Quelle est ton adresse email professionnelle ?"
  - Exemple : "marie.dupont@gmail.com"

- **phone**
  - Question : "Quel est ton numéro de téléphone (avec l'indicatif pays) ?"
  - Exemple : "+33 6 12 34 56 78" ou "06 12 34 56 78"

### 2. LIENS PROFESSIONNELS (OPTIONNELS)
- **website_url** et **website_label**
  - Question : "As-tu un site web personnel ou portfolio ? Si oui, donne-moi l'URL complète."
  - Exemple : "https://marie-dupont.fr" → label sera "marie-dupont.fr"

- **linkedin_url** et **linkedin_handle** 
  - Question : "As-tu un profil LinkedIn ? Si oui, donne-moi le lien complet."
  - Exemple : "https://linkedin.com/in/marie-dupont" → handle sera "marie-dupont"

- **github_url** et **github_handle**
  - Question : "As-tu un profil GitHub ? Si oui, donne-moi le lien complet."
  - Exemple : "https://github.com/marie-dupont" → handle sera "marie-dupont"

### 3. CONTENU DU CV

- **intro_paragraphs**
  - Question : "Écris une ou deux phrases qui te décrivent professionnellement."
  - Exemple : "Développeuse web avec 3 ans d'expérience, passionnée par les technologies modernes et l'innovation."

- **quick_guide_items**
  - Question : "Liste 3 à 5 de tes principales compétences ou points forts."
  - Exemple : "Développement web, Gestion d'équipe, React/Node.js, Problem solving"

- **education**
  - Question : "Parle-moi de ta formation. Pour chaque diplôme, indique : le nom du diplôme, l'école/université, les dates (format AAAA-AAAA), et éventuellement des mentions ou points importants."
  - Exemple : "Master en Informatique à l'École Polytechnique (2020-2022), spécialité IA, mention Bien"
  - ⚠️ **FORMAT DATES OBLIGATOIRE** : Toujours utiliser des tirets pour séparer les années (ex: "2020-2022", "2015-2018")

- **experience**
  - Question : "Décris ton expérience professionnelle. Pour chaque poste : nom de l'entreprise, ton poste, lieu, dates (format Mois AAAA-Mois AAAA), et tes principales réalisations avec des chiffres si possible."
  - Exemple : "Développeur chez Google, Paris (Janvier 2022-présent) : Développé 3 nouvelles fonctionnalités, réduit les bugs de 40%"
  - ⚠️ **FORMAT DATES OBLIGATOIRE** : Utiliser des tirets et des espaces (ex: "Janvier 2022-Décembre 2024", "Avril-Juin 2022")

- **publications** (si applicable)
  - Question : "As-tu publié des articles, recherches ou communications ? Si oui, donne-moi les détails."
  - Exemple : "Article sur l'IA publié en 2023 dans la revue TechReview"

- **projects**
  - Question : "Quels sont tes projets personnels ou professionnels marquants ? Avec liens GitHub si possible."
  - Exemple : "Application mobile de gestion de tâches (React Native) - 1000+ téléchargements"

- **languages**
  - Question : "Quels langages de programmation ou langues maîtrises-tu ?"
  - Exemple : "Python, JavaScript, TypeScript, Anglais, Espagnol"

- **technologies**
  - Question : "Quelles technologies, frameworks ou outils utilises-tu ?"
  - Exemple : "React, Node.js, Docker, AWS, PostgreSQL"

## FINALISATION

Une fois toutes les informations collectées :

1. **Présente un récapitulatif clair** de toutes les informations
2. **Demande confirmation** : "Ces informations sont-elles correctes ?"
3. **Si confirmé**, appelle la fonction `generate_resume_pdf` avec tous les paramètres
4. **Présente le résultat** : "Voici ton CV ! Tu peux le télécharger et me dire s'il faut ajuster quelque chose."

## GESTION DES RÉPONSES

- **Si réponse vide** : "Cette information est importante pour ton CV. Peux-tu me donner cette information ?"
- **Si réponse invalide** : "Je n'ai pas bien compris. Peux-tu reformuler ? Voici un exemple : [exemple]"
- **Si l'utilisateur veut passer** : "D'accord, on peut laisser ça vide pour l'instant. On pourra l'ajouter plus tard si tu veux."

## FORMATS JSON POUR LES PARAMÈTRES

Quand tu collectes des informations complexes, formate-les correctement :
- **Listes simples** : ["item1", "item2", "item3"]
- **Éducation** : [{"degree": "Master", "institution": "École", "date_range": "2020-2022", "field_of_study": "Informatique", "highlights": ["Mention Bien"]}]
- **Expérience** : [{"company": "Google", "role": "Développeur", "location": "Paris", "date_range": "Janvier 2022-présent", "highlights": ["Réalisation 1", "Impact 2"]}]

⚠️ **RÈGLES CRITIQUES POUR LES DATES** :
- **TOUJOURS** utiliser des tirets pour séparer les périodes : "2020-2022", "Avril-Juin 2022"
- **JAMAIS** coller les dates : ❌ "20202022" ✅ "2020-2022"
- Pour l'éducation : Format "AAAA-AAAA" (ex: "2015-2018")
- Pour l'expérience : Format "Mois AAAA-Mois AAAA" (ex: "Janvier 2022-Décembre 2024")

Commence maintenant par la question de démarrage !"""


def validate_json_parameter(param_name: str, param_value: str) -> list:
    """
    Validate and parse a JSON parameter.

    Args:
        param_name (str): Name of the parameter for error reporting
        param_value (str): JSON string to validate

    Returns:
        list: Parsed JSON data
        
    Raises:
        ValueError: If JSON is invalid
    """
    try:
        parsed = json.loads(param_value)
        if not isinstance(parsed, list):
            raise ValueError(f"Parameter '{param_name}' must be a JSON array")
        return parsed
    except json.JSONDecodeError as e:
        raise ValueError(f"Invalid JSON in parameter '{param_name}': {str(e)}")


def generate_resume_pdf(
    pdf_title: str,
    pdf_author: str,
    name: str,
    location: str,
    email: str,
    phone: str,
    last_updated_text: str = "",
    website_url: str = "",
    website_label: str = "",
    linkedin_url: str = "",
    linkedin_handle: str = "",
    github_url: str = "",
    github_handle: str = "",
    intro_paragraphs: str = "[]",
    quick_guide_items: str = "[]",
    education: str = "[]",
    experience: str = "[]",
    publications: str = "[]",
    projects: str = "[]",
    languages: str = "[]",
    technologies: str = "[]"
) -> str:
    """
    Generate a professional PDF resume from structured data.
    
    Creates a LaTeX-based PDF resume. All JSON parameters must be valid JSON strings.

    Args:
        pdf_title (str): PDF document title (e.g., "John Doe Resume")
        pdf_author (str): Author name for PDF metadata (e.g., "John Doe")
        name (str): Full name (e.g., "John Doe")
        location (str): Current location (e.g., "Paris, France")
        email (str): Email address (e.g., "john.doe@example.com")
        phone (str): Phone with country code (e.g., "+33 1 23 45 67 89")
        last_updated_text (str): Optional update text (e.g., "Updated September 2024") or ""
        website_url (str): Website URL (e.g., "https://johndoe.dev") or ""
        website_label (str): Website display text (e.g., "johndoe.dev") or ""
        linkedin_url (str): LinkedIn URL (e.g., "https://linkedin.com/in/johndoe") or ""
        linkedin_handle (str): LinkedIn username (e.g., "johndoe") or ""
        github_url (str): GitHub URL (e.g., "https://github.com/johndoe") or ""
        github_handle (str): GitHub username (e.g., "johndoe") or ""
        intro_paragraphs (str): JSON array of strings. Example: ["I am a software engineer with 5+ years experience.", "Passionate about AI and machine learning."]
        quick_guide_items (str): JSON array of key skills. Example: ["Python Expert", "Team Leadership", "Agile Methodologies"]
        education (str): JSON array of objects. Example: [{"degree": "Master of Science", "institution": "MIT", "date_range": "2018-2020", "field_of_study": "Computer Science", "highlights": ["GPA: 3.9/4.0"]}]. IMPORTANT: date_range must use format "YYYY-YYYY" (e.g., "2015-2018", NOT "20152018")
        experience (str): JSON array of objects. Example: [{"company": "Google", "role": "Senior Engineer", "location": "Mountain View, CA", "date_range": "January 2020-Present", "highlights": ["Led team of 5 engineers", "Increased system performance by 40%"]}]. IMPORTANT: date_range must use format "Month YYYY-Month YYYY" with proper separators
        publications (str): JSON array of objects. Example: [{"title": "AI in Production", "authors": ["John Doe", "Jane Smith"], "date": "2023", "doi": "10.1000/xyz123"}] or "[]"
        projects (str): JSON array of objects. Example: [{"title": "E-commerce Platform", "repo_url": "https://github.com/johndoe/ecommerce", "repo_label": "github.com/johndoe/ecommerce", "highlights": ["Built with React and Node.js", "Handles 10k+ users"]}]
        languages (str): JSON array of programming languages. Example: ["Python", "JavaScript", "TypeScript", "Go"]
        technologies (str): JSON array of tools/frameworks. Example: ["React", "Node.js", "Docker", "AWS", "PostgreSQL"]

    Returns:
        str: File path to the generated PDF resume
    """
    try:
        # Valider et parser tous les paramètres JSON
        intro_paragraphs_list = validate_json_parameter("intro_paragraphs", intro_paragraphs)
        quick_guide_items_list = validate_json_parameter("quick_guide_items", quick_guide_items)
        education_list = validate_json_parameter("education", education)
        experience_list = validate_json_parameter("experience", experience)
        publications_list = validate_json_parameter("publications", publications)
        projects_list = validate_json_parameter("projects", projects)
        languages_list = validate_json_parameter("languages", languages)
        technologies_list = validate_json_parameter("technologies", technologies)
        
        # Construire le dictionnaire Resume à partir des paramètres
        resume_data = {
            "meta": {
                "pdf_title": pdf_title,
                "pdf_author": pdf_author,
                "last_updated_text": last_updated_text if last_updated_text else None
            },
            "header": {
                "name": name,
                "location": location,
                "email": email,
                "phone": phone,
                "website_url": website_url if website_url else None,
                "website_label": website_label if website_label else None,
                "linkedin_url": linkedin_url if linkedin_url else None,
                "linkedin_handle": linkedin_handle if linkedin_handle else None,
                "github_url": github_url if github_url else None,
                "github_handle": github_handle if github_handle else None
            },
            "intro_paragraphs": intro_paragraphs_list,
            "quick_guide_items": quick_guide_items_list,
            "education": education_list,
            "experience": experience_list,
            "publications": publications_list,
            "projects": projects_list,
            "technologies_section": {
                "languages": languages_list,
                "technologies": technologies_list
            }
        }
        
        # Valider avec le modèle Pydantic
        resume = Resume.model_validate(resume_data)
        
        # Générer le PDF
        base_name = uuid.uuid4().hex
        out_dir = OUTPUT_DIR
        out_dir.mkdir(parents=True, exist_ok=True)
        out_tex = out_dir / f"{base_name}.tex"
        out_pdf = out_dir / f"{base_name}.pdf"
        
        render_tex(resume.model_dump(), out_tex, template_name=TEMPLATE_NAME)
        
        preferred_engine = "latexmk" if platform.system() == "Linux" else "tectonic"
        compile_pdf(out_tex, out_pdf, engine_preference=preferred_engine)
        
        # Retourner DIRECTEMENT le chemin pour que Gradio génère l'URL publique
        return str(out_pdf)
        
    except (ValueError, ValidationError) as e:
        # Pour les erreurs, lever une exception que Gradio peut gérer
        raise ValueError(str(e))
    except Exception as err:  # noqa: BLE001
        # Pour toutes les autres erreurs
        raise ValueError(f"Unexpected error: {str(err)}")

def launch_gradio(server_host: str = "127.0.0.1", server_port: int = 7860) -> None:
    """Lance une application Gradio (UI + MCP Server).

    L'UI propose: zone de texte JSON (schéma `Resume`) → bouton → PDF.\
    Le serveur MCP est activé via `mcp_server=True` conformément à la doc
    officielle Gradio [Building an MCP Server with Gradio](https://www.gradio.app/guides/building-mcp-server-with-gradio).
    """
    if gr is None:
        print("Gradio n'est pas installé. Ajoutez 'gradio' à pyproject.toml.")
        raise ImportError("Gradio n'est pas disponible")

    sample_path = PROJECT_ROOT / "example_inputs" / "sample.json"
    sample_value = "{}"
    if sample_path.exists():
        try:
            sample_value = sample_path.read_text(encoding="utf-8")
        except Exception:  # noqa: BLE001
            pass

    with gr.Blocks(title="Générateur de CV PDF (LaTeX)") as demo:
        gr.Markdown("## Générateur de CV PDF avec champs structurés\nTemplate: `classic.tex.j2`.")

        with gr.Accordion("Mode d'emploi", open=True):
            gr.Markdown(
                "- Remplissez les champs ci-dessous pour créer votre CV.\n"
                "- Les champs marqués * sont obligatoires.\n"
                "- Les listes (éducation, expérience, etc.) doivent être au format JSON.\n"
                "- Cliquez sur 'Générer le PDF' pour créer votre CV.\n"
            )

        with gr.Tab("Informations de base"):
            with gr.Row():
                with gr.Column():
                    ui_pdf_title = gr.Textbox(label="Titre du PDF *", value="Mon CV")
                    ui_pdf_author = gr.Textbox(label="Auteur du PDF *", value="")
                    ui_last_updated_text = gr.Textbox(label="Dernière mise à jour", value="", placeholder="ex: Septembre 2024")
                with gr.Column():
                    ui_name = gr.Textbox(label="Nom complet *", value="")
                    ui_location = gr.Textbox(label="Localisation *", value="", placeholder="ex: Paris, France")
                    ui_email = gr.Textbox(label="Email *", value="", placeholder="ex: nom@example.com")
                    ui_phone = gr.Textbox(label="Téléphone *", value="", placeholder="ex: +33 1 23 45 67 89")

        with gr.Tab("Liens et réseaux sociaux"):
            with gr.Row():
                with gr.Column():
                    ui_website_url = gr.Textbox(label="URL du site web", value="", placeholder="https://monsite.com")
                    ui_website_label = gr.Textbox(label="Label du site web", value="", placeholder="monsite.com")
                    ui_linkedin_url = gr.Textbox(label="URL LinkedIn", value="", placeholder="https://linkedin.com/in/...")
                    ui_linkedin_handle = gr.Textbox(label="Handle LinkedIn", value="", placeholder="monprofil")
                with gr.Column():
                    ui_github_url = gr.Textbox(label="URL GitHub", value="", placeholder="https://github.com/...")
                    ui_github_handle = gr.Textbox(label="Handle GitHub", value="", placeholder="monprofil")

        with gr.Tab("Contenu du CV"):
            ui_intro_paragraphs = gr.Textbox(
                label="Paragraphes d'introduction (JSON)", 
                value='["Ingénieur passionné avec 5 ans d\'expérience"]',
                lines=3,
                placeholder='["Paragraphe 1", "Paragraphe 2"]'
            )
            ui_quick_guide_items = gr.Textbox(
                label="Points clés (JSON)", 
                value='["Expert en Python", "Gestion d\'équipe"]',
                lines=3,
                placeholder='["Point 1", "Point 2"]'
            )

        with gr.Row():
                with gr.Column():
                    ui_education = gr.Textbox(
                        label="Éducation (JSON)", 
                        value='[]',
                        lines=5,
                        placeholder='[{"degree": "Master", "institution": "Université", "date_range": "2020-2022", "field_of_study": "Informatique", "highlights": []}]'
                    )
                    ui_experience = gr.Textbox(
                        label="Expérience (JSON)", 
                        value='[]',
                        lines=5,
                        placeholder='[{"company": "Entreprise", "role": "Développeur", "location": "Paris", "date_range": "2022-2024", "highlights": ["Réalisation X", "Amélioration Y"]}]'
                    )
                with gr.Column():
                    ui_publications = gr.Textbox(
                        label="Publications (JSON)", 
                        value='[]',
                        lines=3,
                        placeholder='[{"date": "2024", "title": "Article", "authors": ["Moi"], "doi_url": null, "doi_label": null}]'
                    )
                    ui_projects = gr.Textbox(
                        label="Projets (JSON)", 
                        value='[]',
                        lines=3,
                        placeholder='[{"title": "Projet", "repo_url": "https://github.com/...", "repo_label": "github.com/...", "highlights": []}]'
                    )

        with gr.Tab("Compétences"):
            with gr.Row():
                ui_languages = gr.Textbox(
                    label="Langages de programmation (JSON)", 
                    value='["Python", "JavaScript", "Java"]',
                    lines=2,
                    placeholder='["Python", "JavaScript", "Java"]'
                )
                ui_technologies = gr.Textbox(
                    label="Technologies (JSON)", 
                    value='["React", "Docker", "AWS"]',
                    lines=2,
                    placeholder='["React", "Docker", "AWS"]'
                )

        with gr.Row():
            generate_btn = gr.Button("Générer le PDF", variant="primary", size="lg")
        
        pdf_file = gr.File(label="PDF généré", file_count="single")

        def _on_click_structured(
            pdf_title, pdf_author, name, location, email, phone,
            last_updated_text, website_url, website_label,
            linkedin_url, linkedin_handle, github_url, github_handle,
            intro_paragraphs, quick_guide_items, education, experience,
            publications, projects, languages, technologies
        ) -> str:
            """Génère le PDF avec les champs structurés."""
            try:
                return generate_resume_pdf(
                    pdf_title, pdf_author, name, location, email, phone,
                    last_updated_text, website_url, website_label,
                    linkedin_url, linkedin_handle, github_url, github_handle,
                    intro_paragraphs, quick_guide_items, education, experience,
                    publications, projects, languages, technologies
                )
            except Exception as err:  # noqa: BLE001
                raise gr.Error(str(err))

        # Connecter l'interface utilisateur
        generate_btn.click(
            _on_click_structured,
            inputs=[
                ui_pdf_title, ui_pdf_author, ui_name, ui_location, ui_email, ui_phone,
                ui_last_updated_text, ui_website_url, ui_website_label,
                ui_linkedin_url, ui_linkedin_handle, ui_github_url, ui_github_handle,
                ui_intro_paragraphs, ui_quick_guide_items, ui_education, ui_experience,
                ui_publications, ui_projects, ui_languages, ui_technologies
            ],
            outputs=[pdf_file],
            api_name=False
        )


        # Section for API endpoints (hidden from UI but accessible for MCP)
        with gr.Tab("API Endpoints", visible=False):
            # API: generate_resume_pdf - Main resume generation tool
            with gr.Row():
                with gr.Column():
                    # Required fields
                    api_pdf_title = gr.Textbox(label="pdf_title", value="Professional Resume")
                    api_pdf_author = gr.Textbox(label="pdf_author", value="John Doe")
                    api_name = gr.Textbox(label="name", value="John Doe")
                    api_location = gr.Textbox(label="location", value="Paris, France")
                    api_email = gr.Textbox(label="email", value="john.doe@example.com")
                    api_phone = gr.Textbox(label="phone", value="+33 1 23 45 67 89")
                    
                    # Optional fields
                    api_last_updated_text = gr.Textbox(label="last_updated_text", value="")
                    api_website_url = gr.Textbox(label="website_url", value="")
                    api_website_label = gr.Textbox(label="website_label", value="")
                    api_linkedin_url = gr.Textbox(label="linkedin_url", value="")
                    api_linkedin_handle = gr.Textbox(label="linkedin_handle", value="")
                    api_github_url = gr.Textbox(label="github_url", value="")
                    api_github_handle = gr.Textbox(label="github_handle", value="")
                    
                with gr.Column():
                    # JSON array fields with comprehensive examples for LLMs
                    api_intro_paragraphs = gr.Textbox(
                        label="intro_paragraphs", 
                        value='["Experienced software engineer with 5+ years in full-stack development.", "Passionate about building scalable systems and leading technical teams."]',
                        placeholder='["Your intro paragraph 1", "Your intro paragraph 2"]',
                        lines=2
                    )
                    api_quick_guide_items = gr.Textbox(
                        label="quick_guide_items", 
                        value='["Python Expert", "Team Leadership", "System Architecture", "Agile Methodologies"]',
                        placeholder='["Skill 1", "Skill 2", "Skill 3"]',
                        lines=2
                    )
                    api_education = gr.Textbox(
                        label="education", 
                        value='[{"degree": "Master of Science", "institution": "MIT", "date_range": "2018-2020", "field_of_study": "Computer Science", "highlights": ["GPA: 3.9/4.0", "Thesis: Machine Learning Systems"]}]',
                        placeholder='[{"degree": "Your degree", "institution": "Your school", "date_range": "2018-2020", "field_of_study": "Your field", "highlights": ["Achievement 1"]}]',
                        lines=3
                    )
                    api_experience = gr.Textbox(
                        label="experience", 
                        value='[{"company": "Google", "role": "Senior Software Engineer", "location": "Mountain View, CA", "date_range": "2020-Present", "highlights": ["Led team of 8 engineers", "Improved system performance by 45%", "Launched 3 major features"]}]',
                        placeholder='[{"company": "Company Name", "role": "Your Role", "location": "City, Country", "date_range": "2020-Present", "highlights": ["Achievement 1", "Achievement 2"]}]',
                        lines=3
                    )
                    api_publications = gr.Textbox(
                        label="publications", 
                        value='[]',
                        placeholder='[{"title": "Paper Title", "authors": ["Author 1", "Author 2"], "date": "2023", "doi": "10.1000/xyz123"}]',
                        lines=1
                    )
                    api_projects = gr.Textbox(
                        label="projects", 
                        value='[{"title": "E-commerce Platform", "repo_url": "https://github.com/johndoe/ecommerce", "repo_label": "github.com/johndoe/ecommerce", "highlights": ["Built with React and Node.js", "Handles 10k+ concurrent users", "99.9% uptime"]}]',
                        placeholder='[{"title": "Project Name", "repo_url": "https://github.com/user/repo", "repo_label": "github.com/user/repo", "highlights": ["Feature 1", "Feature 2"]}]',
                        lines=2
                    )
                    api_languages = gr.Textbox(
                        label="languages", 
                        value='["Python", "JavaScript", "TypeScript", "Go", "Rust"]',
                        placeholder='["Language1", "Language2", "Language3"]',
                        lines=1
                    )
                    api_technologies = gr.Textbox(
                        label="technologies", 
                        value='["React", "Node.js", "Docker", "Kubernetes", "AWS", "PostgreSQL", "Redis"]',
                        placeholder='["Tech1", "Tech2", "Framework1", "Database1"]',
                        lines=1
                    )
                    
            api_resume_output = gr.File(label="Generated PDF Resume")
            api_resume_trigger = gr.Button("Generate Resume")


            # API: resume_generation_system_prompt - System prompt principal
            with gr.Row():
                api_system_output = gr.Textbox(label="System Prompt for Resume Generation", lines=15)
                api_system_trigger = gr.Button("Get System Prompt")
            

            # Hook API names to the triggers
            api_resume_trigger.click(
                fn=generate_resume_pdf,
                inputs=[
                    api_pdf_title, api_pdf_author, api_name, api_location, api_email, api_phone,
                    api_last_updated_text, api_website_url, api_website_label,
                    api_linkedin_url, api_linkedin_handle, api_github_url, api_github_handle,
                    api_intro_paragraphs, api_quick_guide_items, api_education, api_experience,
                    api_publications, api_projects, api_languages, api_technologies
                ],
                outputs=[api_resume_output],
                api_name="generate_resume_pdf"
            )
            
            api_system_trigger.click(
                fn=resume_generation_system_prompt,
                inputs=[],
                outputs=[api_system_output],
                api_name="resume_generation_system_prompt"
            )

    # Launch the interface with MCP server enabled
    # Following best practices from Gradio MCP documentation
    demo.launch(
        mcp_server=True,  # Enable MCP server
        server_name=server_host,
        server_port=server_port,
        share=False,  # No sharing for production/HF Spaces
        allowed_paths=[str(OUTPUT_DIR)],  # Allow access to generated PDFs
        show_api=True,  # Show API documentation
    )
    
    print(f"🚀 Resume Generator MCP Server is running!")
    print(f"📊 Web Interface: http://{server_host}:{server_port}")
    print(f"🔗 MCP Endpoint: http://{server_host}:{server_port}/gradio_api/mcp/sse")
    print(f"📋 API Schema: http://{server_host}:{server_port}/gradio_api/mcp/schema")


def main() -> None:
    import argparse

    parser = argparse.ArgumentParser(description="Générer le CV PDF depuis des données JSON ou lancer l'UI Gradio")
    parser.add_argument(
        "--serve",
        action="store_true",
        help="Lancer l'interface Gradio (au lieu du mode CLI)",
    )
    parser.add_argument(
        "--input-json",
        type=Path,
        required=False,
        help="Chemin du fichier JSON d'entrée (conforme au modèle Resume)",
    )
    parser.add_argument(
        "--template",
        type=str,
        default=TEMPLATE_NAME,
        help="Nom du fichier template (dans le dossier templates)",
    )
    parser.add_argument(
        "--server-host",
        type=str,
        default="127.0.0.1",
        help="Hôte pour l'UI Gradio (par défaut 127.0.0.1)",
    )
    parser.add_argument(
        "--server-port",
        type=int,
        default=7860,
        help="Port pour l'UI Gradio (par défaut 7860)",
    )
    parser.add_argument(
        "--out-dir",
        type=Path,
        default=OUTPUT_DIR,
        help="Dossier de sortie pour les fichiers générés (.tex, .pdf, artefacts LaTeX)",
    )
    # Suppression de l'argument --basename: le nom est toujours un UUID
    parser.add_argument(
        "--engine",
        type=str,
        choices=["tectonic", "latexmk"],
        default=None,
        help="Moteur de compilation LaTeX à privilégier (par défaut: latexmk sous Linux, sinon tectonic)",
    )
    parser.add_argument(
        "--out-tex",
        type=Path,
        default=None,
        help="Chemin du fichier .tex rendu (défaut: build/output.tex)",
    )
    parser.add_argument(
        "--out-pdf",
        type=Path,
        default=None,
        help="Chemin du PDF de sortie (défaut: build/output.pdf)",
    )
    args = parser.parse_args()

    # Mode serveur (UI Gradio)
    if args.serve:
        launch_gradio(server_host=args.server_host, server_port=args.server_port)
        return

    if not args.input_json:
        parser.error("--input-json est requis en mode CLI (sans --serve)")

    data = json.loads(args.input_json.read_text(encoding="utf-8"))

    # Nom de base: toujours un UUID
    base_name = uuid.uuid4().hex

    # Résoudre les chemins de sortie par défaut si non fournis
    out_tex = args.out_tex or (args.out_dir / f"{base_name}.tex")
    out_pdf = args.out_pdf or (args.out_dir / f"{base_name}.pdf")

    # Forcer le template classic par défaut si non précisé
    render_tex(data, out_tex, template_name=args.template or TEMPLATE_NAME)

    # Choix du moteur par défaut selon l'OS
    preferred_engine = args.engine
    if preferred_engine is None:
        preferred_engine = "latexmk" if platform.system() == "Linux" else "tectonic"

    compile_pdf(out_tex, out_pdf, engine_preference=preferred_engine)
    print(f"PDF généré: {out_pdf}")

if __name__ == "__main__":
    main()