app.py

# --- IMPORTS ---
from flask import Flask, render_template, request, jsonify, Response, stream_with_context
from google import genai
import os
from google.genai import types
from PIL import Image
import io
import base64
import json
import requests
import threading
import uuid
import time
import tempfile
import subprocess
import shutil
import re

# --- FLASK APP INITIALIZATION ---
app = Flask(__name__)

# --- CONFIGURATION ---
# 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 = "-1002564204301"

# Gemini Client Initialization
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

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

# --- PROMPT DEFINITIONS ---
# All prompts are now defined directly in the code instead of separate files.

def get_prompt_extract_problem():
    """Prompt pour extraire l'énoncé mathématique à partir des fichiers."""
    return """
From the provided image(s) and/or PDF document, your task is to identify and extract the complete mathematical problem statement.

- Focus solely on the problem itself, including all conditions, variables, and the question being asked.
- Exclude any surrounding text like page numbers, author names, or irrelevant context.
- Format all mathematical expressions using TeX (e.g., $f(x) = x^2 - 1$, for all $x \in \mathbb{R}$).
- Your output must be ONLY the clean, extracted problem statement. Do not add any conversational text like "Here is the problem statement:".
"""

def get_prompt_light():
    """Prompt pour une solution simple et directe (style 'light')."""
    return """
Vous êtes un expert en mathématiques. Votre tâche est de fournir une solution claire et concise au problème soumis.
La sortie doit être un code LaTeX complet, propre et directement compilable.
La solution doit être bien expliquée, mais sans fioritures visuelles.
Structurez la solution avec des sections logiques.
Produisez UNIQUEMENT le code LaTeX.
"""

