app.py

from flask import Flask, render_template, request, jsonify, Response, stream_with_context
from google import genai # User's import
import os
from PIL import Image
import io
import base64
import json
import requests
import threading
import uuid
import time
import tempfile # Added
import subprocess # Added
import shutil # Added
import re # Added

app = Flask(__name__)

# API Keys
GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
# IMPORTANT: For production, move these to environment variables or a secure config
TELEGRAM_BOT_TOKEN = "8004545342:AAGcZaoDjYg8dmbbXRsR1N3TfSSbEiAGz88" 
TELEGRAM_CHAT_ID = "-1002497861230"

# Initialize Gemini client
if GOOGLE_API_KEY:
    try:
        client = genai.Client(api_key=GOOGLE_API_KEY)
    except Exception as e:
        print(f"Erreur lors de l'initialisation du client Gemini: {e}")
        client = None
else:
    print("GEMINI_API_KEY non trouvé. Le client Gemini ne sera pas initialisé.")
    client = None


ppmqth = r"""

**PROMPT AMÉLIORÉ**

# RÔLE & OBJECTIF
Tu es un expert en mathématiques du supérieur, un tuteur pédagogue exceptionnel, et un maître utilisateur de LaTeX. Ton objectif est de générer une correction LaTeX complète, rigoureuse, pédagogique et visuellement impeccable pour l'exercice de mathématiques fourni. Le résultat doit être un fichier source `.tex` autonome, directement compilable via `pdflatex`, et d'une qualité de présentation professionnelle, similaire à l'exemple fourni précédemment.

# CONTEXTE
*   **Input:** L'énoncé de l'exercice de mathématiques sera fourni sous forme de texte (copié/collé par l'utilisateur) immédiatement après ce prompt.
*   **Niveau Cible:** Élève de Terminale (système français, filière scientifique ou équivalent).
*   **Output Attendu:** **Uniquement** le code source LaTeX (`.tex`) brut et complet. Aucune explication ou texte d'accompagnement en dehors du code lui-même. Pas de marqueurs de code (comme ```latex ... ```).

# TÂCHE PRINCIPALE
1.  **Analyse:** Lis et comprends parfaitement l'énoncé de l'exercice fourni.
2.  **Résolution:** Résous l'exercice de manière exhaustive, en détaillant chaque étape de raisonnement et de calcul.
3.  **Rédaction LaTeX:** Rédige la solution complète *directement* en code LaTeX, en respectant **scrupuleusement** toutes les spécifications techniques, de style et de contenu ci-dessous.

# SPÉCIFICATIONS TECHNIQUES DU CODE LATEX

1.  **Document de Base:**
    *   Classe: `\documentclass[12pt,a4paper]{article}`
    *   Encodage: `\usepackage[utf8]{inputenc}`, `\usepackage[T1]{fontenc}`
    *   Langue: `\usepackage[french]{babel}`
    *   Police: `\usepackage{lmodern}` (Latin Modern)
    *   Typographie Fine: `\usepackage{microtype}`

2.  **Packages Indispensables (Configurer si nécessaire):**
    *   Maths: `amsmath`, `amssymb`, `amsfonts`, `mathtools`, `bm` (pour gras maths), `siunitx` (unités SI).
    *   Mise en Page: `geometry` (marges `a4paper, margin=2.5cm`), `setspace` (utiliser `\onehalfspacing`), `fancyhdr` (pour en-têtes/pieds), `titlesec` & `titletoc` (personnalisation titres/TDM), `multicol` (si besoin).
    *   Visuel & Couleurs: `xcolor` (définir les couleurs ci-dessous), `tcolorbox` (avec `theorems`, `skins`, `breakable`, `hooks`), `fontawesome5` (pour icônes).
    *   Liens & PDF: `hyperref` (configuré pour liens colorés, métadonnées PDF), `bookmark`.
    *   Graphiques: `tikz` (avec `calc`, `shapes`, `arrows.meta`, `positioning`), `pgfplots` (avec `compat=1.18`, `fillbetween`).

3.  **Configuration Générale:**
    *   Paragraphes: Pas d'indentation (`\setlength{\parindent}{0pt}`), espacement entre paragraphes (`\setlength{\parskip}{1.2ex plus 0.5ex minus 0.2ex}`).
    *   Compilabilité: Code valide pour `pdflatex`.

# STYLE & PRÉSENTATION PROFESSIONNELLE (Inspiré de l'exemple)

1.  **Couleurs à Définir (`\definecolor`):**
    *   `maincolor`: Bleu (e.g., `{RGB}{0, 90, 160}`)
    *   `secondcolor`: Vert-bleu (e.g., `{RGB}{0, 150, 136}`)
    *   `thirdcolor`: Violet (e.g., `{RGB}{140, 0, 140}`)
    *   `accentcolor`: Orange (e.g., `{RGB}{255, 140, 0}`)
    *   `ubgcolor`: Fond clair (e.g., `{RGB}{245, 247, 250}`)
    *   `codebackground`: Fond code (e.g., `{RGB}{245, 245, 245}`)
    *   `gridcolor`: Grille PGFPlots (e.g., `{RGB}{220, 220, 220}`)
    *   `asymptotecolor`: Asymptotes (e.g., `{RGB}{200, 0, 0}`)

2.  **Page de Titre / Présentation Initiale:**
    *   Créer une page de titre distincte (`titlepage`) ou un bloc titre élégant après `\begin{document}` utilisant `\maketitle` (redéfini si nécessaire).
    *   Inclure titre clair, sous-titre (e.g., "Exercice X: Solution Détaillée"), auteur générique (e.g., "Solution Proposée"), date (`\today`).
    *   Optionnel : Page séparée pour l'énoncé encadré et un plan de résolution avant la table des matières.

3.  **Structure & Navigation:**
    *   Table des matières (`\tableofcontents`) après la présentation initiale.
    *   En-têtes/Pieds de page (`fancyhdr`): Infos discrètes (titre exo, page), règles fines colorées.
    *   Titres (`titlesec`): Sections/sous-sections numérotées avec style distinctif (e.g., numéro dans cercle/rectangle coloré, ligne de séparation).

4.  **Boîtes `tcolorbox` Personnalisées (avec icônes `fontawesome5`):**
    *   `enoncebox` (Grisâtre, `\faBook`): Pour l'énoncé principal.
    *   `definitionbox` (Couleur secondaire, `\faLightbulb`): Pour définitions, théorèmes clés.
    *   `resultbox` (Couleur accent, `\faCheckCircle`): Pour les résultats finaux importants.
    *   `notebox` (Couleur tertiaire, `\faInfoCircle`): Pour remarques, astuces, points de méthode.
    *   `examplebox` (Vert, `\faClipboard`): Pour exemples illustratifs ou rappels de méthode.
    *   Configurer ces boîtes pour être `breakable`, avec titre stylisé.

5.  **Commandes Mathématiques Personnalisées (`\newcommand`):**
    *   Ensembles: `\R`, `\C`, `\N`, `\Z`, `\Q`.
    *   Limites: `\limx{}`, `\limxp{}`, `\limxm{}`, `\limsinf`, `\liminf`.
    *   Dérivées: `\derivee{}{} `, `\ddx{}`, `\dfdx{}`.
    *   Divers: `\abs{}`, `\norm{}`, `\vect{}`, `\ds` (`\displaystyle`).
    *   Mise en valeur: `\highlight{}` (fond jaune?), `\finalresult{}` (fond couleur accent?).
    *   Environnements: `importanteq` (pour équations clés encadrées, via `empheq`).

6.  **Graphiques (`pgfplots`):**
    *   Si pertinent (étude de fonction, géométrie): Inclure un graphique propre.
    *   Configurer `pgfplotsset`: Axes centrés (`axis lines=middle`), flèches (`-Latex`), grille (`grid=both`), labels (`xlabel`, `ylabel`), légende (`legend pos=...`), couleurs définies plus haut.
    *   Tracer la courbe principale (trait plein, couleur principale), asymptotes (pointillés, couleurs dédiées), points remarquables.

# CONTENU PÉDAGOGIQUE DE LA SOLUTION

1.  **Clarté et Rigueur:**
    *   Rappeler l'énoncé initialement dans `enoncebox`.
    *   Structurer la solution logiquement (par question, par étape).
    *   Justifier *chaque* étape de calcul ou de raisonnement.
    *   Utiliser un langage mathématique précis et une rédaction claire en français.
    *   Aligner soigneusement les équations (`align*`, `cases`).

2.  **Pédagogie:**
    *   Expliquer les "pourquoi" derrière les méthodes utilisées.
    *   Utiliser les `notebox` pour des conseils, pièges à éviter, ou rappels de cours.
    *   Mettre en évidence les définitions/théorèmes clés dans `definitionbox`.
    *   Encapsuler les résultats finaux dans `resultbox` ou avec `\finalresult`.

3.  **Complétude:**
    *   Traiter toutes les questions de l'énoncé.
    *   Inclure les interprétations graphiques demandées ou pertinentes.
    *   Conclure si nécessaire en résumant les points essentiels.

# CONTRAINTES STRICTES
*   Le seul output doit être le code LaTeX brut.
*   Aucun texte avant `\documentclass` ou après `\end{document}` (sauf la mention spéciale).
*   Inclure la ligne `Concu par Mariam AI` juste avant `\end{document}`.

rend  le très espacer. Ça doit être très aéré 

"""

