app.py

# --- START OF FILE app - 2025-04-25T003524.273.py ---

from flask import Flask, render_template, request, send_file, jsonify, current_app
from google import genai
from google.genai import types
from PIL import Image
import subprocess
import tempfile
import os
import io
import base64
import logging # Importer le module de logging

# --- Constantes ---
MODEL_SINGLE_GENERATION = "gemini-2.5-pro-exp-03-25"
LATEX_MENTION = r"\vspace{1cm}\noindent\textit{Ce devoir a été généré par Mariam AI. \url{https://mariam-241.vercel.app}}"

app = Flask(__name__)

# Configuration du logging
logging.basicConfig(level=logging.DEBUG) # Afficher les messages DEBUG et supérieurs

# --- Fonctions Utilitaires ---
def check_latex_installation():
    """Vérifie si pdflatex est accessible dans le PATH système."""
    try:
        # Tente d'exécuter pdflatex pour vérifier son existence et son fonctionnement
        current_app.logger.info("Vérification de l'installation de pdflatex...")
        result = subprocess.run(['pdflatex', '--version'], capture_output=True, check=True, timeout=10, text=True, encoding='utf-8', errors='replace')
        current_app.logger.info(f"pdflatex trouvé. Version: {result.stdout.splitlines()[0]}")
        return True, "Installation LaTeX (pdflatex) trouvée."
    except (subprocess.CalledProcessError, FileNotFoundError, TimeoutError) as e:
        error_msg = f"pdflatex introuvable ou ne répond pas. Veuillez installer une distribution LaTeX (comme TeX Live ou MiKTeX) et vous assurer qu'elle est dans le PATH système. Erreur: {e}"
        current_app.logger.error(error_msg)
        # Si FileNotFoundError, donner plus de détails
        if isinstance(e, FileNotFoundError):
             error_msg += f"\nLe système ne trouve pas l'exécutable 'pdflatex'. Est-il dans le PATH ?"
        elif isinstance(e, TimeoutError):
             error_msg += f"\nLa commande 'pdflatex --version' a dépassé le délai. L'installation est peut-être corrompue."
        elif isinstance(e, subprocess.CalledProcessError):
             error_msg += f"\nLa commande 'pdflatex --version' a retourné une erreur: {e.stderr}"
        return False, error_msg
    except Exception as e:
        error_msg = f"Erreur inattendue lors de la vérification de pdflatex: {e}"
        current_app.logger.error(error_msg)
        return False, error_msg

def initialize_genai_client():
    """Initialise et retourne le client Google GenAI."""
    try:
        current_app.logger.info("Initialisation du client GenAI...")
        api_key = os.environ.get("GOOGLE_API_KEY")
        if not api_key:
            current_app.logger.error("Clé API Google non trouvée dans les variables d'environnement.")
            return None, "Clé API Google non trouvée dans les variables d'environnement."

        client = genai.Client(api_key=api_key, http_options={'api_version':'v1alpha'})
        # Test rapide de la connexion (optionnel mais utile)
        client.models.get_model(f'models/{MODEL_SINGLE_GENERATION}')
        current_app.logger.info("Client GenAI initialisé et modèle vérifié.")
        return client, "Client Mariam AI initialisé."
    except Exception as e:
        error_msg = f"Erreur lors de l'initialisation ou de la vérification du client GenAI: {e}"
        current_app.logger.error(error_msg)
        return None, error_msg


