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 platform # Not strictly needed for app.py modifications
import re # Added

app = Flask(__name__)

# API Keys
GOOGLE_API_KEY = os.environ.get("GEMINI_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
# Assuming genai.Client and client.models.generate_content are part of user's specific library setup
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é 

"""

# 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:
        # Using timeout to prevent hanging if pdflatex is unresponsive
        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."""
    # Pattern for ```latex ... ```
    match_latex = re.search(r"```(?:latex|tex)\s*(.*?)\s*```", latex_code, re.DOTALL | re.IGNORECASE)
    if match_latex:
        return match_latex.group(1).strip()
    
    # Pattern for generic ``` ... ```, checking if it likely contains LaTeX
    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() # Default to stripping whitespace if no fences found

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."

    # Create a temporary directory for LaTeX compilation files
    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" # Ensure UTF-8 locale for pdflatex
            my_env["LANG"] = "C.UTF-8"
            
            last_result = None
            for i in range(2): # Run pdflatex twice for references, TOC, etc.
                # Added -file-line-error for more precise error messages
                # Added -halt-on-error to stop on first error (more efficient)
                # Note: -halt-on-error might prevent a second pass that could fix some issues.
                # For robustness, -interaction=nonstopmode is often preferred to try to complete.
                process = subprocess.run(
                    ["pdflatex", "-interaction=nonstopmode", "-output-directory", temp_dir_compile, tex_path],
                    capture_output=True, # Capture stdout and stderr
                    text=True,           # Decode output as text
                    check=False,         # Do not raise exception on non-zero exit code
                    encoding="utf-8",    # Specify encoding for output decoding
                    errors="replace",    # Replace undecodable characters
                    env=my_env,
                    timeout=120          # Timeout for pdflatex execution (e.g., 2 minutes)
                )
                last_result = process
                if not os.path.exists(pdf_path_in_compile_dir) and process.returncode != 0:
                    # If PDF not created and there was an error, no point in second pass
                    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."
                
                # Try to extract more specific error messages
                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) # Get first line of error
                    if match:
                        return None, f"Erreur de compilation PDF: {match.group(1).strip()}"
                
                # Generic error if specific parsing fails
                log_preview = error_log[-1000:] # Last 1000 characters of log for preview
                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é"""
    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é"""
    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: # Assuming text content
             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) # Increased timeout for larger files
        
        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):
    """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 = io.BytesIO()
        img.save(buffered, format="PNG") # Gemini prefers PNG or JPEG
        img_base64_str = base64.b64encode(buffered.getvalue()).decode()
        
        full_latex_response = ""
        
        try:
            task_results[task_id]['status'] = 'generating_latex'
            print(f"Task {task_id}: Génération LaTeX par Gemini...")
            
            # User's original model: "gemini-2.5-pro-exp-03-25"
            # Using "gemini-1.5-pro-latest" as a robust alternative. User can change if needed.
            # The user's original Gemini call structure:
            gemini_response = client.models.generate_content(
                model="gemini-1.5-pro-latest", 
                contents=[
                    {'inline_data': {'mime_type': 'image/png', 'data': img_base64_str}},
                    ppmqth 
                ]
                # Consider adding generation_config for token limits, temperature if needed
                # generation_config=genai.types.GenerationConfig(max_output_tokens=8192)
            )

            if gemini_response.candidates:
                candidate = gemini_response.candidates[0]
                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: # Fallback for simpler candidate structure
                     full_latex_response = candidate.text
            elif hasattr(gemini_response, 'text') and gemini_response.text: # Fallback for direct 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)}).")

            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}.tex",
                    caption=f"Code LaTeX pour tâche {task_id} (pdflatex non disponible)"
                )
                task_results[task_id]['status'] = 'completed_tex_only'
                task_results[task_id]['response'] = cleaned_latex
                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}"
            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"Solution PDF pour tâche {task_id}",
                    is_pdf=True
                )
                task_results[task_id]['status'] = 'completed'
                task_results[task_id]['response'] = cleaned_latex # Web UI still gets LaTeX source
            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}" # Store PDF specific error
                send_document_to_telegram(
                    cleaned_latex,
                    filename=f"solution_{task_id}.tex",
                    caption=f"Code LaTeX pour tâche {task_id} (Erreur PDF: {pdf_message[:150]})"
                )
                task_results[task_id]['response'] = cleaned_latex # Web UI gets LaTeX source
        
        except Exception as e_gen:
            print(f"Task {task_id}: Erreur lors de la génération Gemini ou traitement PDF: {e_gen}")
            task_results[task_id]['status'] = 'error'
            task_results[task_id]['error'] = f"Erreur de traitement: {str(e_gen)}"
            # Optionally send a simple text error to Telegram
            send_document_to_telegram(
                f"Erreur lors du traitement de la tâche {task_id}: {str(e_gen)}",
                filename=f"error_{task_id}.txt",
                caption=f"Erreur Tâche {task_id}"
            )
            task_results[task_id]['response'] = f"Erreur: {str(e_gen)}"


    except Exception as e_outer:
        print(f"Task {task_id}: Exception majeure dans la tâche de fond: {e_outer}")
        task_results[task_id]['status'] = 'error'
        task_results[task_id]['error'] = f"Erreur système: {str(e_outer)}"
        task_results[task_id]['response'] = f"Erreur système: {str(e_outer)}"
    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()
        
        # Envoyer l'image à Telegram (confirmation d'upload)
        send_to_telegram(image_data, f"Nouvelle image pour résolution (Tâche à venir)")
        
        task_id = str(uuid.uuid4())
        task_results[task_id] = {
            'status': 'pending',
            'response': '',
            'error': None,
            'time_started': time.time()
        }
        
        threading.Thread(
            target=process_image_background,
            args=(task_id, image_data)
        ).start()
        
        return jsonify({
            'task_id': task_id,
            'status': 'pending'
        })

    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]
    
    # Basic cleanup logic (can be improved with a dedicated cleanup thread)
    current_time = time.time()
    if task['status'] in ['completed', 'error', 'pdf_error', 'completed_tex_only'] and \
       (current_time - task.get('time_started', 0) > 3600): # Cleanup after 1 hour
        # del task_results[task_id] # Potentially remove, or mark for removal
        # For now, just don't error if it's old
        pass 
    
    response_data = {
        'status': task['status'],
        'response': task.get('response'),
        'error': task.get('error')
    }
    if task.get('error_detail'): # Include PDF specific error if present
        response_data['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
        while True:
            task = task_results.get(task_id)
            if not task: # Task might have been cleaned up
                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 == 'completed' or current_status == 'completed_tex_only':
                    data_to_send["response"] = task.get("response", "")
                elif current_status == 'error' or current_status == 'pdf_error':
                    data_to_send["error"] = task.get("error", "Erreur inconnue")
                    if task.get("error_detail"):
                         data_to_send["error_detail"] = task.get("error_detail")
                    if task.get("response"): # Send partial response if available on error
                        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 # End stream for terminal states
            
            time.sleep(1) # Check status every second
    
    return Response(
        stream_with_context(generate()),
        mimetype='text/event-stream',
        headers={
            'Cache-Control': 'no-cache',
            'X-Accel-Buffering': 'no', # Important for Nginx or other reverse proxies
            '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.")
    
    # For production, use a proper WSGI server like Gunicorn or uWSGI
    app.run(debug=True, host='0.0.0.0', port=5000)