PPMQTH_LIGHT = r"""
# RÔLE & OBJECTIF
Tu es un expert en mathématiques capable de fournir une solution claire et concise. Ton objectif est de générer une correction LaTeX directement compilable pour l'exercice fourni.

# CONTEXTE
*   **Input:** L'énoncé de l'exercice (texte).
*   **Niveau Cible:** Terminale (scientifique).
*   **Output Attendu:** **Uniquement** le code source LaTeX (`.tex`) brut et complet. Pas de texte d'accompagnement en dehors du code.

# TÂCHE PRINCIPALE
1.  **Analyse:** Comprends l'énoncé.
2.  **Résolution:** Résous l'exercice.
3.  **Rédaction LaTeX:** Rédige la solution en LaTeX standard.

# SPÉCIFICATIONS TECHNIQUES DU CODE LATEX (Minimal)
*   Classe: `\documentclass[12pt,a4paper]{article}`
*   Encodage: `\usepackage[utf8]{inputenc}`, `\usepackage[T1]{fontenc}`
*   Langue: `\usepackage[french]{babel}`
*   Maths: `\usepackage{amsmath}`, `\usepackage{amssymb}`
*   Optionnel: `\usepackage{graphicx}` si l'énoncé peut contenir des schémas à reproduire (rare pour du texte).
*   Pas de packages de mise en page complexes (pas de tcolorbox, fancyhdr, tikz, etc. sauf si *absolument* indispensable pour représenter la solution mathématique elle-même).
*   Utilise des environnements mathématiques standards (`align*`, `equation*`, `\[ ... \]`).

# CONTENU PÉDAGOGIQUE DE LA SOLUTION
*   Rappeler l'énoncé.
*   Structurer la solution logiquement.
*   Justifier les étapes principales.
*   Langage mathématique précis.

# CONTRAINTES STRICTES
*   Le seul output doit être le code LaTeX brut.
*   Aucun texte avant `\documentclass` ou après `\end{document}`.
*   Inclure la ligne `Concu par Mariam AI` juste avant `\end{document}`.
*   L'objectif est une solution fonctionnelle et lisible, sans mise en page sophistiquée.
"""