def clean_latex(raw_latex_text):
    """Nettoie le code LaTeX brut potentiellement fourni par Gemini."""
    if not isinstance(raw_latex_text, str):
        current_app.logger.warning("clean_latex reçu une entrée non-string.")
        return ""

    current_app.logger.debug(f"LaTeX brut reçu:\n{raw_latex_text[:500]}...\n...\n{raw_latex_text[-500:]}") # Log début et fin
    cleaned = raw_latex_text.strip()

    # Supprime les marqueurs de bloc de code (```latex ... ``` ou ``` ... ```) de manière plus robuste
    if cleaned.startswith("```"):
        cleaned = cleaned.split('\n', 1)[-1] # Prend tout après la première ligne
        if cleaned.startswith("latex"): # Gère le cas ```latex
            cleaned = cleaned[len("latex"):].lstrip() # Enlève 'latex' et espaces suivants

    # Supprime les marqueurs de fin de bloc de code
    if cleaned.endswith("```"):
        cleaned = cleaned[:-3].rstrip() # Enlève ``` et les espaces/sauts de ligne potentiels avant

    # Vérification de la structure minimale
    if not cleaned.strip().startswith("\\documentclass"):
        current_app.logger.warning("Code LaTeX nettoyé ne commence pas par \\documentclass.")
        # Ne pas ajouter \documentclass ici, car on ne sait pas quel type ou options sont nécessaires.
        # L'erreur de compilation qui suivra sera plus informative.

    end_doc_tag = "\\end{document}"
    if end_doc_tag not in cleaned:
         # Si \documentclass est présent mais pas \end{document}, c'est probablement une erreur de génération
         if cleaned.strip().startswith("\\documentclass"):
              current_app.logger.warning(f"Tag '{end_doc_tag}' manquant dans le LaTeX généré. Tentative d'ajout.")
              cleaned += f"\n{end_doc_tag}"
         else:
              # Si même \documentclass manque, le code est probablement inutile
              current_app.logger.error("Structure LaTeX de base manquante (\\documentclass et \\end{document}).")
              # On retourne quand même ce qu'on a, la compilation échouera.
              pass
    else:
         # Assurer qu'il n'y a rien après \end{document} (sauf des espaces/sauts de ligne)
         end_idx = cleaned.rfind(end_doc_tag) + len(end_doc_tag)
         trailing_content = cleaned[end_idx:].strip()
         if trailing_content:
             current_app.logger.warning(f"Contenu trouvé après {end_doc_tag} : '{trailing_content[:100]}...' - Suppression.")
             cleaned = cleaned[:end_idx]


    current_app.logger.debug(f"LaTeX nettoyé:\n{cleaned[:500]}...\n...\n{cleaned[-500:]}")
    return cleaned.strip() # Retourne le résultat nettoyé final