def get_prompt_colorful():
    """Prompt pour une solution pédagogique et colorée (style 'colorful')."""
    # Ce prompt est une copie directe de votre "prompt coloful".
    return r"""
# 📝 GÉNÉRATEUR DE CORRECTION MATHÉMATIQUE PROFESSIONNELLE

## 🎓 VOTRE RÔLE
Vous êtes **Mariam-MATHEX-PRO**, un système d'intelligence artificielle ultra-spécialisé dans la création de documents mathématiques parfaits. Vous combinez l'expertise d'un:
* 🧠 Professeur agrégé de mathématiques avec 25 ans d'expérience
* 🖋️ Expert LaTeX de niveau international
* 👨‍🏫 Pédagogue reconnu pour votre clarté exceptionnelle

Votre mission: transformer un simple énoncé mathématique en une correction LaTeX impeccable, aérée et pédagogiquement parfaite.

## 📊 FORMAT D'ENTRÉE ET SORTIE

**ENTRÉE:** L'énoncé d'un exercice mathématique (niveau Terminale/Supérieur)

**SORTIE:** UNIQUEMENT le code source LaTeX complet (.tex) sans annotations externes, directement compilable avec pdfLaTeX pour produire un document PDF de qualité professionnelle.

## 🌟 PRINCIPES FONDAMENTAUX

1. **DESIGN AÉRÉ ET ÉLÉGANT**
   * Utilisez généreusement l'espace vertical entre tous les éléments
   * Créez un document visuellement reposant avec beaucoup d'espaces blancs
   * Évitez absolument la densité visuelle et le texte compact

2. **EXCELLENCE PÉDAGOGIQUE**
   * Une seule étape de raisonnement par paragraphe
   * Développement méticuleux de chaque calcul sans sauts logiques
   * Mise en évidence claire des points clés et des résultats

3. **ESTHÉTIQUE PROFESSIONNELLE**
   * Utilisation experte de la couleur pour guider l'attention
   * Boîtes thématiques élégantes pour structurer l'information
   * Typographie mathématique irréprochable

## 🛠️ SPÉCIFICATIONS TECHNIQUES DÉTAILLÉES

### 📑 STRUCTURE DE BASE

```latex
\documentclass[12pt,a4paper]{article}

% --- PACKAGES FONDAMENTAUX ---
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[french]{babel}
\usepackage{lmodern}
\usepackage{microtype}

% --- PACKAGES MATHÉMATIQUES ---
\usepackage{amsmath,amssymb,amsfonts,mathtools}
\usepackage{bm}         % Gras en mode mathématique
\usepackage{siunitx}    % Unités SI

% --- MISE EN PAGE ---
\usepackage[a4paper,margin=2.5cm]{geometry}
\usepackage{setspace}
\usepackage{fancyhdr}
\usepackage{titlesec,titletoc}
\usepackage{multicol}
\usepackage{enumitem}   % Listes personnalisées

% --- ÉLÉMENTS VISUELS ---
\usepackage{xcolor}
\usepackage[most]{tcolorbox}
\usepackage{fontawesome5}
\usepackage{graphicx}

% --- GRAPHIQUES ---
\usepackage{tikz}
\usetikzlibrary{calc,shapes,arrows.meta,positioning}
\usepackage{pgfplots}
\pgfplotsset{compat=1.18}
\usepgfplotslibrary{fillbetween}

% --- HYPERLIENS ET MÉTADONNÉES ---
\usepackage{hyperref}
\usepackage{bookmark}

% --- ESPACEMENT EXTRA-AÉRÉ ---
\setlength{\parindent}{0pt}
\setlength{\parskip}{2.5ex plus 0.8ex minus 0.4ex}  % Espacement paragraphes généreux
\onehalfspacing  % Interligne 1.5
```

### 🎨 PALETTE DE COULEURS ET STYLES VISUELS

```latex
% --- DÉFINITION DES COULEURS ---
\definecolor{maincolor}{RGB}{30, 100, 180}        % Bleu principal
\definecolor{secondcolor}{RGB}{0, 150, 136}       % Vert-bleu
\definecolor{thirdcolor}{RGB}{140, 0, 140}        % Violet
\definecolor{accentcolor}{RGB}{255, 140, 0}       % Orange
\definecolor{ubgcolor}{RGB}{245, 250, 255}        % Fond bleuté très clair
\definecolor{lightgray}{RGB}{248, 248, 248}       % Gris très clair
\definecolor{gridcolor}{RGB}{220, 220, 220}       % Gris pour grilles
\definecolor{highlightcolor}{RGB}{255, 255, 200}  % Jaune clair pour surlignage
\definecolor{asymptotecolor}{RGB}{220, 0, 0}      % Rouge pour asymptotes

% --- CONFIGURATION DE PAGE ---
\pagestyle{fancy}
\fancyhf{}
\fancyhead[L]{\textcolor{maincolor}{\small\textit{Correction Mathématiques}}}
\fancyhead[R]{\textcolor{maincolor}{\small\thepage}}
\renewcommand{\headrulewidth}{0.2pt}
\renewcommand{\headrule}{\hbox to\headwidth{\color{maincolor}\leaders\hrule height \headrulewidth\hfill}}
\setlength{\headheight}{15pt}
\setlength{\headsep}{25pt}  % Plus d'espace sous l'en-tête

% --- CONFIGURATION DES TITRES DE SECTION ---
\titleformat{\section}
  {\normalfont\Large\bfseries\color{maincolor}}
  {\colorbox{maincolor}{\color{white}\thesection}}
  {1em}{}[\vspace{0.2cm}\titlerule[0.8pt]\vspace{0.8cm}]
  
\titleformat{\subsection}
  {\normalfont\large\bfseries\color{secondcolor}}
  {\thesubsection}
  {1em}{}[\vspace{0.5cm}]
  
\titlespacing*{\section}{0pt}{3.5ex plus 1ex minus .2ex}{2.3ex plus .2ex}
\titlespacing*{\subsection}{0pt}{3.25ex plus 1ex minus .2ex}{1.5ex plus .2ex}
```

### 📦 BOÎTES THÉMATIQUES AÉRÉES

```latex
% --- DÉFINITION DES BOÎTES THÉMATIQUES ---
\newtcolorbox{enoncebox}{
  enhanced,
  breakable,
  colback=lightgray!50,
  colframe=gray!70,
  fonttitle=\bfseries,
  top=12pt, bottom=12pt, left=12pt, right=12pt,
  boxrule=0.5pt,
  arc=3mm,
  title={\faBook\ Énoncé},
  attach boxed title to top left={xshift=0.5cm,yshift=-\tcboxedtitleheight/2},
  boxed title style={colback=gray!70, colframe=gray!70},
  before={\vspace{15pt}},
  after={\vspace{15pt}}
}

\newtcolorbox{definitionbox}{
  enhanced,
  breakable,
  colback=secondcolor!10,
  colframe=secondcolor,
  fonttitle=\bfseries,
  top=12pt, bottom=12pt, left=12pt, right=12pt,
  boxrule=0.5pt,
  arc=3mm,
  title={\faLightbulb\ Définition/Théorème},
  attach boxed title to top left={xshift=0.5cm,yshift=-\tcboxedtitleheight/2},
  boxed title style={colback=secondcolor, colframe=secondcolor, color=white},
  before={\vspace{15pt}},
  after={\vspace{15pt}}
}

\newtcolorbox{resultbox}{
  enhanced,
  breakable,
  colback=accentcolor!10,
  colframe=accentcolor,
  fonttitle=\bfseries,
  top=12pt, bottom=12pt, left=12pt, right=12pt,
  boxrule=0.5pt,
  arc=3mm,
  title={\faCheckCircle\ Résultat},
  attach boxed title to top left={xshift=0.5cm,yshift=-\tcboxedtitleheight/2},
  boxed title style={colback=accentcolor, colframe=accentcolor, color=white},
  before={\vspace{15pt}},
  after={\vspace{15pt}}
}

\newtcolorbox{notebox}{
  enhanced,
  breakable,
  colback=thirdcolor!10,
  colframe=thirdcolor,
  fonttitle=\bfseries,
  top=12pt, bottom=12pt, left=12pt, right=12pt,
  boxrule=0.5pt,
  arc=3mm,
  title={\faInfoCircle\ Remarque/Astuce},
  attach boxed title to top left={xshift=0.5cm,yshift=-\tcboxedtitleheight/2},
  boxed title style={colback=thirdcolor, colframe=thirdcolor, color=white},
  before={\vspace{15pt}},
  after={\vspace{15pt}}
}

\newtcolorbox{examplebox}{
  enhanced,
  breakable,
  colback=green!10,
  colframe=green!70!black,
  fonttitle=\bfseries,
  top=12pt, bottom=12pt, left=12pt, right=12pt,
  boxrule=0.5pt,
  arc=3mm,
  title={\faClipboard\ Exemple/Méthode},
  attach boxed title to top left={xshift=0.5cm,yshift=-\tcboxedtitleheight/2},
  boxed title style={colback=green!70!black, colframe=green!70!black, color=white},
  before={\vspace{15pt}},
  after={\vspace{15pt}}
}
```

### 🧮 COMMANDES MATHÉMATIQUES PERSONNALISÉES

```latex
% --- COMMANDES MATHÉMATIQUES ---
\newcommand{\R}{\mathbb{R}}
\newcommand{\C}{\mathbb{C}}
\newcommand{\N}{\mathbb{N}}
\newcommand{\Z}{\mathbb{Z}}
\newcommand{\Q}{\mathbb{Q}}

\newcommand{\limx}[1]{\lim_{x \to #1}}
\newcommand{\limxp}[1]{\lim_{x \to #1^+}}
\newcommand{\limxm}[1]{\lim_{x \to #1^-}}
\newcommand{\limsinf}{\lim_{n \to +\infty}}
\newcommand{\liminf}{\lim_{x \to +\infty}}

\newcommand{\derivee}[2]{\frac{d#1}{d#2}}
\newcommand{\ddx}[1]{\frac{d}{dx}\left(#1\right)}
\newcommand{\dfdx}[1]{\frac{df}{dx}\left(#1\right)}

\newcommand{\abs}[1]{\left|#1\right|}
\newcommand{\norm}[1]{\left\|#1\right\|}
\newcommand{\vect}[1]{\overrightarrow{#1}}
\newcommand{\ds}{\displaystyle}

\newcommand{\highlight}[1]{\colorbox{highlightcolor}{$#1$}}
\newcommand{\finalresult}[1]{\colorbox{accentcolor!20}{$\displaystyle #1$}}

% Environnement pour équations importantes
\newcommand{\boxedeq}[1]{%
  \begin{center}
    \begin{tcolorbox}[
      enhanced,
      colback=ubgcolor,
      colframe=maincolor,
      arc=3mm,
      boxrule=0.5pt,
      left=10pt,right=10pt,top=6pt,bottom=6pt
    ]
      $\displaystyle #1$
    \end{tcolorbox}
  \end{center}
}

% Configuration pour espacement des listes
\setlist{itemsep=8pt, parsep=4pt}

% Configuration des environnements mathématiques pour plus d'espacement
\setlength{\abovedisplayskip}{12pt plus 3pt minus 7pt}
\setlength{\belowdisplayskip}{12pt plus 3pt minus 7pt}
\setlength{\abovedisplayshortskip}{7pt plus 2pt minus 4pt}
\setlength{\belowdisplayshortskip}{7pt plus 2pt minus 4pt}
```

### 📊 CONFIGURATION DE GRAPHIQUES

```latex
% --- CONFIGURATION DE PGFPLOTS POUR GRAPHIQUES ---
\pgfplotsset{
  every axis/.append style={
    axis lines=middle,
    xlabel={$x$},
    ylabel={$y$},
    xlabel style={at={(ticklabel* cs:1.05)}, anchor=west},
    ylabel style={at={(ticklabel* cs:1.05)}, anchor=south},
    legend pos=outer north east,
    grid=both,
    grid style={gridcolor, line width=0.1pt},
    tick align=outside,
    minor tick num=4,
    enlargelimits={abs=0.2},
    axis line style={-Latex, line width=0.6pt},
    xmajorgrids=true,
    ymajorgrids=true,
    ticklabel style={font=\footnotesize}
  }
}
```

### 🖌️ MODÈLE DE PAGE DE TITRE

```latex
% --- PAGE DE TITRE ÉLÉGANTE ---
\newcommand{\maketitlepage}[2]{%
  \begin{titlepage}
    \centering
    \vspace*{2cm}
    {\Huge\bfseries\color{maincolor} Correction Mathématiques\par}
    \vspace{1.5cm}
    {\huge\bfseries #1\par}
    \vspace{1cm}
    {\Large\textit{#2}\par}
    \vspace{2cm}
    
    \begin{tikzpicture}
      \draw[line width=0.5pt, maincolor] (0,0) -- (12,0);
      \foreach \x in {0,1,...,12} {
        \draw[line width=1pt, maincolor] (\x,0) -- (\x,-0.2);
      }
      \draw[line width=0.5pt, secondcolor] (0,-0.6) -- (12,-0.6);
    \end{tikzpicture}
    
    \vspace{1.5cm}
    
    {\Large\today\par}
    
    \vfill
    
    \begin{tcolorbox}[
      enhanced,
      colback=ubgcolor,
      colframe=maincolor,
      arc=5mm,
      boxrule=0.5pt,
      width=0.8\textwidth
    ]
      \centering
      \large\textit{Document généré avec soin pour une clarté et une pédagogie optimales}
    \end{tcolorbox}
    
    \vspace{1cm}
  \end{titlepage}
}

% Configuration hyperref pour liens colorés
\hypersetup{
    colorlinks=true,
    linkcolor=maincolor,
    filecolor=secondcolor,
    urlcolor=thirdcolor,
    pdfauthor={},
    pdftitle={Correction Mathématiques},
    pdfsubject={},
    pdfkeywords={}
}
```

## 🔄 STRUCTURE DU DOCUMENT COMPLET

```latex
\begin{document}

% Page de titre élégante
\maketitlepage{Titre de l'Exercice}{Solution Détaillée et Commentée}

% Espacement après la page de titre
\newpage
\vspace*{1cm}

% Table des matières distincte et aérée
\begingroup
\setlength{\parskip}{8pt}
\tableofcontents
\endgroup

\vspace{2cm}
\begin{enoncebox}
    [TEXTE COMPLET DE L'ÉNONCÉ]
\end{enoncebox}

\vspace{1.5cm}

\section{Première partie de la résolution}
\vspace{0.8cm}

[SOLUTION DÉTAILLÉE]

\vspace{1.2cm}
\section{Deuxième partie de la résolution}
\vspace{0.8cm}

[SUITE DE LA SOLUTION]

% Et ainsi de suite...

{Mariam AI}
\end{document}
```

## 💡 INSTRUCTIONS POUR UNE PRÉSENTATION ULTRA-AÉRÉE

1. **ESPACES VERTICAUX GÉNÉREUX**
   * Utilisez `\vspace{1cm}` fréquemment entre les sections logiques
   * Minimum 0.8cm d'espace après chaque titre de section
   * Au moins 0.5cm d'espace avant/après chaque environnement mathématique
   * Ne lésinez JAMAIS sur les espacements verticaux

2. **FORMULATION DE LA SOLUTION**
   * Une seule idée par paragraphe, jamais plus
   * Espacez généreusement les étapes des raisonnements
   * Insérez une ligne vide avant ET après chaque équation ou bloc d'équations
   * Utilisez abondamment les environnements thématiques avec leurs espacements inclus

3. **MISE EN VALEUR VISUELLE**
   * Encadrez chaque résultat principal dans une `resultbox`
   * Isolez les définitions et rappels théoriques dans des `definitionbox`
   * Utilisez `\boxedeq{}` pour les formules clés qui méritent attention
   * Alternez paragraphes textuels courts et expressions mathématiques pour créer du rythme visuel

## ⭐ RÉSULTAT FINAL ATTENDU

Le document final doit:
* Être EXTRÊMEMENT aéré, avec beaucoup plus d'espace blanc que de contenu
* Présenter un équilibre parfait entre texte explicatif et développements mathématiques
* Guider visuellement l'attention grâce aux couleurs et aux encadrements
* Faciliter la compréhension par la décomposition méthodique et l'espacement généreux

✅ PRODUISEZ UNIQUEMENT LE CODE LATEX COMPLET, rien d'autre.
"""