# Dictionnaire pour stocker les résultats des tâches en cours
task_results = {}

# --- LaTeX Helper Functions ---
def check_latex_installation():
    """Vérifie si pdflatex est installé sur le système"""
    try:
        subprocess.run(["pdflatex", "-version"], capture_output=True, check=True, timeout=10)
        print("INFO: pdflatex est installé et accessible.")
        return True
    except (FileNotFoundError, subprocess.TimeoutExpired, subprocess.CalledProcessError) as e:
        print(f"AVERTISSEMENT: pdflatex n'est pas installé ou ne fonctionne pas correctement: {e}")
        print("AVERTISSEMENT: La génération de PDF sera désactivée. Seuls les fichiers .tex seront envoyés.")
        return False

IS_LATEX_INSTALLED = check_latex_installation()

def clean_latex_code(latex_code):
    """Removes markdown code block fences (```latex ... ``` or ``` ... ```) if present."""
    match_latex = re.search(r"```(?:latex|tex)\s*(.*?)\s*```", latex_code, re.DOTALL | re.IGNORECASE)
    if match_latex:
        return match_latex.group(1).strip()
    
    match_generic = re.search(r"```\s*(\\documentclass.*?)\s*```", latex_code, re.DOTALL | re.IGNORECASE)
    if match_generic:
        return match_generic.group(1).strip()
        
    return latex_code.strip()

