Update app.py

app.py

@@ -10,6 +10,7 @@ import requests
 from werkzeug.utils import secure_filename
 import markdown # Pour convertir la réponse en HTML
 from flask_session import Session # <-- Importer Session
+import pprint # Pour un affichage plus lisible des structures complexes (optionnel)
 
 # --- Configuration Initiale ---
 load_dotenv()
@@ -36,22 +37,17 @@ app.config['SESSION_TYPE'] = 'filesystem'  # Indique d'utiliser le stockage par
 app.config['SESSION_PERMANENT'] = False  # La session expire quand le navigateur est fermé
 app.config['SESSION_USE_SIGNER'] = True  # Signe l'ID de session dans le cookie pour sécurité
 app.config['SESSION_FILE_DIR'] = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'flask_session') # Chemin où stocker les fichiers de session
-# os.path.join(...) crée un chemin vers un dossier nommé 'flask_session'
-# à côté de votre fichier app.py
 
 # Crée le dossier pour les sessions filesystem s'il n'existe pas
 os.makedirs(app.config['SESSION_FILE_DIR'], exist_ok=True)
 print(f"Dossier pour les sessions serveur configuré : {app.config['SESSION_FILE_DIR']}")
 
-
 # --- Initialisation de Flask-Session ---
-# Doit être fait APRÈS avoir défini la configuration de session
-server_session = Session(app) # <-- Lie l'extension à votre application
+server_session = Session(app)
 
 # --- Configuration de l'API Gemini ---