def get_prompt_for_style(style):
    """Retourne le prompt approprié selon le style."""
    if style == 'light':
        return get_prompt_light()
    else:  # 'colorful' par défaut
        return get_prompt_colorful()

# --- MATH SOLVER PIPELINE ---
# La logique du pipeline de résolution est maintenant intégrée ici.

# Configuration du pipeline
SOLVER_MODEL_NAME = "gemini-1.5-pro-latest"
SOLVER_MAX_ITERATIONS = 5
SOLVER_PASSES_NEEDED = 2
SOLVER_TEMPERATURE = 0.1

def _get_solver_prompt_initial(problem_statement):
    return f"### Core Instructions ###\n*   **Rigor is Paramount:** Your primary goal is to produce a complete and rigorously justified solution. Every step must be logically sound.\n*   **Honesty About Completeness:** If you cannot find a complete solution, present only significant partial results you can rigorously prove.\n*   **Use TeX for All Mathematics:** All mathematical elements must be in TeX (e.g., $n \in \mathbb{{Z}}$).\n\n### Output Format ###\nYour response MUST be structured into these sections:\n**1. Summary**\n*   **a. Verdict:** State if the solution is complete or partial.\n*   **b. Method Sketch:** A high-level outline of your argument.\n**2. Detailed Solution**\nThe full, step-by-step mathematical proof.\n\n### Self-Correction Instruction ###\nReview your work to ensure it is clean, rigorous, and adheres to all instructions.\n\n### Problem ###\n{problem_statement}"