# --- Fonction Principale (API GenAI) ---
def generate_complete_latex(client, image):
    """
    Génère une solution complète en LaTeX à partir de l'image en une seule étape,
    en utilisant un modèle capable de "réfléchir" (thinking) et de produire un document bien formaté.
    """
    prompt = f"""
    # ROLE & OBJECTIF
Agis en tant qu'expert en mathématiques et tuteur pédagogue. Ton objectif est de créer une correction détaillée et irréprochable pour l'exercice mathématique présenté dans l'image fournie. La correction doit être sous forme de document LaTeX complet et directement compilable.

# CONTEXTE
- **Input:** Une image contenant un exercice de mathématiques.
- **Niveau Cible:** Élève de Terminale S (Lycée, filière scientifique française).
- **Output Attendu:** Un fichier source LaTeX (.tex) autonome.

# TÂCHE PRINCIPALE
1.  Analyse l'image pour comprendre parfaitement l'énoncé de l'exercice.
2.  Résous l'exercice de manière rigoureuse, étape par étape.
3.  Rédige la solution complète directement en code LaTeX, en respectant **toutes** les spécifications ci-dessous.

# SPÉCIFICATIONS TECHNIQUES DU CODE LATEX
1.  **Structure du Document:** Commence **strictement** par `\\documentclass{{article}}` et se termine **strictement** par `\\end{{document}}`. N'ajoute rien avant `\\documentclass` ou après `\\end{{document}}`.
2.  **Packages Requis:** Inclus impérativement les packages suivants dans le préambule (entre `\\documentclass` et `\\begin{{document}}`): `amsmath`, `amssymb`, `geometry` (avec `\\geometry{{a4paper, margin=2cm}}`), `hyperref` (charge-le en dernier si possible), `graphicx` (si des figures sont nécessaires), `inputenc` (avec `\\usepackage[utf8]{{inputenc}}`), `fontenc` (avec `\\usepackage[T1]{{fontenc}}`), `babel` (avec `\\usepackage[french]{{babel}}`), `url`.
3.  **Encodage:** Assure-toi que le document est encodé en UTF-8 (implicite avec `inputenc`). Utilise correctement les accents français (é, à, ç, etc.) directement ou via les commandes LaTeX appropriées si nécessaire.
4.  **Compilabilité:** Le code généré doit être valide et compilable sans erreur avec `pdflatex`. Évite les packages ou commandes obsolètes ou trop exotiques.
5.  **Formatage du Code:** Produis un code LaTeX propre, bien indenté et lisible.
6.  **Environnements Mathématiques:** Utilise les environnements LaTeX appropriés (`align`, `align*`, `equation`, `gather`, `cases`, etc.) pour présenter les calculs et les équations de manière claire et standard. Préfère `align*` pour les suites d'égalités non numérotées. Utilise `\( ... \)` ou `$ ... $` pour les maths en ligne, et `\[ ... \]` ou `$$ ... $$` (préférer `\[ ... \]` ou `equation*`) pour les maths hors ligne non numérotées.
7.  **AUCUN Marqueur de Code:** Le résultat doit être **uniquement** le code LaTeX brut. N'inclus **JAMAIS** de marqueurs de code comme ```latex ... ``` ou ``` ... ``` au début ou à la fin.

# STYLE & CONTENU DE LA SOLUTION
1.  **Pédagogie:** La correction doit être claire, aérée et facile à comprendre pour un élève de Terminale S. Utilise des phrases complètes.
2.  **Justifications:** Justifie **chaque** étape clé du raisonnement mathématique. Explique *pourquoi* une certaine méthode est utilisée ou *comment* on passe d'une étape à l'autre. N'hésite pas à rappeler brièvement une propriété ou une formule utilisée.
3.  **Rigueur:** Assure l'exactitude mathématique complète de la solution. Vérifie les calculs.
4.  **Structure Logique:** Organise la solution de manière logique. Numérote les questions si l'exercice en comporte plusieurs. Utilise des sections (`\\section*{{...}}`, `\\subsection*{{...}}`) si cela améliore la clarté pour des problèmes longs ou multi-parties. Commence par un titre simple comme `\\title*{{Correction de l'exercice}} \\date{{}} \\maketitle`.
5.  **Mention Obligatoire:** Insère la ligne suivante **exactement** telle quelle, juste avant la ligne `\\end{{document}}`:
    {LATEX_MENTION}

# PROCESSUS INTERNE RECOMMANDÉ (Pour l'IA)
1.  **Analyse Approfondie:** Décompose le problème en sous-étapes logiques. Identifie les concepts mathématiques clés.
2.  **Résolution Étape par Étape:** Effectue la résolution mathématique complète en interne. Sois très détaillé dans ton raisonnement.
3.  **Traduction en LaTeX:** Convertis ta résolution raisonnée en code LaTeX, en appliquant méticuleusement toutes les spécifications de formatage et de style demandées. Porte une attention particulière aux packages requis et à la structure du document. Vérifie que la mention obligatoire est bien placée.
    """
    try:
        current_app.logger.info(f"Génération LaTeX demandée au modèle {MODEL_SINGLE_GENERATION}...")
        response = client.models.generate_content(
            model=MODEL_SINGLE_GENERATION,
            contents=[image, prompt],
            config=types.GenerateContentConfig(
                temperature=0.3, # Température basse pour plus de consistance
                # max_output_tokens=8192, # Augmenter si nécessaire
            ),
            # request_options={'timeout': 120} # Timeout pour la requête API elle-même si besoin
            )

        latex_content_raw = None
        thinking_content = None

        # Extrait le contenu LaTeX et le raisonnement (thought)
        # La structure peut varier légèrement, tentons d'être robustes
        if response.candidates:
            candidate = response.candidates[0]
            if candidate.content and candidate.content.parts:
                 # Parfois le 'thought' est dans une part séparée, parfois attaché
                 if hasattr(candidate, 'thought') and candidate.thought:
                      thinking_content = candidate.thought
                 # Le contenu textuel est généralement la dernière partie
                 latex_content_raw = candidate.text # .text combine les parts textuelles
                 # Chercher explicitement le 'thought' dans les parts si non trouvé avant
                 if not thinking_content:
                     for part in candidate.content.parts:
                          if hasattr(part, 'thought') and part.thought:
                               thinking_content = part.thought
                               # Si le thought est dans une part, le latex brut est peut-être ailleurs
                               # Re-extraire le texte des autres parts si nécessaire
                               text_parts = [p.text for p in candidate.content.parts if not hasattr(p, 'thought')]
                               if text_parts:
                                    latex_content_raw = "\n".join(text_parts)
                               break # Supposons qu'il n'y a qu'un seul 'thought'

            # Log de ce qui a été extrait
            current_app.logger.info(f"Génération terminée. Contenu brut extrait: {'Oui' if latex_content_raw else 'Non'}, Thinking process extrait: {'Oui' if thinking_content else 'Non'}")
            if thinking_content:
                current_app.logger.debug(f"Thinking process:\n{thinking_content[:500]}...")

        else:
             current_app.logger.warning("Aucun candidat trouvé dans la réponse de l'API.")
             # Tenter de voir s'il y a une erreur dans la réponse 'prompt_feedback'
             if response.prompt_feedback and response.prompt_feedback.block_reason:
                  block_reason = response.prompt_feedback.block_reason.name
                  current_app.logger.error(f"Génération bloquée par l'API. Raison: {block_reason}")
                  safety_ratings = response.prompt_feedback.safety_ratings
                  current_app.logger.error(f"Safety Ratings: {safety_ratings}")
                  return None, None, f"Génération bloquée (Raison: {block_reason}). Vérifiez les Safety Ratings dans les logs serveur."
             else:
                  return None, None, "Aucun candidat retourné par l'API GenAI."


        if latex_content_raw:
            latex_content_cleaned = clean_latex(latex_content_raw)

            # Vérification et insertion de la mention obligatoire AVANT la balise de fin
            end_doc_tag = "\\end{document}"
            if LATEX_MENTION not in latex_content_cleaned:
                 current_app.logger.warning("Mention obligatoire non trouvée dans le LaTeX nettoyé. Tentative d'insertion.")
                 if end_doc_tag in latex_content_cleaned:
                     # Insère juste avant \end{document}
                     cleaned_parts = latex_content_cleaned.rsplit(end_doc_tag, 1)
                     latex_content_cleaned = cleaned_parts[0].rstrip() + f"\n{LATEX_MENTION}\n{end_doc_tag}" + cleaned_parts[1] # Conserve ce qui pourrait être après (même si clean_latex devrait l'enlever)
                 else:
                     # Si \end{document} manque (malgré clean_latex), on l'ajoute avec la mention
                     current_app.logger.warning(f"'{end_doc_tag}' manquait aussi. Ajout de la mention et de la balise à la fin.")
                     latex_content_cleaned += f"\n{LATEX_MENTION}\n{end_doc_tag}"
            else:
                 current_app.logger.info("Mention obligatoire trouvée dans le LaTeX nettoyé.")


            return latex_content_cleaned, thinking_content, None
        else:
             current_app.logger.error("Aucun contenu LaTeX brut n'a pu être extrait de la réponse de l'API.")
             return None, thinking_content, "Aucun contenu LaTeX n'a été généré ou extrait de la réponse de l'API."

    except types.StopCandidateException as e:
         current_app.logger.error(f"Génération stoppée par StopCandidateException: {e}")
         return None, None, f"Génération stoppée (possible contenu inapproprié ou autre raison interne à l'API): {e}"
    except Exception as e:
        current_app.logger.exception("Erreur imprévue lors de la génération du LaTeX via l'API GenAI.")
        return None, None, f"Erreur lors de la génération du LaTeX: {str(e)}"

