Update app.py

app.py

@@ -1,4 +1,6 @@
-from flask import Flask, render_template, request, send_file, jsonify
+# --- 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
@@ -7,74 +9,109 @@ 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"  # Modèle avec "thinking" pour la génération complète
+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
-        subprocess.run(['pdflatex', '--version'], capture_output=True, check=True, timeout=10)
+        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:
-        return False, 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}"
+        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:
-        # Dans un environnement Flask, vous devrez configurer votre API key différemment
-        # Par exemple, en utilisant les variables d'environnement
+        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:
-        return None, f"Erreur lors de l'initialisation du client: {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):
-        return ""  # Retourne une chaîne vide si l'entrée n'est pas une chaîne
+        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 ``` ... ```)
-    if cleaned.startswith("```latex"):
-        cleaned = cleaned[8:]
-    elif cleaned.startswith("```"):
-         # Gère le cas où il y a un saut de ligne après ```
-        lines = cleaned.split('\n', 1)
-        if len(lines) > 1:
-            cleaned = lines[1]
-        else:
-            cleaned = cleaned[3:]  # Si pas de saut de ligne, juste enlever ```
+    # 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].strip()  # Enlève ``` et les espaces potentiels avant
+        cleaned = cleaned[:-3].rstrip() # Enlève ``` et les espaces/sauts de ligne potentiels avant
 
-    # Assure que le document commence correctement
-    if not cleaned.startswith("\\documentclass"):
-        pass  # On log un avertissement dans l'application web
+    # 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.
 
-    # Assure que le document se termine exactement par \end{document}
     end_doc_tag = "\\end{document}"
-    if end_doc_tag in cleaned:
-        end_idx = cleaned.rfind(end_doc_tag) + len(end_doc_tag)
-        cleaned = cleaned[:end_idx]
+    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:
-        # Ajoute seulement si \documentclass est présent pour éviter de créer un doc invalide
-        if cleaned.strip().startswith("\\documentclass"):
-             cleaned += f"\n{end_doc_tag}"
+         # 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]
 