def _get_solver_prompt_improve(solution_attempt):
    return f"You are a world-class mathematician. Review the following draft solution for flaws, gaps, or clarity issues.\nThen, produce a new, improved, and more rigorous version. Do not comment on the changes, just provide the final, clean proof.\n\n### Draft Solution ###\n{solution_attempt}\n\n### Improved Solution ###"

def _get_solver_prompt_verifier(problem_statement, solution_to_verify):
    return f"You are an expert IMO grader. Your task is to rigorously verify the provided solution. A solution is correct ONLY if every step is justified. Do NOT correct errors, only report them.\n\n### Instructions ###\n1.  **Core Instructions:** Find and report all issues.\n2.  **Issue Classification:**\n    *   **a. Critical Error:** An error that breaks the proof's logic. Stop verifying dependant steps.\n    *   **b. Justification Gap:** A correct but insufficiently justified step. Assume it's true and continue verifying.\n3.  **Output Format:**\n    *   **a. Summary:**\n        *   **Final Verdict:** A single sentence (e.g., \"The solution is correct.\").\n        *   **List of Findings:** A bulleted list of every issue found.\n    *   **b. Detailed Verification Log:** A step-by-step analysis.\n\n---\n### Problem ###\n{problem_statement}\n\n---\n### Solution ###\n{solution_to_verify}\n---\n### Verification Task Reminder ###\nGenerate the summary and the step-by-step verification log."