# --- Fonction de Compilation LaTeX ---
def compile_latex_to_pdf(latex_content):
    """
    Compile une chaîne de caractères contenant du code LaTeX en fichier PDF.
    Utilise un répertoire temporaire pour les fichiers intermédiaires.
    """
    if not latex_content or not latex_content.strip():
        current_app.logger.error("Tentative de compilation de contenu LaTeX vide.")
        return None, "Impossible de compiler : contenu LaTeX vide."

    # Utilise un répertoire temporaire sécurisé qui sera nettoyé automatiquement
    with tempfile.TemporaryDirectory() as temp_dir:
        base_filename = "solution"
        tex_filename = f"{base_filename}.tex"
        pdf_filename = f"{base_filename}.pdf"
        log_filename = f"{base_filename}.log"
        aux_filename = f"{base_filename}.aux" # Aussi utile pour le debug

        tex_filepath = os.path.join(temp_dir, tex_filename)
        pdf_filepath = os.path.join(temp_dir, pdf_filename)
        log_filepath = os.path.join(temp_dir, log_filename)
        aux_filepath = os.path.join(temp_dir, aux_filename)

        current_app.logger.info(f"Tentative de compilation LaTeX dans le répertoire temporaire : {temp_dir}")
        current_app.logger.debug(f"Chemin du fichier .tex : {tex_filepath}")

        # Écrit le contenu LaTeX dans le fichier .tex avec encodage UTF-8
        try:
            with open(tex_filepath, "w", encoding="utf-8") as f:
                f.write(latex_content)
            current_app.logger.info(f"Fichier .tex écrit avec succès ({len(latex_content)} octets).")
        except IOError as e:
            error_msg = f"Erreur lors de l'écriture du fichier .tex temporaire: {str(e)}"
            current_app.logger.error(error_msg)
            return None, error_msg

        # Exécute pdflatex
        # -interaction=nonstopmode : N'attend pas d'input utilisateur en cas d'erreur
        # -halt-on-error : S'arrête à la première erreur (peut être utile pour debug, mais nonstopmode est plus courant pour l'automatisation)
        # -file-line-error : Affiche les erreurs avec nom de fichier et numéro de ligne
        command = [
            "pdflatex",
            "-interaction=nonstopmode",
            "-file-line-error",
            f"-output-directory={temp_dir}",
            f"-jobname={base_filename}", # Nom sans extension
            tex_filepath
        ]
        current_app.logger.info(f"Commande pdflatex (passe 1): {' '.join(command)}")

        pdf_generated = False
        compile_log_lines = [] # Stocke toutes les lignes de log (stdout, stderr, infos custom)
        max_passes = 2 # Généralement suffisant pour les références croisées/table des matières simples

        for pass_num in range(1, max_passes + 1):
            compile_log_lines.append(f"--- Compilation LaTeX (Passe {pass_num}/{max_passes}) ---")
            current_app.logger.info(f"Lancement de la passe {pass_num} de pdflatex...")
            try:
                # Augmentation du timeout pour les compilations potentiellement longues
                result = subprocess.run(command, capture_output=True, check=False, # check=False pour analyser nous-mêmes le résultat
                                       text=True, encoding='utf-8', errors='replace', timeout=90) # Timeout augmenté à 90s

                compile_log_lines.append(f"Code de retour pdflatex: {result.returncode}")
                compile_log_lines.append("--- Sortie Standard (stdout) ---")
                compile_log_lines.append(result.stdout if result.stdout else "Aucune sortie standard.")
                compile_log_lines.append("--- Sortie Erreur (stderr) ---")
                compile_log_lines.append(result.stderr if result.stderr else "Aucune sortie d'erreur.")

                # Essayer de lire le fichier .log de LaTeX pour des détails cruciaux
                log_content = ""
                try:
                    if os.path.exists(log_filepath):
                        with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
                            log_content = log_file.read()
                        compile_log_lines.append(f"--- Contenu du fichier log ({log_filename}) ---")
                        compile_log_lines.append(log_content)
                        current_app.logger.debug(f"Fichier log lu ({len(log_content)} octets).")
                    else:
                        compile_log_lines.append(f"--- Fichier log ({log_filename}) non trouvé. ---")
                        current_app.logger.warning(f"Fichier log non trouvé après la passe {pass_num}.")

                except IOError as log_e:
                    log_read_error = f"Impossible de lire le fichier log de LaTeX ({log_filename}): {log_e}"
                    compile_log_lines.append(f"--- ERREUR LECTURE LOG: {log_read_error} ---")
                    current_app.logger.error(log_read_error)


                # Vérification cruciale : le PDF existe-t-il ?
                if os.path.exists(pdf_filepath):
                    current_app.logger.info(f"Fichier PDF trouvé après la passe {pass_num}.")
                    pdf_generated = True
                    # Si le PDF est là et c'est la dernière passe, ou s'il n'y a pas d'erreurs majeures signalées
                    # dans le log (heuristique simple : chercher "!")
                    # et que le return code est 0 (ou même 1 parfois avec nonstopmode si le PDF est quand même généré)
                    # on pourrait arrêter plus tôt. Pour la robustesse, faisons les 2 passes si pas d'erreur fatale.
                    # Si une erreur fatale est détectée (e.g., "! LaTeX Error:"), on arrête.
                    if "! LaTeX Error:" in log_content or "Fatal error occurred" in log_content:
                         current_app.logger.error(f"Erreur fatale détectée dans le log LaTeX pendant la passe {pass_num}. Arrêt de la compilation.")
                         compile_log_lines.append("--- ERREUR FATALE DÉTECTÉE DANS LE LOG - COMPILATION INTERROMPUE ---")
                         return None, "\n".join(compile_log_lines)

                    # Si on est à la dernière passe et le PDF existe, c'est bon signe
                    if pass_num == max_passes:
                        break # Sortir de la boucle des passes

                else:
                    # Si le PDF n'existe pas après une passe, il y a un problème sérieux
                    current_app.logger.error(f"Fichier PDF non généré après la passe {pass_num}.")
                    compile_log_lines.append(f"--- ERREUR: Fichier PDF non trouvé après la passe {pass_num}. ---")
                    # Si le fichier log existe, il contient probablement la raison
                    if not log_content and os.path.exists(log_filepath): # Relire le log si pas déjà fait
                         try:
                            with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
                                log_content = log_file.read()
                            compile_log_lines.append(f"--- Contenu du fichier log ({log_filename}) après échec PDF ---")
                            compile_log_lines.append(log_content)
                         except IOError: pass # Déjà loggué plus haut si erreur de lecture
                    
                    # Inutile de faire une autre passe si la première a échoué si gravement
                    return None, "\n".join(compile_log_lines)


            except subprocess.TimeoutExpired:
                 timeout_msg = f"La compilation LaTeX (Passe {pass_num}) a dépassé le délai de {90} secondes. Le document est peut-être trop complexe ou contient une boucle infinie."
                 current_app.logger.error(timeout_msg)
                 compile_log_lines.append(f"--- ERREUR: TIMEOUT ({timeout_msg}) ---")
                 # Essayer de lire le log même après timeout
                 try:
                     if os.path.exists(log_filepath):
                         with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
                             compile_log_lines.append(f"--- Contenu partiel du log ({log_filename}) après timeout ---")
                             compile_log_lines.append(log_file.read()[-5000:]) # Derniers 5000 caractères
                 except IOError: pass
                 return None, "\n".join(compile_log_lines)

            except Exception as e:
                 exec_error = f"Une erreur inattendue est survenue lors de l'exécution de pdflatex (Passe {pass_num}): {str(e)}"
                 current_app.logger.exception(exec_error) # Log l'exception complète
                 compile_log_lines.append(f"--- ERREUR SYSTÈME PENDANT L'EXÉCUTION: {exec_error} ---")
                 return None, "\n".join(compile_log_lines)

        # Fin de la boucle des passes

        # Vérifie si le fichier PDF existe après toutes les passes
        if pdf_generated and os.path.exists(pdf_filepath):
            try:
                current_app.logger.info("Compilation terminée avec succès. Lecture du fichier PDF...")
                # Lit le contenu binaire du PDF généré
                with open(pdf_filepath, "rb") as f:
                    pdf_data = f.read()
                current_app.logger.info(f"PDF lu avec succès ({len(pdf_data)} octets).")
                # Retourner aussi une partie du log pour info, même en cas de succès
                success_log_summary = "\n".join(compile_log_lines[-10:]) # Dernières 10 lignes du log interne
                return pdf_data, f"PDF généré avec succès !\n--- Extrait final du log ---\n{success_log_summary}"
            except IOError as e:
                read_error = f"PDF généré mais erreur lors de la lecture du fichier: {str(e)}"
                current_app.logger.error(read_error)
                compile_log_lines.append(f"--- ERREUR LECTURE PDF: {read_error} ---")
                return None, "\n".join(compile_log_lines)
        else:
            current_app.logger.error("Le fichier PDF n'a pas été généré après toutes les passes de compilation.")
            compile_log_lines.append("--- ÉCHEC FINAL: Le fichier PDF n'a pas été trouvé après toutes les passes. ---")
            # Le log contient déjà les détails des erreurs des passes précédentes.
            return None, "\n".join(compile_log_lines)