def latex_to_pdf(latex_code, output_filename_base="document"):
    """
    Converts LaTeX code to PDF.
    Returns: path_to_final_pdf (str) or None if error, message (str)
    The returned path_to_final_pdf is a temporary file that the caller is responsible for deleting.
    """
    if not IS_LATEX_INSTALLED:
        return None, "pdflatex n'est pas disponible sur le système."

    with tempfile.TemporaryDirectory() as temp_dir_compile:
        tex_filename = f"{output_filename_base}.tex"
        tex_path = os.path.join(temp_dir_compile, tex_filename)
        pdf_path_in_compile_dir = os.path.join(temp_dir_compile, f"{output_filename_base}.pdf")

        try:
            with open(tex_path, "w", encoding="utf-8") as tex_file:
                tex_file.write(latex_code)
            
            my_env = os.environ.copy()
            my_env["LC_ALL"] = "C.UTF-8" 
            my_env["LANG"] = "C.UTF-8"
            
            last_result = None
            for i in range(2): 
                process = subprocess.run(
                    ["pdflatex", "-interaction=nonstopmode", "-output-directory", temp_dir_compile, tex_path],
                    capture_output=True, 
                    text=True,           
                    check=False,         
                    encoding="utf-8",    
                    errors="replace",    
                    env=my_env,
                    timeout=120          
                )
                last_result = process
                if not os.path.exists(pdf_path_in_compile_dir) and process.returncode != 0:
                    break
            
            if os.path.exists(pdf_path_in_compile_dir):
                with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as temp_pdf_out_file:
                    shutil.copy(pdf_path_in_compile_dir, temp_pdf_out_file.name)
                    final_pdf_path = temp_pdf_out_file.name
                return final_pdf_path, f"PDF généré avec succès: {os.path.basename(final_pdf_path)}"
            else:
                error_log = last_result.stdout + "\n" + last_result.stderr if last_result else "Aucun résultat de compilation."
                
                if "LaTeX Error: File `" in error_log:
                    match = re.search(r"LaTeX Error: File `(.*?)' not found.", error_log)
                    if match:
                        return None, f"Erreur de compilation PDF: Fichier LaTeX manquant '{match.group(1)}'. Assurez-vous que tous les packages nécessaires (comme fontawesome5) sont installés."
                
                if "! Undefined control sequence." in error_log:
                     return None, "Erreur de compilation PDF: Commande LaTeX non définie. Vérifiez le code LaTeX pour des erreurs de syntaxe."

                if "! LaTeX Error:" in error_log:
                    match = re.search(r"! LaTeX Error: (.*?)\n", error_log) 
                    if match:
                        return None, f"Erreur de compilation PDF: {match.group(1).strip()}"
                
                log_preview = error_log[-1000:] 
                print(f"Erreur de compilation PDF complète pour {output_filename_base}:\n{error_log}")
                return None, f"Erreur lors de la compilation du PDF. Détails dans les logs du serveur. Aperçu: ...{log_preview}"
        
        except subprocess.TimeoutExpired:
            print(f"Timeout lors de la compilation de {output_filename_base}.tex")
            return None, "Timeout lors de la compilation du PDF. Le document est peut-être trop complexe ou contient une boucle infinie."
        except Exception as e:
            print(f"Exception inattendue lors de la génération du PDF ({output_filename_base}): {e}")
            return None, f"Exception inattendue lors de la génération du PDF: {str(e)}"


# --- Telegram Functions ---
def send_to_telegram(image_data, caption="Nouvelle image uploadée"):
    """Envoie l'image à un chat Telegram spécifié"""
    if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
        print("AVERTISSEMENT: TELEGRAM_BOT_TOKEN ou TELEGRAM_CHAT_ID non configuré. Envoi Telegram désactivé.")
        return False
    try:
        url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendPhoto"
        files = {'photo': ('image.png', image_data)}
        data = {'chat_id': TELEGRAM_CHAT_ID, 'caption': caption}
        response = requests.post(url, files=files, data=data, timeout=30)
        
        if response.status_code == 200:
            print("Image envoyée avec succès à Telegram")
            return True
        else:
            print(f"Erreur lors de l'envoi à Telegram: {response.status_code} - {response.text}")
            return False
    except requests.exceptions.RequestException as e:
        print(f"Exception Request lors de l'envoi à Telegram: {e}")
        return False
    except Exception as e:
        print(f"Exception générale lors de l'envoi à Telegram: {e}")
        return False