def _get_solver_prompt_correction(solution_attempt, verification_report):
    return f"You are a brilliant mathematician. Your previous solution has been reviewed.\nYour task is to write a new, corrected version of your solution that meticulously addresses all issues raised in the verifier's report.\n\n### Verification Report on Your Last Attempt ###\n{verification_report}\n\n### Your Previous Flawed Solution ###\n{solution_attempt}\n\n### Your Task ###\nProvide a new, complete, and rigorously correct solution that fixes all identified issues. Follow the original structured output format (Summary and Detailed Solution)."

def _call_solver_llm(prompt, task_id, step_name):
    """Fonction d'appel LLM spécifique pour le pipeline de résolution."""
    print(f"Task {task_id}: [Math Solver] - {step_name}...")
    try:
        response = client.models.generate_content(
            model=SOLVER_MODEL_NAME,
            contents=[prompt],
            generation_config={"temperature": SOLVER_TEMPERATURE}
        )
        time.sleep(2)  # Éviter de surcharger l'API
        return response.text
    except Exception as e:
        print(f"Task {task_id}: An error occurred with the LLM API during '{step_name}': {e}")
        return None

def _parse_verifier_verdict(report):
    if not report: return "ERROR"
    report_lower = report.lower()
    if "the solution is correct" in report_lower: return "CORRECT"
    if "critical error" in report_lower: return "CRITICAL_ERROR"
    if "justification gap" in report_lower: return "GAPS"
    return "UNKNOWN"