-MODEL_FLASH = 'gemini-2.0-flash' # Default model
-MODEL_PRO = 'gemini-2.5-pro-exp-03-25' # Advanced model
-# ASSUREZ-VOUS QUE SYSTEM_INSTRUCTION EST BIEN DÉFINI ICI OU CHARGÉ
+MODEL_FLASH = 'gemini-2.0-flash'
+MODEL_PRO = 'gemini-2.5-pro-exp-03-25'
 SYSTEM_INSTRUCTION = "Tu es un assistant intelligent et amical nommé Mariam. Tu assistes les utilisateurs au mieux de tes capacités. Tu as été créé par Aenir."
 SAFETY_SETTINGS = [
     {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
@@ -66,8 +62,6 @@ try:
         print("ERREUR: Clé API GOOGLE_API_KEY manquante dans le fichier .env")
     else:
         genai.configure(api_key=gemini_api_key)
-        # Just configure, don't create model instance yet
-        # Check if we can list models as a basic configuration test
         models_list = [m.name for m in genai.list_models()]
         if f'models/{MODEL_FLASH}' in models_list and f'models/{MODEL_PRO}' in models_list:
              print(f"Configuration Gemini effectuée. Modèles requis ({MODEL_FLASH}, {MODEL_PRO}) disponibles.")
@@ -94,111 +88,74 @@ def perform_web_search(query):
     if not serper_api_key:
         print("AVERTISSEMENT: Clé API SERPER_API_KEY manquante. Recherche web désactivée.")
         return None
-
     search_url = "https://google.serper.dev/search"
-    headers = {
-        'X-API-KEY': serper_api_key,
-        'Content-Type': 'application/json'
-    }
-    payload = json.dumps({"q": query, "gl": "fr", "hl": "fr"}) # Ajout localisation FR
-
+    headers = {'X-API-KEY': serper_api_key, 'Content-Type': 'application/json'}
+    payload = json.dumps({"q": query, "gl": "fr", "hl": "fr"})
     try:
-        print(f"Recherche Serper pour: '{query}'")
+        print(f"--- LOG WEBSEARCH: Recherche Serper pour: '{query}'")
         response = requests.post(search_url, headers=headers, data=payload, timeout=10)
-        response.raise_for_status() # Lève une exception pour les erreurs HTTP (4xx, 5xx)
+        response.raise_for_status()
         data = response.json()
-        print("Résultats de recherche Serper obtenus.")
-        # print(json.dumps(data, indent=2)) # Décommenter pour voir les résultats bruts
+        print("--- LOG WEBSEARCH: Résultats de recherche Serper obtenus.")
         return data
-    except requests.exceptions.Timeout:
-        print("Erreur lors de la recherche web : Timeout")
-        return None
     except requests.exceptions.RequestException as e:
-        print(f"Erreur lors de la recherche web : {e}")
-        # Essayer de lire le corps de la réponse d'erreur si possible
-        try:
-            error_details = e.response.json()
-            print(f"Détails de l'erreur Serper: {error_details}")
-        except:
-            pass # Ignorer si le corps n'est pas JSON ou n'existe pas
+        print(f"--- LOG WEBSEARCH: Erreur lors de la recherche web : {e}")
         return None
     except json.JSONDecodeError as e:
-        print(f"Erreur lors du décodage de la réponse JSON de Serper : {e}")
-        print(f"Réponse reçue (texte brut) : {response.text}")
+        print(f"--- LOG WEBSEARCH: Erreur JSON Serper : {e}")
         return None
 
 def format_search_results(data):
     """Met en forme les résultats de recherche (format Markdown)."""
-    if not data:
-        return "Aucun résultat de recherche web trouvé pertinent."
-
+    if not data: return "Aucun résultat de recherche web trouvé pertinent."
     results = []
-
-    # Réponse directe (Answer Box)
     if data.get('answerBox'):
         ab = data['answerBox']
         title = ab.get('title', '')
         snippet = ab.get('snippet') or ab.get('answer', '')
-        if snippet:
-            results.append(f"**Réponse rapide : {title}**\n{snippet}\n")
-
-    # Knowledge Graph
+        if snippet: results.append(f"**Réponse rapide : {title}**\n{snippet}\n")
     if data.get('knowledgeGraph'):
         kg = data['knowledgeGraph']
         title = kg.get('title', '')
         type = kg.get('type', '')
         description = kg.get('description', '')
-        if title and description:
-             results.append(f"**{title} ({type})**\n{description}\n")
+        if title and description: results.append(f"**{title} ({type})**\n{description}\n")
         if kg.get('attributes'):
-             results.append("\n**Attributs :**") # Ajout titre pour clarté
-             for attr, value in kg['attributes'].items():
-                  results.append(f"- {attr}: {value}")
-             results.append("") # Ligne vide après les attributs
-
-
-    # Résultats organiques
+             results.append("\n**Attributs :**")
+             for attr, value in kg['attributes'].items(): results.append(f"- {attr}: {value}")
+             results.append("")
     if data.get('organic'):
         results.append("**Pages web pertinentes :**")
-        for i, item in enumerate(data['organic'][:3], 1): # Top 3
+        for i, item in enumerate(data['organic'][:3], 1):
             title = item.get('title', 'Sans titre')
             link = item.get('link', '#')
             snippet = item.get('snippet', 'Pas de description.')
             results.append(f"{i}. **[{title}]({link})**\n   {snippet}\n")
-
-    # People Also Ask
     if data.get('peopleAlsoAsk'):
         results.append("**Questions liées :**")
-        for i, item in enumerate(data['peopleAlsoAsk'][:2], 1): # Top 2
-             results.append(f"- {item.get('question', '')}")
-
-
-    if not results:
-        return "Aucun résultat structuré trouvé dans la recherche web."
-
+        for i, item in enumerate(data['peopleAlsoAsk'][:2], 1): results.append(f"- {item.get('question', '')}")
+    if not results: return "Aucun résultat structuré trouvé dans la recherche web."
+    print(f"--- LOG WEBSEARCH: Résultats formatés (début): '{(' '.join(results))[:100]}...'")
     return "\n".join(results)
 
 def prepare_gemini_history(chat_history):
     """Convertit l'historique stocké en session au format attendu par Gemini API."""
+    print(f"--- DEBUG [prepare_gemini_history]: Entrée avec {len(chat_history)} messages") # LOG 1
     gemini_history = []
-    # Itérer sur une copie pour éviter les problèmes si on modifie pendant l'itération (peu probable ici mais bonne pratique)
-    for message in list(chat_history):
+    for i, message in enumerate(list(chat_history)): # Utiliser list() pour itérer sur une copie
         role = 'user' if message.get('role') == 'user' else 'model'
-        # Utiliser le 'raw_text' stocké pour Gemini
-        text_part = message.get('raw_text') # Utiliser get pour éviter KeyError si 'raw_text' manque
-        if text_part is None:
-             print(f"AVERTISSEMENT: 'raw_text' manquant pour un message {role}, utilisation de 'text'. Message: {message.get('text', '')[:50]}...")
-             text_part = message.get('text', '') # Fallback vers 'text' si raw_text est absent
-
-        # Vérifier si text_part n'est pas vide avant d'ajouter
-        if text_part:
+        text_part = message.get('raw_text')
+        # Log détaillé pour chaque message traité
+        print(f"  [prepare_gemini_history] Message {i} (rôle session: {message.get('role')}, rôle gemini: {role}): raw_text présent? {'Oui' if text_part is not None else 'NON'}, contenu début: '{str(text_part)[:60]}...'") # LOG 2
+
+        if text_part: # Important: Ne pas ajouter de messages vides à l'historique Gemini
             parts = [text_part]
-            # NOTE: La gestion des fichiers des tours PRÉCÉDENTS n'est pas gérée ici.
-            # L'API generate_content se concentre généralement sur le fichier du tour ACTUEL.
             gemini_history.append({'role': role, 'parts': parts})
         else:
-            print(f"AVERTISSEMENT: Message vide détecté et ignoré pour l'historique Gemini (role: {role}).")
+            # Log si un message est ignoré car vide
+            print(f"  AVERTISSEMENT [prepare_gemini_history]: raw_text vide ou absent pour le message {i}, ignoré pour l'historique Gemini.") # LOG 3
 
+    print(f"--- DEBUG [prepare_gemini_history]: Sortie avec {len(gemini_history)} messages formatés pour Gemini") # LOG 4
     return gemini_history
 
 # --- Routes Flask ---
@@ -206,342 +163,318 @@ def prepare_gemini_history(chat_history):
 @app.route('/')
 def root():
     """Sert la page HTML principale."""
-    # Pas besoin de toucher à l'historique ici, le frontend le demandera via /api/history
+    print("--- LOG: Appel route '/' ---")
     return render_template('index.html')
 
 @app.route('/api/history', methods=['GET'])
 def get_history():
     """Fournit l'historique de chat stocké en session au format JSON."""
-    # Flask-Session gère la session (filesystem dans ce cas)
+    print("\n--- DEBUG [/api/history]: Début requête GET ---") # LOG 5
     if 'chat_history' not in session:
         session['chat_history'] = []
+        print("  [/api/history]: Session 'chat_history' initialisée (vide).")
 
-    # Préparer l'historique pour l'affichage (contient déjà le HTML pour l'assistant)
-    # Il est crucial que les messages stockés aient 'role' et 'text'
     display_history = []
-    for msg in session.get('chat_history', []):
-         # Vérification minimale pour éviter les erreurs si la structure est corrompue
+    current_history = session.get('chat_history', [])
+    print(f"  [/api/history]: Historique récupéré de la session serveur: {len(current_history)} messages.") # LOG 6
+
+    # Optionnel: Afficher la structure brute pour un debug profond
+    # print("  [/api/history]: Contenu brut de l'historique session:")
+    # pprint.pprint(current_history)
+
+    for i, msg in enumerate(current_history):
+         # Vérifier la structure de chaque message récupéré
          if isinstance(msg, dict) and 'role' in msg and 'text' in msg:
              display_history.append({
                  'role': msg.get('role'),
-                 'text': msg.get('text')
+                 'text': msg.get('text') # On envoie bien le HTML ('text') au frontend
              })
          else:
-             print(f"AVERTISSEMENT: Format de message invalide dans l'historique de session ignoré: {msg}")
-
+             # Log si un message dans la session est mal formé
+             print(f"  AVERTISSEMENT [/api/history]: Format invalide dans l'historique session au message {i}: {msg}") # LOG 7
 
-    print(f"API: Récupération de l'historique ({len(display_history)} messages depuis la session serveur)")
+    print(f"  [/api/history]: Historique préparé pour le frontend: {len(display_history)} messages.") # LOG 8
     return jsonify({'success': True, 'history': display_history})
 
 @app.route('/api/chat', methods=['POST'])
 def chat_api():
     """Gère les nouvelles requêtes de chat via AJAX."""
+    print(f"\n---===================================---")
+    print(f"--- DEBUG [/api/chat]: Nouvelle requête POST ---")
+
     if not GEMINI_CONFIGURED:
-        print("API ERREUR: Tentative d'appel à /api/chat sans configuration Gemini valide.")
-        return jsonify({'success': False, 'error': "Le service IA n'est pas configuré correctement."}), 503 # Service Unavailable
+        print("--- ERREUR [/api/chat]: Tentative d'appel sans configuration Gemini valide.")
+        return jsonify({'success': False, 'error': "Le service IA n'est pas configuré correctement."}), 503
 
     # Récupération des données du formulaire
     prompt = request.form.get('prompt', '').strip()
-    use_web_search_str = request.form.get('web_search', 'false') # 'true' ou 'false'
-    use_web_search = use_web_search_str.lower() == 'true'
+    use_web_search = request.form.get('web_search', 'false').lower() == 'true'
     file = request.files.get('file')
-    use_advanced_str = request.form.get('advanced_reasoning', 'false') # Get the new flag
-    use_advanced = use_advanced_str.lower() == 'true'
+    use_advanced = request.form.get('advanced_reasoning', 'false').lower() == 'true'
+
+    print(f"  [/api/chat]: Prompt reçu: '{prompt[:50]}...'")
+    print(f"  [/api/chat]: Recherche Web: {use_web_search}, Raisonnement Avancé: {use_advanced}")
+    print(f"  [/api/chat]: Fichier: {file.filename if file else 'Aucun'}")
 
-    # Validation simple
+    # Validation
     if not prompt and not file:
+        print("--- ERREUR [/api/chat]: Prompt et fichier vides.")
         return jsonify({'success': False, 'error': 'Veuillez fournir un message ou un fichier.'}), 400
 
-    print(f"\n--- Nouvelle requête /api/chat ---")
-    print(f"Prompt reçu: '{prompt[:50]}...'")
-    print(f"Recherche Web activée: {use_web_search}")
-    print(f"Raisonnement avancé demandé: {use_advanced}")
-    print(f"Fichier reçu: {file.filename if file else 'Aucun'}")
-
-    # Initialiser l'historique de session si nécessaire (géré par Flask-Session)
+    # --- Log de l'état de l'historique AVANT toute modification ---
     if 'chat_history' not in session:
         session['chat_history'] = []
-
-    uploaded_gemini_file = None # L'objet fichier retourné par genai.upload_file
-    uploaded_filename = None    # Juste le nom du fichier pour référence/affichage
-    filepath_to_delete = None   # Chemin du fichier local à supprimer après traitement
-
-    # --- Gestion de l'upload de fichier ---
+    history_before_user_add = list(session.get('chat_history', [])) # Copie pour le log
+    print(f"--- DEBUG [/api/chat]: Historique en session AVANT ajout user message: {len(history_before_user_add)} messages") # LOG 9
+    # Optionnel: Afficher les derniers messages pour voir le contexte précédent
+    # if history_before_user_add:
+    #     print("  [/api/chat]: Dernier(s) message(s) avant ajout:")
+    #     pprint.pprint(history_before_user_add[-2:]) # Afficher les 2 derniers
+
+    uploaded_gemini_file = None
+    uploaded_filename = None
+    filepath_to_delete = None
+
+    # --- Gestion de l'upload de fichier (avec logs) ---
     if file and file.filename != '':
+        print(f"--- LOG [/api/chat]: Traitement du fichier '{file.filename}'")
         if allowed_file(file.filename):
             try:
                 filename = secure_filename(file.filename)
                 filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
                 file.save(filepath)
-                filepath_to_delete = filepath # Marquer pour suppression
+                filepath_to_delete = filepath
                 uploaded_filename = filename
-                print(f"Fichier '{filename}' sauvegardé temporairement dans '{filepath}'")
-
-                # Détecter le MimeType pour Gemini
-                mime_type = mimetypes.guess_type(filepath)[0]
-                if not mime_type:
-                    mime_type = 'application/octet-stream' # Fallback
-                    print(f"AVERTISSEMENT: Impossible de deviner le MimeType pour '{filename}', utilisation de '{mime_type}'.")
-
-                # Uploader vers Google AI (peut prendre du temps)
-                print(f"Upload du fichier vers Google AI (MimeType: {mime_type})...")
-                # Note: L'API upload_file est générique et ne dépend pas du modèle Flash/Pro
+                print(f"  [/api/chat]: Fichier '{filename}' sauvegardé dans '{filepath}'")
+                mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
+                print(f"  [/api/chat]: Upload Google AI (Mime: {mime_type})...")
                 uploaded_gemini_file = genai.upload_file(path=filepath, mime_type=mime_type)
-                print(f"Fichier '{uploaded_gemini_file.name}' uploadé avec succès vers Google AI.")
-
+                print(f"  [/api/chat]: Fichier Google AI '{uploaded_gemini_file.name}' uploadé.")
             except Exception as e:
-                print(f"ERREUR Critique lors du traitement/upload du fichier '{filename}': {e}")
-                # Supprimer le fichier local même en cas d'erreur d'upload Gemini
+                print(f"--- ERREUR [/api/chat]: Échec traitement/upload fichier '{filename}': {e}")
                 if filepath_to_delete and os.path.exists(filepath_to_delete):
-                    try:
-                        os.remove(filepath_to_delete)
-                        print(f"Fichier temporaire '{filepath_to_delete}' supprimé après erreur.")
-                    except OSError as del_e:
-                         print(f"Erreur lors de la suppression du fichier temporaire après erreur: {del_e}")
-                # Renvoyer une erreur claire au client
-                return jsonify({'success': False, 'error': f"Erreur lors du traitement du fichier: {e}"}), 500
+                    try: os.remove(filepath_to_delete)
+                    except OSError as del_e: print(f"  Erreur suppression fichier temp après erreur: {del_e}")
+                return jsonify({'success': False, 'error': f"Erreur traitement fichier: {e}"}), 500
         else:
-            print(f"ERREUR: Type de fichier non autorisé: {file.filename}")
-            return jsonify({'success': False, 'error': f"Type de fichier non autorisé. Extensions permises: {', '.join(ALLOWED_EXTENSIONS)}"}), 400
+            print(f"--- ERREUR [/api/chat]: Type de fichier non autorisé: {file.filename}")
+            return jsonify({'success': False, 'error': f"Type de fichier non autorisé."}), 400
 
     # --- Préparation du message utilisateur pour l'historique et Gemini ---
-    # Texte brut pour Gemini (et pour l'historique interne)
     raw_user_text = prompt
-    # Texte pour l'affichage dans l'interface (peut inclure le nom de fichier)
     display_user_text = f"[{uploaded_filename}] {prompt}" if uploaded_filename and prompt else (prompt or f"[{uploaded_filename}]")
-
-    # Ajout à l'historique de session
     user_history_entry = {
         'role': 'user',
-        'text': display_user_text, # Pour get_history et potentiellement debug
-        'raw_text': raw_user_text,   # Pour l'envoi à Gemini via prepare_gemini_history
-        # On ne stocke PAS l'objet 'uploaded_gemini_file' dans la session
+        'text': display_user_text,
+        'raw_text': raw_user_text,
     }
-    # Vérifier que l'historique est bien une liste avant d'ajouter
+
+    # Ajout à l'historique de session (vérifier que c'est une liste)
     if not isinstance(session.get('chat_history'), list):
-        print("ERREUR: chat_history dans la session n'est pas une liste! Réinitialisation.")
+        print("--- ERREUR [/api/chat]: 'chat_history' n'est pas une liste! Réinitialisation.")
         session['chat_history'] = []
     session['chat_history'].append(user_history_entry)
-    # session.modified = True # Normalement plus nécessaire avec Flask-Session Filesystem/Redis etc.
-                               # mais ne fait pas de mal de le laisser pour l'instant.
-
-    # --- Préparation des 'parts' pour l'appel Gemini ACTUEL ---
-    current_gemini_parts = []
-    if uploaded_gemini_file:
-        # Important: Ne pas envoyer l'objet fichier lui-même si le prompt est vide.
-        # Gemini pourrait avoir du mal à l'interpréter sans contexte textuel.
-        if raw_user_text:
-             current_gemini_parts.append(uploaded_gemini_file)
-        else:
-             # Si seulement un fichier est envoyé, créer un prompt minimal
-             raw_user_text = f"Décris le contenu de ce fichier : {uploaded_filename}"
-             print(f"INFO: Fichier seul détecté, utilisation du prompt généré: '{raw_user_text}'")
-             current_gemini_parts.append(uploaded_gemini_file)
 
+    # --- Log de l'état de l'historique APRES ajout du message utilisateur ---
+    history_after_user_add = list(session.get('chat_history', [])) # Nouvelle copie
+    print(f"--- DEBUG [/api/chat]: Historique en session APRES ajout user message: {len(history_after_user_add)} messages") # LOG 10
+    # print("  [/api/chat]: Dernier message ajouté (user):")
+    # pprint.pprint(history_after_user_add[-1])
 
-    final_prompt_for_gemini = raw_user_text # Commencer avec le texte brut (potentiellement généré ci-dessus)
 
-    # --- Recherche Web (si activée et si un prompt textuel existe) ---
-    if use_web_search and raw_user_text: # Vérifier qu'on a bien du texte pour chercher
-        print("Activation de la recherche web...")
-        search_data = perform_web_search(raw_user_text)
+    # --- Préparation des 'parts' pour l'appel Gemini ACTUEL ---
+    current_gemini_parts = []
+    # Gérer le cas où seul un fichier est envoyé
+    if uploaded_gemini_file and not raw_user_text:
+         raw_user_text = f"Décris le contenu de ce fichier : {uploaded_filename}"
+         final_prompt_for_gemini = raw_user_text
+         current_gemini_parts.append(uploaded_gemini_file)
+         current_gemini_parts.append(final_prompt_for_gemini)
+         print(f"  [/api/chat]: Fichier seul détecté, prompt généré: '{final_prompt_for_gemini}'")
+    elif uploaded_gemini_file and raw_user_text:
+        final_prompt_for_gemini = raw_user_text
+        current_gemini_parts.append(uploaded_gemini_file)
+        current_gemini_parts.append(final_prompt_for_gemini)
+    else: # Seulement du texte (ou ni texte ni fichier valide, géré plus bas)
+        final_prompt_for_gemini = raw_user_text
+        if final_prompt_for_gemini:
+             current_gemini_parts.append(final_prompt_for_gemini)
+
+    # --- Recherche Web ---
+    if use_web_search and final_prompt_for_gemini: # Assurer qu'il y a du texte à chercher
+        print(f"--- LOG [/api/chat]: Activation recherche web pour: '{final_prompt_for_gemini[:60]}...'")
+        search_data = perform_web_search(final_prompt_for_gemini)
         if search_data:
             formatted_results = format_search_results(search_data)
-            # Construire un prompt enrichi pour Gemini
-            final_prompt_for_gemini = f"""Voici la question originale de l'utilisateur:
-"{raw_user_text}"
-
-J'ai effectué une recherche web et voici les informations pertinentes trouvées:
---- DEBUT RESULTATS WEB ---
-{formatted_results}
---- FIN RESULTATS WEB ---
-
-En te basant sur ces informations ET sur ta connaissance générale, fournis une réponse complète et bien structurée à la question originale de l'utilisateur."""
-            print("Prompt enrichi avec les résultats de recherche web.")
+            enriched_prompt = f"""Voici la question originale de l'utilisateur:\n"{final_prompt_for_gemini}"\n\nInformations pertinentes de recherche web:\n--- DEBUT RESULTATS WEB ---\n{formatted_results}\n--- FIN RESULTATS WEB ---\n\nRéponds à la question originale en te basant sur ces informations ET ta connaissance générale."""
+            # Remplacer le dernier élément texte dans current_gemini_parts
+            if current_gemini_parts and isinstance(current_gemini_parts[-1], str):
+                current_gemini_parts[-1] = enriched_prompt
+                final_prompt_for_gemini = enriched_prompt # Mettre à jour pour les logs suivants
+            print(f"  [/api/chat]: Prompt enrichi avec recherche web.")
         else:
-            print("Aucun résultat de recherche web pertinent trouvé ou erreur, utilisation du prompt original/généré.")
-            # final_prompt_for_gemini reste raw_user_text ou le prompt généré
-
-    # Ajouter le texte (potentiellement enrichi) aux parts pour Gemini UNIQUEMENT s'il y a du texte
-    if final_prompt_for_gemini:
-         current_gemini_parts.append(final_prompt_for_gemini)
-    elif not current_gemini_parts: # Si on n'a ni fichier utile ni texte
-         print("ERREUR: Aucune donnée (texte ou fichier valide) à envoyer à Gemini.")
-         # Retirer le message utilisateur vide ajouté précédemment
-         if session.get('chat_history'):
-            session['chat_history'].pop()
-         return jsonify({'success': False, 'error': "Impossible d'envoyer une requête vide à l'IA."}), 400
+            print(f"  [/api/chat]: Recherche web sans résultat pertinent ou erreur.")
 
+    # Vérifier si on a quelque chose à envoyer
+    if not current_gemini_parts:
+        print("--- ERREUR [/api/chat]: Aucune donnée (texte ou fichier valide) à envoyer après traitement.")
+        if session.get('chat_history'): session['chat_history'].pop() # Retirer le user message vide/inutile
+        return jsonify({'success': False, 'error': "Impossible d'envoyer une requête vide."}), 400
 
     # --- Appel à l'API Gemini ---
     try:
-        # Préparer l'historique des messages PRÉCÉDENTS
-        # Utiliser une copie de la session pour éviter les modifications pendant la préparation
-        history_copy = list(session.get('chat_history', []))
-        gemini_history = prepare_gemini_history(history_copy[:-1]) # Exclut le message actuel
-        print(f"Préparation de l'appel Gemini avec {len(gemini_history)} messages d'historique.")
+        # Préparer l'historique des messages PRÉCÉDENTS pour Gemini
+        # Important: Utiliser une copie de l'historique SANS le dernier message utilisateur ajouté
+        history_for_gemini_prep = list(session.get('chat_history', []))[:-1]
+        gemini_history_to_send = prepare_gemini_history(history_for_gemini_prep)
 
         # Construire le contenu complet pour l'appel
-        contents_for_gemini = gemini_history + [{'role': 'user', 'parts': current_gemini_parts}]
+        contents_for_gemini = gemini_history_to_send + [{'role': 'user', 'parts': current_gemini_parts}]
 
-        # DEBUG: Afficher ce qui va être envoyé (peut être très verbeux)
-        # print("--- Contenu envoyé à Gemini ---")
-        # import pprint
-        # pprint.pprint(contents_for_gemini)
-        # print("-----------------------------")
-
-
-        # Choisir le nom du modèle à utiliser
+        # --- LOG DÉTAILLÉ : Ce qui est envoyé à l'API ---
         selected_model_name = MODEL_PRO if use_advanced else MODEL_FLASH
-        print(f"Utilisation du modèle Gemini: {selected_model_name}")
+        print(f"--- DEBUG [/api/chat]: Préparation de l'envoi à l'API Gemini (Modèle: {selected_model_name}) ---") # LOG 11
+        print(f"  Nombre total de tours (historique + actuel): {len(contents_for_gemini)}") # LOG 12a
+        print(f"  Nombre de messages d'historique formatés envoyés: {len(gemini_history_to_send)}") # LOG 12b
+        print(f"  Contenu détaillé des 'parts' envoyées:") # LOG 13
+        for i, turn in enumerate(contents_for_gemini):
+            role = turn.get('role')
+            parts_details = []
+            for part in turn.get('parts', []):
+                if isinstance(part, str):
+                    parts_details.append(f"Text({len(part)} chars): '{part[:60].replace(chr(10), ' ')}...'") # Remplacer newline pour log sur 1 ligne
+                elif hasattr(part, 'name') and hasattr(part, 'mime_type'):
+                    parts_details.append(f"File(name={part.name}, mime={part.mime_type})")
+                else:
+                    parts_details.append(f"UnknownPart({type(part)})")
+            print(f"    Turn {i} (role: {role}): {', '.join(parts_details)}")
+        print("--------------------------------------------------------------------")
 
-        # Créer l'instance du modèle spécifique pour cette requête
-        # Réutiliser les paramètres globaux (safety, system instruction)
+        # Créer l'instance du modèle et appeler l'API
         active_model = genai.GenerativeModel(
             model_name=selected_model_name,
-            safety_settings=SAFETY_SETTINGS, # defined globally
-            system_instruction=SYSTEM_INSTRUCTION # defined globally
+            safety_settings=SAFETY_SETTINGS,
+            system_instruction=SYSTEM_INSTRUCTION
         )
-
-        # Appel API
-        print(f"Envoi de la requête à {selected_model_name}...")
-        # Utilisation de generate_content en mode non-streamé
+        print(f"--- LOG [/api/chat]: Envoi de la requête à {selected_model_name}...")
         response = active_model.generate_content(contents_for_gemini)
-        # print(response) # Décommenter pour voir la réponse brute de l'API
 
-        # Extraire le texte de la réponse (gestion d'erreur potentielle ici si la réponse est bloquée etc.)
-        # Gérer le cas où la réponse est bloquée par les safety settings
+        # --- Traitement de la réponse (avec logs) ---
         response_text_raw = ""
         response_html = ""
         try:
-             # Vérifier si la réponse a des 'parts' avant d'essayer d'accéder à .text
-             if response.parts:
+            if response.parts:
                 response_text_raw = response.text # .text concatène les parts textuelles
-             else:
-                # Si pas de parts, vérifier le prompt_feedback pour la raison (blocage probable)
-                print(f"AVERTISSEMENT: Réponse de Gemini sans contenu textuel ('parts'). Feedback: {response.prompt_feedback}")
-                # Donner un message d'erreur plus informatif basé sur le feedback si possible
+                print(f"--- LOG [/api/chat]: Réponse reçue de Gemini (brute, début): '{response_text_raw[:100]}...'")
+            else:
+                feedback_info = f"Feedback: {response.prompt_feedback}" if response.prompt_feedback else "Pas de feedback détaillé."
+                print(f"--- AVERTISSEMENT [/api/chat]: Réponse Gemini sans 'parts'. {feedback_info}")
                 if response.prompt_feedback and response.prompt_feedback.block_reason:
-                    reason = response.prompt_feedback.block_reason.name # Ex: 'SAFETY', 'OTHER'
+                    reason = response.prompt_feedback.block_reason.name
                     response_text_raw = f"Désolé, ma réponse a été bloquée ({reason})."
-                    # Si SAFETY, vérifier les ratings spécifiques si disponibles
                     if reason == 'SAFETY' and response.prompt_feedback.safety_ratings:
-                        blocked_categories = [r.category.name for r in response.prompt_feedback.safety_ratings if r.probability.name not in ['NEGLIGIBLE', 'LOW']]
-                        if blocked_categories:
-                            response_text_raw += f" Catégories potentiellement concernées: {', '.join(blocked_categories)}."
-
+                        blocked_cats = [r.category.name for r in response.prompt_feedback.safety_ratings if r.probability.name not in ['NEGLIGIBLE', 'LOW']]
+                        if blocked_cats: response_text_raw += f" Catégories: {', '.join(blocked_cats)}."
                 else:
-                     response_text_raw = "Désolé, je n'ai pas pu générer de réponse pour cette demande."
+                     response_text_raw = "Désolé, je n'ai pas pu générer de réponse."
+                print(f"  [/api/chat]: Message d'erreur généré: '{response_text_raw}'")
 
-
-             # Convertir en HTML même si c'est un message d'erreur
-             response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
+            # Conversion Markdown
+            response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
+            if response_html != response_text_raw:
+                 print(f"  [/api/chat]: Réponse convertie en HTML.")
 
         except ValueError as e:
-            # Gérer le cas où .text échoue même avec des parts (rare, mais possible si structure inattendue)
-            print(f"ERREUR: Impossible d'extraire le texte de la réponse Gemini. Erreur: {e}")
-            print(f"Réponse brute: {response}")
-            print(f"Feedback: {response.prompt_feedback}")
-            response_text_raw = "Désolé, une erreur interne est survenue lors de la lecture de la réponse."
+            print(f"--- ERREUR [/api/chat]: Impossible d'extraire le texte de la réponse Gemini. Erreur: {e}")
+            print(f"  Réponse brute: {response}")
+            response_text_raw = "Désolé, erreur interne lors de la lecture de la réponse."
             response_html = markdown.markdown(response_text_raw)
-        except Exception as e_resp: # Capturer toute autre exception inattendue
-            print(f"ERREUR INATTENDUE lors du traitement de la réponse Gemini : {e_resp}")
-            print(f"Réponse brute: {response}")
-            response_text_raw = f"Désolé, une erreur inattendue est survenue ({type(e_resp).__name__})."
+        except Exception as e_resp:
+            print(f"--- ERREUR [/api/chat]: INATTENDUE lors traitement réponse Gemini : {e_resp}")
+            print(f"  Réponse brute: {response}")
+            response_text_raw = f"Désolé, erreur inattendue ({type(e_resp).__name__})."
             response_html = markdown.markdown(response_text_raw)
 
-
-        print(f"Réponse reçue de Gemini (brute, début): '{response_text_raw[:100]}...'")
-        if response_html != response_text_raw: # Log seulement si Markdown a fait quelque chose
-             print("Réponse convertie en HTML.")
-
-
-        # Ajouter la réponse de l'assistant à l'historique de session
+        # --- Ajout de la réponse Assistant à l'historique de session ---
         assistant_history_entry = {
             'role': 'assistant',
-            'text': response_html,      # HTML pour l'affichage via get_history
-            'raw_text': response_text_raw # Texte brut pour les futurs appels Gemini
+            'text': response_html,
+            'raw_text': response_text_raw
         }
-        # Re-vérifier que l'historique est une liste avant d'ajouter
         if not isinstance(session.get('chat_history'), list):
-            print("ERREUR: chat_history dans la session n'est pas une liste avant ajout assistant! Réinitialisation.")
-            session['chat_history'] = [user_history_entry] # Garder au moins le user msg
+            print("--- ERREUR [/api/chat]: 'chat_history' n'est pas liste avant ajout assistant! Réinitialisation.")
+            session['chat_history'] = [user_history_entry] # Garder au moins user msg
         session['chat_history'].append(assistant_history_entry)
-        # session.modified = True # Probablement pas nécessaire mais sans danger
 
-        # Renvoyer la réponse HTML au frontend
-        print("Envoi de la réponse HTML au client.")
+        # --- Log de l'état final de l'historique pour ce tour ---
+        history_final_turn = list(session.get('chat_history', []))
+        print(f"--- DEBUG [/api/chat]: Historique en session FINAL après ajout assistant: {len(history_final_turn)} messages") # LOG 14
+        # print("  [/api/chat]: Dernier message ajouté (assistant):")
+        # pprint.pprint(history_final_turn[-1])
+
+        # --- Renvoyer la réponse au frontend ---
+        print(f"--- LOG [/api/chat]: Envoi de la réponse HTML au client.")
+        print(f"---==================================---\n")
         return jsonify({'success': True, 'message': response_html})
 
     except Exception as e:
-        print(f"ERREUR Critique lors de l'appel à Gemini ou du traitement de la réponse : {e}")
-        # En cas d'erreur, retirer le dernier message utilisateur de l'historique
-        # pour éviter les boucles d'erreur si le message lui-même pose problème.
-        # Vérifier si l'historique n'est pas vide avant de pop
+        print(f"--- ERREUR CRITIQUE [/api/chat]: Échec appel Gemini ou traitement réponse : {e}")
+        # Tentative de retrait du dernier message utilisateur en cas d'erreur
         current_history = session.get('chat_history')
         if isinstance(current_history, list) and current_history:
             try:
-                # S'assurer que le dernier élément était bien le message utilisateur
                 if current_history[-1].get('role') == 'user':
                     current_history.pop()
-                    # session.modified = True # Si on modifie directement la liste obtenue par .get()
-                    print("Le dernier message utilisateur a été retiré de l'historique suite à l'erreur.")
+                    print("  [/api/chat]: Dernier message user retiré de l'historique suite à l'erreur.")
                 else:
-                    print("Le dernier message n'était pas 'user', historique non modifié après erreur.")
+                    print("  [/api/chat]: Dernier message n'était pas 'user', historique non modifié après erreur.")
             except Exception as pop_e:
-                 print(f"Erreur lors de la tentative de retrait du message utilisateur de l'historique: {pop_e}")
-        else:
-            print("L'historique était vide ou invalide lors de l'erreur.")
-
-        # Renvoyer une erreur générique mais informative
-        return jsonify({'success': False, 'error': f"Une erreur interne est survenue lors de la génération de la réponse. Détails: {e}"}), 500
+                 print(f"  Erreur lors tentative retrait message user: {pop_e}")
+        print(f"---==================================---\n")
+        return jsonify({'success': False, 'error': f"Erreur interne: {e}"}), 500
 
     finally:
-        # --- Nettoyage du fichier uploadé vers Google AI ---
+        # --- Nettoyage des fichiers (Google AI et local) ---
+        # Nettoyage Google AI File
         if uploaded_gemini_file:
              try:
-                 print(f"Tentative de suppression du fichier Google AI : {uploaded_gemini_file.name}")
+                 print(f"--- LOG [/api/chat FINALLY]: Tentative suppression fichier Google AI : {uploaded_gemini_file.name}")
                  genai.delete_file(uploaded_gemini_file.name)
-                 print(f"Fichier Google AI '{uploaded_gemini_file.name}' supprimé.")
+                 print(f"  [/api/chat FINALLY]: Fichier Google AI '{uploaded_gemini_file.name}' supprimé.")
              except Exception as e_del_gcp:
-                 # Ne pas bloquer l'utilisateur pour ça, juste logguer
-                 print(f"AVERTISSEMENT: Échec de la suppression du fichier Google AI '{uploaded_gemini_file.name}': {e_del_gcp}")
-
-
-        # --- Nettoyage du fichier temporaire local ---
+                 print(f"  AVERTISSEMENT [/api/chat FINALLY]: Échec suppression fichier Google AI '{uploaded_gemini_file.name}': {e_del_gcp}")
+        # Nettoyage Fichier Local
         if filepath_to_delete and os.path.exists(filepath_to_delete):
             try:
                 os.remove(filepath_to_delete)
-                print(f"Fichier temporaire local '{filepath_to_delete}' supprimé avec succès.")
+                print(f"--- LOG [/api/chat FINALLY]: Fichier temporaire local '{filepath_to_delete}' supprimé.")
             except OSError as e_del_local:
-                print(f"ERREUR lors de la suppression du fichier temporaire local '{filepath_to_delete}': {e_del_local}")
+                print(f"--- ERREUR [/api/chat FINALLY]: Échec suppression fichier local '{filepath_to_delete}': {e_del_local}")
 
 
 @app.route('/clear', methods=['POST'])
 def clear_chat():
     """Efface l'historique de chat dans la session."""
+    print("\n--- DEBUG [/clear]: Requête POST reçue ---")
     session.clear() # Efface toutes les données de la session serveur actuelle
-    print("API: Historique de chat effacé via /clear (session serveur).")
-
-    # Adapter la réponse selon si c'est une requête AJAX (fetch) ou une soumission classique
+    print("  [/clear]: Session serveur effacée.")
     is_ajax = 'XMLHttpRequest' == request.headers.get('X-Requested-With') or \
               'application/json' in request.headers.get('Accept', '')
-
     if is_ajax:
+         print("  [/clear]: Réponse JSON (AJAX).")
          return jsonify({'success': True, 'message': 'Historique effacé.'})
     else:
-        # Comportement pour une soumission de formulaire classique (si jamais utilisé)
+        print("  [/clear]: Réponse Flash + Redirect (non-AJAX).")
         flash("Conversation effacée.", "info")
-        return redirect(url_for('root')) # Redirige vers la racine
+        return redirect(url_for('root'))
 
 
 # --- Démarrage de l'application ---
 if __name__ == '__main__':
-    print("Démarrage du serveur Flask...")
-    # Utiliser host='0.0.0.0' pour rendre accessible sur le réseau local
-    # debug=True est pratique pour le développement, mais à désactiver en production !
-    # Utiliser un port différent si le port 5000 est déjà pris
+    print("--- Démarrage du serveur Flask ---")
     port = int(os.environ.get('PORT', 5001))
-    # Mettre debug=False pour la production
-    app.run(debug=False, host='0.0.0.0', port=port)
+    # Mettre debug=True pour le développement et voir les logs facilement.
+    # ATTENTION: NE PAS UTILISER debug=True en production !
+    app.run(debug=True, host='0.0.0.0', port=port)
+
 # --- END OF FILE app.py ---