def send_document_to_telegram(content_or_path, filename="reponse.txt", caption="Réponse", is_pdf=False):
    """Envoie un fichier (texte ou PDF) à un chat Telegram spécifié"""
    if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
        print("AVERTISSEMENT: TELEGRAM_BOT_TOKEN ou TELEGRAM_CHAT_ID non configuré. Envoi Telegram désactivé.")
        return False
    try:
        url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendDocument"
        files = None
        
        if is_pdf:
            with open(content_or_path, 'rb') as f_pdf:
                files = {'document': (filename, f_pdf.read(), 'application/pdf')}
        else: 
             files = {'document': (filename, content_or_path.encode('utf-8'), 'text/plain')}
        
        data = {'chat_id': TELEGRAM_CHAT_ID, 'caption': caption}
        response = requests.post(url, files=files, data=data, timeout=60) 
        
        if response.status_code == 200:
            print(f"Document '{filename}' envoyé avec succès à Telegram.")
            return True
        else:
            print(f"Erreur lors de l'envoi du document '{filename}' à Telegram: {response.status_code} - {response.text}")
            return False
    except requests.exceptions.RequestException as e:
        print(f"Exception Request lors de l'envoi du document '{filename}' à Telegram: {e}")
        return False
    except Exception as e:
        print(f"Exception générale lors de l'envoi du document '{filename}' à Telegram: {e}")
        return False