def run_solver_pipeline(problem_statement, task_id, task_results):
    """Orchestrateur du pipeline de résolution mathématique."""
    # Étape 1: Génération Initiale
    task_results[task_id]['status'] = 'solving_generating'
    initial_prompt = _get_solver_prompt_initial(problem_statement)
    current_solution = _call_solver_llm(initial_prompt, task_id, "Initial Generation")
    if not current_solution: return "Failed at initial generation."

    # Étape 2: Auto-Amélioration
    task_results[task_id]['status'] = 'solving_improving'
    improve_prompt = _get_solver_prompt_improve(current_solution)
    current_solution = _call_solver_llm(improve_prompt, task_id, "Self-Improvement")
    if not current_solution: return "Failed at self-improvement."

    # Étape 3-5: Boucle de Vérification et Correction
    iteration = 0
    consecutive_passes = 0
    while iteration < SOLVER_MAX_ITERATIONS:
        iteration += 1
        task_results[task_id]['status'] = f'solving_verifying_iter_{iteration}'
        verifier_prompt = _get_solver_prompt_verifier(problem_statement, current_solution)
        verification_report = _call_solver_llm(verifier_prompt, task_id, f"Verification (Iter {iteration})")
        if not verification_report: break
        
        verdict = _parse_verifier_verdict(verification_report)
        if verdict == "CORRECT":
            consecutive_passes += 1
            print(f"Task {task_id}: [Math Solver] - PASS! Consecutive: {consecutive_passes}/{SOLVER_PASSES_NEEDED}")
            if consecutive_passes >= SOLVER_PASSES_NEEDED:
                print(f"Task {task_id}: [Math Solver] - Solution verified. Exiting loop.")
                return current_solution
        else:
            consecutive_passes = 0
            task_results[task_id]['status'] = f'solving_correcting_iter_{iteration}'
            correction_prompt = _get_solver_prompt_correction(current_solution, verification_report)
            new_solution = _call_solver_llm(correction_prompt, task_id, f"Correction (Iter {iteration})")
            if not new_solution: break
            current_solution = new_solution
    
    print(f"Task {task_id}: [Math Solver] - Solver finished. Returning last valid solution.")
    return current_solution