-    return cleaned.strip()  # Retourne le résultat nettoyé
+
+    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):
@@ -97,65 +134,111 @@ Agis en tant qu'expert en mathématiques et tuteur pédagogue. Ton objectif est
 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}}`.
-2.  **Packages Requis:** Inclus impérativement les packages suivants via `\\usepackage{{...}}`: `amsmath`, `amssymb`, `geometry`, `hyperref`, `url`. Assure-toi qu'ils sont déclarés dans le préambule.
-3.  **Compilabilité:** Le code généré doit être valide et compilable sans erreur avec `pdflatex`.
-4.  **Formatage du Code:** Produis un code LaTeX propre, bien indenté et lisible.
-5.  **Environnements Mathématiques:** Utilise les environnements LaTeX appropriés (`align`, `equation`, `gather`, etc.) pour présenter les calculs et les équations de manière claire et standard.
-6.  **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.
+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.
-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.
-3.  **Rigueur:** Assure l'exactitude mathématique complète de la solution.
-4.  **Structure Logique:** Organise la solution de manière logique. Utilise des sections (`\\section*{{...}}`, `\\subsection*{{...}}`) si cela améliore la clarté pour des problèmes longs ou multi-parties.
+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.
-2.  **Résolution Étape par Étape:** Effectue la résolution mathématique complète en interne.
-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
+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,
-            ))
+                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)
-        if response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
-            for part in response.candidates[0].content.parts:
-                if getattr(part, 'thought', None):
-                    thinking_content = part.text
-                else:
-                    latex_content_raw = part.text
+        # 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 supplémentaire : est-ce que la mention obligatoire est présente ?
+
+            # 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:
-                # Tente de l'insérer avant \end{document}
-                end_doc_tag = "\\end{document}"
-                if end_doc_tag in latex_content_cleaned:
-                    latex_content_cleaned = latex_content_cleaned.replace(end_doc_tag, f"{LATEX_MENTION}\n{end_doc_tag}")
-                else:
-                    # Si \end{document} n'est pas là, ajoute les deux à la fin
-                    latex_content_cleaned += f"\n{LATEX_MENTION}\n{end_doc_tag}"
-                    
+                 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:
-            return None, thinking_content, "Aucun contenu LaTeX n'a été généré par le modèle."
+             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:
-         return None, None, "Génération stoppée (possible contenu inapproprié)"
+         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 ---
@@ -164,97 +247,175 @@ 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:
+    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:
-        tex_filename = "solution.tex"
-        pdf_filename = "solution.pdf"
+        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, "solution.log")  # Pour le débogage
+        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:
-            return None, f"Erreur lors de l'écriture du fichier .tex temporaire: {str(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={os.path.splitext(pdf_filename)[0]}",  # Nom sans extension
+            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 = []
-        
-        for pass_num in range(1, 3):  # Lance jusqu'à 2 passes
-            compile_log.append(f"Compilation LaTeX (Passe {pass_num})...")
+        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=True, text=True, 
-                                       encoding='utf-8', errors='replace', timeout=60)
-                compile_log.append(result.stdout)
-                # Vérifie si le PDF a été créé après la première passe (au moins)
+                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.CalledProcessError as e:
-                compile_log.append(f"Erreur lors de la compilation LaTeX (Passe {pass_num}).")
-                compile_log.append(f"Code de retour: {e.returncode}")
-                compile_log.append("Sortie de pdflatex (stdout):")
-                compile_log.append(e.stdout or "Aucune sortie standard.")
-                compile_log.append("Erreurs de pdflatex (stderr):")
-                compile_log.append(e.stderr or "Aucune sortie d'erreur.")
-                
-                # Essayer de lire le fichier .log pour plus d'infos
-                try:
-                    with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
-                        compile_log.append("Extrait du fichier log (solution.log):")
-                        compile_log.append(log_file.read()[-2000:])  # Affiche les dernières lignes
-                except IOError:
-                    compile_log.append("Impossible de lire le fichier log de LaTeX.")
-                
-                return None, "\n".join(compile_log)  # Arrête la compilation en cas d'erreur
-            
             except subprocess.TimeoutExpired:
-                 return None, "La compilation LaTeX a dépassé le délai imparti. Le document est peut-être trop complexe ou contient une boucle infinie."
+                 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:
-                 return None, f"Une erreur inattendue est survenue lors de l'exécution de pdflatex: {str(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 les 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()
-                return pdf_data, "PDF généré avec succès !"
+                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:
-                return None, f"Erreur lors de la lecture du fichier PDF généré: {str(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:
-            compile_log.append("Le fichier PDF n'a pas été généré après la compilation LaTeX.")
-            # Tenter de lire le log même si CalledProcessError n'a pas été levée
-            try:
-                with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
-                    compile_log.append("Extrait du fichier log (solution.log) après échec de génération PDF:")
-                    compile_log.append(log_file.read()[-2000:])
-            except IOError:
-                compile_log.append("Impossible de lire le fichier log de LaTeX.")
-            
-            return None, "\n".join(compile_log)
+            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,
@@ -263,85 +424,108 @@ def check_latex():
 
 @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
-        image = Image.open(file.stream)
-        
+        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": error_message or "Échec de la génération de la solution LaTeX"
+                "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": "Échec de la compilation PDF.", # Message générique pour l'utilisateur
                 "latex": latex_content,
                 "thinking": thinking_process,
-                "compilation_log": pdf_message
+                "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
+            "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 lors du traitement: {str(e)}"
+            "message": f"Erreur serveur inattendue lors du traitement: {str(e)}"
         })
 
-@app.route('/download-pdf', methods=['POST'])
-def download_pdf():
-    # Récupérer le contenu LaTeX
-    latex_content = request.form.get('latex')
-    if not latex_content:
-        return jsonify({"success": False, "message": "Aucun contenu LaTeX fourni"})
-    
-    # Compiler en PDF
-    pdf_data, pdf_message = compile_latex_to_pdf(latex_content)
-    
-    if not pdf_data:
-        return jsonify({"success": False, "message": pdf_message})
-    
-    # Créer un fichier temporaire pour le téléchargement
-    temp_pdf = tempfile.NamedTemporaryFile(delete=False)
-    temp_pdf.write(pdf_data)
-    temp_pdf.close()
-    
-    return send_file(
-        temp_pdf.name,
-        as_attachment=True,
-        download_name="solution_mariam_ai.pdf",
-        mimetype="application/pdf"
-    )
+# @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__':
-    app.run(debug=True)
+    # 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)