# --- Background Image Processing ---
def process_image_background(task_id, image_data, prompt_type="refined"):
    """Traite l'image, génère LaTeX, convertit en PDF (si possible), et envoie via Telegram."""
    pdf_file_to_clean = None
    try:
        task_results[task_id]['status'] = 'processing'
        
        if not client:
            raise ConnectionError("Client Gemini non initialisé. Vérifiez la clé API et la configuration.")

        img = Image.open(io.BytesIO(image_data))
        buffered_for_gemini = io.BytesIO()
        img.save(buffered_for_gemini, format="PNG") 
        img_bytes_for_gemini = buffered_for_gemini.getvalue()
        
        full_latex_response = ""
        
        selected_prompt = ppmqth
        if prompt_type == "light":
            selected_prompt = PPMQTH_LIGHT
            print(f"Task {task_id}: Utilisation du prompt LÉGER.")
        else:
            print(f"Task {task_id}: Utilisation du prompt RAFFINÉ ET COMPLET.")

        try:
            task_results[task_id]['status'] = 'generating_latex'
            print(f"Task {task_id}: Génération LaTeX par Gemini...")
            
            gemini_response = client.models.generate_content(
                model="gemini-2.5-pro-exp-03-25", 
                contents=[
                     {'inline_data': {'mime_type': 'image/png', 'data': base64.b64encode(img_bytes_for_gemini).decode()}},
                    selected_prompt 
                ],
                generation_config={"response_mime_type": "text/plain"} 
            )

            if gemini_response.candidates:
                candidate = gemini_response.candidates[0]
                if candidate.finish_reason.name == "SAFETY": # Check for safety blocking
                     raise genai.types.BlockedPromptException("Contenu bloqué pour des raisons de sécurité.")
                if candidate.content and candidate.content.parts:
                    for part in candidate.content.parts:
                        if hasattr(part, 'text') and part.text:
                            full_latex_response += part.text
                elif hasattr(candidate, 'text') and candidate.text:
                     full_latex_response = candidate.text
            elif hasattr(gemini_response, 'text') and gemini_response.text: 
                full_latex_response = gemini_response.text
            
            if not full_latex_response.strip():
                raise ValueError("Gemini a retourné une réponse vide ou sans contenu textuel.")
            
            print(f"Task {task_id}: LaTeX brut reçu de Gemini (longueur: {len(full_latex_response)}).")

            task_results[task_id]['status'] = 'cleaning_latex'
            cleaned_latex = clean_latex_code(full_latex_response)
            print(f"Task {task_id}: LaTeX nettoyé (longueur: {len(cleaned_latex)}).")
            task_results[task_id]['response'] = cleaned_latex 

            caption_base = f"Solution tâche {task_id} (Style: {prompt_type})"

            if not IS_LATEX_INSTALLED:
                print(f"Task {task_id}: pdflatex non disponible. Envoi du .tex uniquement.")
                send_document_to_telegram(
                    cleaned_latex,
                    filename=f"solution_{task_id}_{prompt_type}.tex",
                    caption=f"{caption_base} - Code LaTeX (pdflatex non dispo)"
                )
                task_results[task_id]['status'] = 'completed_tex_only'
                return

            task_results[task_id]['status'] = 'generating_pdf'
            print(f"Task {task_id}: Génération du PDF...")
            pdf_filename_base = f"solution_{task_id}_{prompt_type}"
            pdf_file_to_clean, pdf_message = latex_to_pdf(cleaned_latex, output_filename_base=pdf_filename_base)

            if pdf_file_to_clean:
                print(f"Task {task_id}: PDF généré: {pdf_file_to_clean}. Envoi à Telegram...")
                send_document_to_telegram(
                    pdf_file_to_clean,
                    filename=f"{pdf_filename_base}.pdf",
                    caption=f"{caption_base} - PDF",
                    is_pdf=True
                )
                task_results[task_id]['status'] = 'completed'
            else:
                print(f"Task {task_id}: Échec de la génération PDF: {pdf_message}. Envoi du .tex en fallback.")
                task_results[task_id]['status'] = 'pdf_error'
                task_results[task_id]['error_detail'] = f"Erreur PDF: {pdf_message}" 
                send_document_to_telegram(
                    cleaned_latex,
                    filename=f"{pdf_filename_base}.tex",
                    caption=f"{caption_base} - Code LaTeX (Erreur PDF: {pdf_message[:100]})"
                )
        
        except genai.types.BlockedPromptException as e_blocked:
            error_msg = f"Prompt ou image bloqué par le filtre de sécurité Gemini: {e_blocked}"
            print(f"Task {task_id}: {error_msg}")
            task_results[task_id]['status'] = 'error'
            task_results[task_id]['error'] = "Le prompt ou l'image a été bloqué par le filtre de sécurité de l'IA. Essayez une autre image ou un prompt différent."
            if not task_results[task_id].get('response'):
                task_results[task_id]['response'] = task_results[task_id]['error']
            send_document_to_telegram(
                f"Erreur tâche {task_id}: {error_msg}",
                filename=f"error_{task_id}.txt",
                caption=f"Erreur Tâche {task_id} - Prompt Bloqué"
            )
        except Exception as e_gen:
            error_msg = f"Erreur lors de la génération Gemini ou traitement PDF: {e_gen}"
            print(f"Task {task_id}: {error_msg}")
            task_results[task_id]['status'] = 'error'
            task_results[task_id]['error'] = f"Erreur de traitement: {str(e_gen)}"
            if not task_results[task_id].get('response'): # S'il n'y a pas de LaTeX partiel
                 task_results[task_id]['response'] = task_results[task_id]['error']
            send_document_to_telegram(
                f"Erreur tâche {task_id}: {error_msg}\n\nLaTeX partiel (si disponible):\n{task_results[task_id].get('response','')}",
                filename=f"error_{task_id}.txt",
                caption=f"Erreur Tâche {task_id}"
            )

    except ConnectionError as e_conn:
        error_msg = f"Erreur de connexion Gemini: {e_conn}"
        print(f"Task {task_id}: {error_msg}")
        task_results[task_id]['status'] = 'error'
        task_results[task_id]['error'] = str(e_conn)
        task_results[task_id]['response'] = str(e_conn) # Mettre l'erreur dans response pour affichage

    except Exception as e_outer:
        error_msg = f"Exception majeure dans la tâche de fond: {e_outer}"
        print(f"Task {task_id}: {error_msg}")
        task_results[task_id]['status'] = 'error'
        task_results[task_id]['error'] = f"Erreur système: {str(e_outer)}"
        if not task_results[task_id].get('response'):
            task_results[task_id]['response'] = task_results[task_id]['error']
    finally:
        if pdf_file_to_clean and os.path.exists(pdf_file_to_clean):
            try:
                os.remove(pdf_file_to_clean)
                print(f"Task {task_id}: Fichier PDF temporaire '{pdf_file_to_clean}' supprimé.")
            except Exception as e_clean:
                print(f"Task {task_id}: Erreur lors de la suppression du PDF temporaire '{pdf_file_to_clean}': {e_clean}")

# --- Flask Routes ---
@app.route('/')
def index():
    return render_template('index.html')