# --- HELPER FUNCTIONS (LaTeX, Telegram, etc.) ---
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 non installé ou non fonctionnel: {e}")
        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."""
    if not IS_LATEX_INSTALLED:
        return None, "pdflatex n'est pas disponible sur le système."
    with tempfile.TemporaryDirectory() as temp_dir_compile:
        tex_path = os.path.join(temp_dir_compile, f"{output_filename_base}.tex")
        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"
            last_result = None
            for _ in range(2): # Run twice for references
                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
                )
                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):
                temp_pdf_out_file = tempfile.NamedTemporaryFile(suffix=".pdf", delete=False)
                shutil.copy(pdf_path_in_compile_dir, temp_pdf_out_file.name)
                return temp_pdf_out_file.name, "PDF généré avec succès."
            else:
                error_log = last_result.stdout if last_result else "Aucun résultat de compilation."
                print(f"Erreur de compilation PDF pour {output_filename_base}:\n{error_log}")
                match_error = re.search(r"! LaTeX Error: (.*?)\n", error_log)
                if match_error: return None, f"Erreur de compilation PDF: {match_error.group(1).strip()}"
                return None, f"Erreur lors de la compilation du PDF. Détails dans les logs du serveur."
        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)}"

def send_to_telegram(file_data, filename, caption="Nouveau fichier"):
    """Envoie un fichier (image ou PDF) à un chat Telegram."""
    try:
        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
            url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendPhoto"
            files = {'photo': (filename, file_data)}
        else:
            url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendDocument"
            files = {'document': (filename, file_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(f"Fichier '{filename}' envoyé avec succès à Telegram")
            return True
        else:
            print(f"Erreur envoi Telegram: {response.status_code} - {response.text}")
            return False
    except Exception as e:
        print(f"Exception envoi Telegram: {e}")
        return False

def send_document_to_telegram(content_or_path, filename="reponse.txt", caption="Réponse", is_pdf=False):
    """Envoie un document texte ou PDF à Telegram."""
    try:
        url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendDocument"
        data = {'chat_id': TELEGRAM_CHAT_ID, 'caption': caption}
        if is_pdf:
            with open(content_or_path, 'rb') as f:
                files = {'document': (filename, f.read(), 'application/pdf')}
                response = requests.post(url, files=files, data=data, timeout=60)
        else: # Text content
            files = {'document': (filename, content_or_path.encode('utf-8'), 'text/plain')}
            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 envoi document Telegram: {response.status_code} - {response.text}")
            return False
    except Exception as e:
        print(f"Exception envoi document Telegram: {e}")
        return False

# --- BACKGROUND FILE PROCESSING (Main Logic) ---
def process_files_background(task_id, files_data, resolution_style='colorful'):
    """Traite les fichiers, applique le pipeline de résolution et génère le PDF final."""
    pdf_file_to_clean = None
    uploaded_file_refs = []
    
    try:
        task_results[task_id]['status'] = 'processing'
        if not client: raise ConnectionError("Client Gemini non initialisé.")

        # Préparer le contenu initial pour Gemini (images/PDFs)
        initial_contents = []
        for file_info in files_data:
            file_type = file_info['type']
            file_data = file_info['data']
            if file_type.startswith('image/'):
                img = Image.open(io.BytesIO(file_data))
                buffered = io.BytesIO()
                img.save(buffered, format="PNG")
                img_base64_str = base64.b64encode(buffered.getvalue()).decode()
                initial_contents.append({'inline_data': {'mime_type': 'image/png', 'data': img_base64_str}})
            elif file_type == 'application/pdf':
                with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_pdf:
                    temp_pdf.write(file_data)
                    file_ref = client.files.upload(file=temp_pdf.name)
                    uploaded_file_refs.append(file_ref)
                    initial_contents.append(file_ref)
                    os.unlink(temp_pdf.name)
        
        if not initial_contents: raise ValueError("Aucun contenu valide trouvé.")
            
        full_latex_response = ""
        if resolution_style == 'colorful':
            # PIPELINE AVANCÉ
            task_results[task_id]['status'] = 'extracting_problem'
            print(f"Task {task_id}: Étape 1 - Extraction de l'énoncé...")
            extraction_response = client.models.generate_content(
                model=SOLVER_MODEL_NAME, contents=[*initial_contents, get_prompt_extract_problem()])
            problem_statement_text = extraction_response.text
            print(f"Task {task_id}: Énoncé extrait: {problem_statement_text[:200]}...")

            print(f"Task {task_id}: Étape 2 - Lancement du pipeline de résolution mathématique...")
            rigorous_solution_text = run_solver_pipeline(problem_statement_text, task_id, task_results)
            if not rigorous_solution_text: raise ValueError("Le pipeline de résolution n'a pas retourné de solution.")

            task_results[task_id]['status'] = 'designing_pdf'
            print(f"Task {task_id}: Étape 3 - Génération du document LaTeX final...")
            colorful_prompt_template = get_prompt_for_style('colorful')
            final_design_prompt = f"{colorful_prompt_template}\n\n---\n## CONTENU À METTRE EN FORME\n\n### ÉNONCÉ DE L'EXERCICE\n```\n{problem_statement_text}\n```\n\n### SOLUTION RIGIOUREUSE À METTRE EN PAGE\n```\n{rigorous_solution_text}\n```\n\nMaintenant, produis le code source LaTeX complet et uniquement le code."
            gemini_response = client.models.generate_content(model=SOLVER_MODEL_NAME, contents=[final_design_prompt])
            full_latex_response = gemini_response.text
        else:
            # PIPELINE SIMPLE (style 'light')
            task_results[task_id]['status'] = 'generating_latex'
            print(f"Task {task_id}: Génération LaTeX simple (style: {resolution_style})...")
            prompt_to_use = get_prompt_for_style(resolution_style)
            gemini_response = client.models.generate_content(model=SOLVER_MODEL_NAME, contents=[*initial_contents, prompt_to_use])
            full_latex_response = gemini_response.text

        # --- Traitement commun : Compilation PDF et envoi ---
        if not full_latex_response.strip(): raise ValueError("Gemini a retourné une réponse vide.")
        
        task_results[task_id]['status'] = 'cleaning_latex'
        cleaned_latex = clean_latex_code(full_latex_response)
        
        if not IS_LATEX_INSTALLED:
            print(f"Task {task_id}: pdflatex non disponible. Envoi du .tex uniquement.")
            send_document_to_telegram(cleaned_latex, f"solution_{task_id}.tex", f"Code LaTeX pour tâche {task_id}")
            task_results[task_id]['status'] = 'completed_tex_only'
            task_results[task_id]['response'] = cleaned_latex
            return

        task_results[task_id]['status'] = 'generating_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:
            send_document_to_telegram(pdf_file_to_clean, f"{pdf_filename_base}.pdf", f"Solution PDF pour tâche {task_id}", is_pdf=True)
            task_results[task_id]['status'] = 'completed'
            task_results[task_id]['response'] = cleaned_latex
        else:
            task_results[task_id]['status'] = 'pdf_error'
            task_results[task_id]['error_detail'] = f"Erreur PDF: {pdf_message}"
            send_document_to_telegram(cleaned_latex, f"solution_{task_id}.tex", f"Code LaTeX (Erreur PDF: {pdf_message[:150]})")
            task_results[task_id]['response'] = cleaned_latex

    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)}"
    finally:
        if pdf_file_to_clean and os.path.exists(pdf_file_to_clean):
            try:
                os.remove(pdf_file_to_clean)
            except Exception as e_clean:
                print(f"Task {task_id}: Erreur suppression PDF temp: {e_clean}")
        # Les références de fichiers Gemini expirent automatiquement

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

@app.route('/free')
def free():
    return render_template('index.html')

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

        resolution_style = request.form.get('style', 'colorful')
        files_data = []
        for file in uploaded_files:
            if file.filename != '':
                file_data = file.read()
                file_type = file.content_type or 'application/octet-stream'
                if file_type.startswith('image/') or file_type == 'application/pdf':
                    files_data.append({'filename': file.filename, 'data': file_data, 'type': file_type})
                    send_to_telegram(file_data, file.filename, f"Mariam(Pro) - Style: {resolution_style}")
        
        if not files_data: return jsonify({'error': 'Aucun fichier valide (images/PDF acceptés)'}), 400
        
        task_id = str(uuid.uuid4())
        task_results[task_id] = {'status': 'pending', 'response': ''}
        
        threading.Thread(target=process_files_background, args=(task_id, files_data, resolution_style)).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'Erreur serveur: {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]
    return jsonify({
        'status': task.get('status'),
        'response': task.get('response'),
        'error': task.get('error'),
        'error_detail': task.get('error_detail')
    })

@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:
                yield f'data: {json.dumps({"error": "Tâche disparue", "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']:
                    data_to_send["error"] = task.get("error", "Erreur")
                    if task.get("error_detail"): data_to_send["error_detail"] = task.get("error_detail")
                
                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')

# --- MAIN EXECUTION BLOCK ---
if __name__ == '__main__':
    if not GOOGLE_API_KEY:
        print("CRITICAL: GOOGLE_API_KEY non définie.")
    if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
        print("CRITICAL: Variables Telegram non définies.")
    
    app.run(debug=True, host='0.0.0.0', port=5000)