@app.route('/')
def index():
    # Log l'accès à la page d'accueil
    current_app.logger.info(f"Requête reçue pour / par {request.remote_addr}")
    return render_template('index.html')

@app.route('/check-latex')
def check_latex():
    current_app.logger.info(f"Requête reçue pour /check-latex par {request.remote_addr}")
    latex_ok, message = check_latex_installation()
    return jsonify({
        "success": latex_ok,
        "message": message
    })

@app.route('/process-image', methods=['POST'])
def process_image():
    current_app.logger.info(f"Requête reçue pour /process-image par {request.remote_addr}")
    if 'image' not in request.files:
        current_app.logger.warning("Aucune image reçue dans la requête /process-image")
        return jsonify({"success": False, "message": "Aucune image téléchargée"})

    file = request.files['image']
    if file.filename == '':
        current_app.logger.warning("Nom de fichier vide dans la requête /process-image")
        return jsonify({"success": False, "message": "Aucun fichier sélectionné"})

    # Vérifier l'extension (simple vérification côté serveur)
    allowed_extensions = {'png', 'jpg', 'jpeg'}
    if '.' not in file.filename or file.filename.rsplit('.', 1)[1].lower() not in allowed_extensions:
         current_app.logger.warning(f"Type de fichier non autorisé: {file.filename}")
         return jsonify({"success": False, "message": "Type de fichier non autorisé. Utilisez PNG, JPG ou JPEG."})

    current_app.logger.info(f"Image reçue: {file.filename}, type: {file.mimetype}")

    try:
        # Initialisation du client GenAI
        client, client_message = initialize_genai_client()
        if not client:
            # Message déjà loggué dans initialize_genai_client
            return jsonify({"success": False, "message": client_message})

        # Traitement de l'image
        current_app.logger.info("Ouverture de l'image...")
        try:
            image = Image.open(file.stream)
             # Optionnel: Redimensionner si trop grande pour l'API ?
             # image.thumbnail((1024, 1024))
            current_app.logger.info(f"Image ouverte avec succès. Format: {image.format}, Taille: {image.size}")
        except Exception as img_e:
            current_app.logger.error(f"Erreur lors de l'ouverture de l'image: {img_e}")
            return jsonify({"success": False, "message": f"Impossible de lire le fichier image: {img_e}"})


        # Génération du LaTeX
        latex_content, thinking_process, error_message = generate_complete_latex(client, image)

        if error_message:
            current_app.logger.error(f"Erreur retournée par generate_complete_latex: {error_message}")
            # Ne pas retourner immédiatement s'il y a quand même du contenu LaTeX partiel
            # return jsonify({"success": False, "message": error_message})

        if not latex_content:
            current_app.logger.error("Échec final de la génération LaTeX, aucun contenu retourné.")
            # S'assurer qu'un message d'erreur est fourni
            final_error_msg = error_message or "Échec de la génération de la solution LaTeX par l'API."
            return jsonify({
                "success": False,
                "message": final_error_msg,
                "thinking": thinking_process # Retourner le thinking même si le latex a échoué
            })

        # S'il y avait une erreur non fatale mais qu'on a du contenu, on le logge et on continue
        if error_message:
             current_app.logger.warning(f"Erreur mineure durant la génération LaTeX ({error_message}), mais du contenu a été produit. Tentative de compilation...")


        # Compilation en PDF
        current_app.logger.info("Lancement de la compilation LaTeX vers PDF...")
        pdf_data, pdf_message = compile_latex_to_pdf(latex_content)

        if not pdf_data:
            current_app.logger.error(f"Échec de la compilation PDF. Message/Log: {pdf_message[:1000]}...") # Log début du message/log d'erreur
            return jsonify({
                "success": False,
                "message": "Échec de la compilation PDF.", # Message générique pour l'utilisateur
                "latex": latex_content,
                "thinking": thinking_process,
                "compilation_log": pdf_message # Le log complet est crucial ici
            })

        # Succès !
        current_app.logger.info("PDF généré et lu avec succès.")
        # Convertir le PDF en base64 pour l'affichage dans le navigateur
        pdf_base64 = base64.b64encode(pdf_data).decode('utf-8')
        current_app.logger.info(f"PDF encodé en base64 (longueur: {len(pdf_base64)}).")

        # Préparer les données de réponse
        return jsonify({
            "success": True,
            "message": "PDF généré avec succès",
            "latex": latex_content,
            "thinking": thinking_process,
            "pdf_base64": pdf_base64,
            "compilation_log": pdf_message # Retourner aussi le log de succès (peut contenir des warnings utiles)
        })

    except Exception as e:
        current_app.logger.exception("Erreur non gérée dans /process-image") # Log l'exception complète
        return jsonify({
            "success": False,
            "message": f"Erreur serveur inattendue lors du traitement: {str(e)}"
        })

# @app.route('/download-pdf', methods=['POST']) # Déprécié, téléchargement via JS+Base64
# def download_pdf():
#     # ... (gardé pour référence mais non utilisé par le frontend actuel)

if __name__ == '__main__':
    # Utiliser '0.0.0.0' pour rendre accessible sur le réseau local si besoin
    # debug=True active le rechargement auto et le débuggeur (NE PAS UTILISER EN PRODUCTION)
    app.run(debug=True, port=5000)