@app.route('/solve', methods=['POST'])
def solve():
    try:
        if 'image' not in request.files:
            return jsonify({'error': 'Aucun fichier image fourni'}), 400
        
        image_file = request.files['image']
        if image_file.filename == '':
            return jsonify({'error': 'Aucun fichier sélectionné'}), 400

        image_data = image_file.read()
        
        prompt_type = request.form.get('prompt_type', 'refined') 
        
        send_to_telegram(image_data, f"Nouvelle image pour résolution (Style: {prompt_type}). Tâche à venir.")
        
        task_id = str(uuid.uuid4())
        task_results[task_id] = {
            'status': 'pending',
            'response': '',
            'error': None,
            'error_detail': None, # Pour les erreurs spécifiques PDF
            'time_started': time.time(),
            'prompt_type': prompt_type 
        }
        
        threading.Thread(
            target=process_image_background,
            args=(task_id, image_data, prompt_type)
        ).start()
        
        return jsonify({
            'task_id': task_id,
            'status': 'pending' # Le statut initial est pending, le thread mettra à jour
        })

    except Exception as e:
        print(f"Exception lors de la création de la tâche: {e}")
        return jsonify({'error': f'Une erreur serveur est survenue: {str(e)}'}), 500

@app.route('/task/<task_id>', methods=['GET'])
def get_task_status(task_id):
    if task_id not in task_results:
        return jsonify({'error': 'Tâche introuvable'}), 404
    
    task = task_results[task_id]
    
    response_data = {
        'status': task['status'],
        'response': task.get('response'),
        'error': task.get('error'),
        'error_detail': task.get('error_detail')
    }
        
    return jsonify(response_data)

@app.route('/stream/<task_id>', methods=['GET'])
def stream_task_progress(task_id):
    def generate():
        if task_id not in task_results:
            yield f'data: {json.dumps({"error": "Tâche introuvable", "status": "error"})}\n\n'
            return
        
        last_status_sent = None
        timeout_start = time.time() # Pour éviter que le stream ne dure indéfiniment
        MAX_STREAM_DURATION = 300 # 5 minutes max pour le stream

        while True:
            if time.time() - timeout_start > MAX_STREAM_DURATION:
                yield f'data: {json.dumps({"error": "Timeout du stream de statut", "status": "error"})}\n\n'
                break

            task = task_results.get(task_id)
            if not task: 
                yield f'data: {json.dumps({"error": "Tâche disparue ou nettoyée", "status": "error"})}\n\n'
                break
            
            current_status = task['status']
            
            if current_status != last_status_sent:
                data_to_send = {"status": current_status}
                if current_status in ['completed', 'completed_tex_only', 'pdf_error']:
                    data_to_send["response"] = task.get("response", "")
                if current_status in ['error', 'pdf_error']: # S'il y a une erreur générale ou spécifique au PDF
                    data_to_send["error"] = task.get("error", "Erreur inconnue")
                    if task.get("error_detail"):
                         data_to_send["error_detail"] = task.get("error_detail")
                    # Envoyer aussi la réponse (LaTeX partiel) s'il y en a une, même en cas d'erreur PDF
                    if task.get("response") and not data_to_send.get("response"): 
                        data_to_send["response"] = task.get("response")


                yield f'data: {json.dumps(data_to_send)}\n\n'
                last_status_sent = current_status
            
            if current_status in ['completed', 'error', 'pdf_error', 'completed_tex_only']:
                break 
            
            time.sleep(1) 
    
    return Response(
        stream_with_context(generate()),
        mimetype='text/event-stream',
        headers={
            'Cache-Control': 'no-cache',
            'X-Accel-Buffering': 'no', 
            'Connection': 'keep-alive'
        }
    )

if __name__ == '__main__':
    if not GOOGLE_API_KEY:
        print("CRITICAL: GEMINI_API_KEY variable d'environnement non définie. L'application risque de ne pas fonctionner.")
    if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
        print("CRITICAL: TELEGRAM_BOT_TOKEN ou TELEGRAM_CHAT_ID non définis. L'intégration Telegram échouera.")
    else:
        print(f"INFO: Prêt à envoyer des notifications Telegram au CHAT_ID: {TELEGRAM_CHAT_ID}")
    
    print(f"INFO: LaTeX est {'installé et activé' if IS_LATEX_INSTALLED else 'NON installé/activé. Les PDFs ne seront pas générés.'}")
    
    # For production, use a proper WSGI server like Gunicorn or uWSGI
    app.run(debug=True, host='0.0.0.0', port=5000)