Update app.py

app.py

@@ -1,171 +1,194 @@
 import os
 import json
 import mimetypes
+import time
+import re # Pour la détection d'URL YouTube
 from flask import Flask, request, session, jsonify, redirect, url_for, flash, render_template
 from dotenv import load_dotenv
 import google.generativeai as genai
+import google.generativeai.types as genai_types # Important pour FileData, Part, etc.
 import requests
 from werkzeug.utils import secure_filename
-import markdown # Pour convertir la réponse en HTML
+import markdown # Pour convertir la réponse Markdown en HTML
 
 # --- Configuration Initiale ---
-load_dotenv()
+load_dotenv() # Charge les variables depuis .env
 
 app = Flask(__name__)
-
-# Clé secrète FORTEMENT recommandée pour les sessions
-app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'dev-secret-key-replace-in-prod')
+# Clé secrète FORTEMENT recommandée pour la sécurité des sessions
+app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'une-cle-secrete-tres-difficile-a-deviner')
 
 # Configuration pour les uploads
 UPLOAD_FOLDER = 'temp'
-ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg'} # Extensions autorisées
+# Extensions autorisées (incluant vidéo)
+ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg', 'mp4', 'mov', 'avi', 'mkv', 'webm'}
+VIDEO_EXTENSIONS = {'mp4', 'mov', 'avi', 'mkv', 'webm'} # Pour identifier les vidéos
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-app.config['MAX_CONTENT_LENGTH'] = 25 * 1024 * 1024  # Limite de taille (ex: 25MB)
+# Augmenter la limite pour les vidéos (ex: 100MB) - Ajustez si nécessaire
+app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024
 
-# Créer le dossier temp s'il n'existe pas
+# Crée le dossier temporaire s'il n'existe pas
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 print(f"Dossier d'upload configuré : {os.path.abspath(UPLOAD_FOLDER)}")
 
 # --- Configuration de l'API Gemini ---
-MODEL_FLASH = 'gemini-2.0-flash' # Default model
-MODEL_PRO = 'gemini-2.5-pro-exp-03-25' # Advanced model
-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"},
-    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
-    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
-    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
-]
+# Utilisez les noms de modèles les plus récents auxquels vous avez accès
+MODEL_FLASH = 'gemini-1.5-flash-latest'
+MODEL_PRO = 'gemini-1.5-pro-latest' # Pro est souvent nécessaire/meilleur pour la vidéo
+
+# Instruction système pour le modèle
+SYSTEM_INSTRUCTION = "Tu es un assistant intelligent et amical nommé Mariam. Tu assistes les utilisateurs au mieux de tes capacités, y compris dans l'analyse de texte, d'images et de vidéos (via upload ou lien YouTube). Tu as été créé par Aenir."
+
+# Paramètres de sécurité (ajuster si nécessaire, BLOCK_NONE est très permissif)
+SAFETY_SETTINGS = [ {"category": c, "threshold": "BLOCK_NONE"} for c in [
+    "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_HATE_SPEECH",
+    "HARM_CATEGORY_SEXUALLY_EXPLICIT", "HARM_CATEGORY_DANGEROUS_CONTENT"]]
+
 GEMINI_CONFIGURED = False
+gemini_client = None # Client API pour les opérations sur les fichiers (upload vidéo)
+
 try:
     gemini_api_key = os.getenv("GOOGLE_API_KEY")
     if not gemini_api_key:
-        print("ERREUR: Clé API GOOGLE_API_KEY manquante dans le fichier .env")
+        raise ValueError("Clé API GOOGLE_API_KEY manquante dans le fichier .env")
+
+    # Initialise le client pour les opérations sur les fichiers (upload vidéo avec polling)
+    gemini_client = genai.Client(api_key=gemini_api_key)
+    # Configure également l'espace de noms global pour GenerativeModel, etc.
+    genai.configure(api_key=gemini_api_key)
+
+    # Vérifie si les modèles requis sont disponibles
+    print("Vérification des modèles Gemini disponibles...")
+    models_list = [m.name for m in genai.list_models()]
+    required_models = [f'models/{MODEL_FLASH}', f'models/{MODEL_PRO}']
+    if all(model in models_list for model in required_models):
+         print(f"Configuration Gemini effectuée. Modèles requis trouvés.")
+         print(f"Instruction Système: {SYSTEM_INSTRUCTION}")
+         GEMINI_CONFIGURED = True
     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.")
-             print(f"System instruction: {SYSTEM_INSTRUCTION}")
-             GEMINI_CONFIGURED = True
-        else:
-            print(f"ERREUR: Les modèles requis ({MODEL_FLASH}, {MODEL_PRO}) ne sont pas tous disponibles via l'API.")
-            print(f"Modèles trouvés: {models_list}")
+        missing = [model for model in required_models if model not in models_list]
+        raise ValueError(f"Les modèles Gemini requis suivants sont manquants: {missing}")
 
 except Exception as e:
     print(f"ERREUR Critique lors de la configuration initiale de Gemini : {e}")
     print("L'application fonctionnera sans les fonctionnalités IA.")
+    gemini_client = None # S'assure que le client est None si la config échoue
 
 # --- Fonctions Utilitaires ---
 
+def get_file_extension(filename):
+    """Retourne l'extension du fichier en minuscules, ou None."""
+    return filename.rsplit('.', 1)[1].lower() if '.' in filename else None
+
 def allowed_file(filename):
-    """Vérifie si l'extension du fichier est autorisée."""
-    return '.' in filename and \
-           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+    """Vérifie si l'extension du fichier est dans la liste autorisée."""
+    return get_file_extension(filename) in ALLOWED_EXTENSIONS
+
+def is_video_file(filename):
+    """Vérifie si l'extension correspond à un type vidéo connu."""
+    return get_file_extension(filename) in VIDEO_EXTENSIONS
+
+def is_youtube_url(url):
+    """Vérifie si la chaîne ressemble à une URL YouTube valide."""
+    if not url: # Gère les cas où l'URL est None ou vide
+        return False
+    # Regex simple pour les formats courants d'URL YouTube
+    youtube_regex = re.compile(
+        r'(https?://)?(www\.)?' # Protocole et www optionnels
+        r'(youtube|youtu|youtube-nocookie)\.(com|be)/' # Domaines youtube.com, youtu.be, etc.
+        r'(watch\?v=|embed/|v/|.+\?v=)?' # Différents chemins possibles
+        r'([^&=%\?]{11})') # L'ID vidéo de 11 caractères
+    return youtube_regex.match(url) is not None
+
+# --- Fonction d'Upload Vidéo avec Polling ---
+def upload_video_with_polling(filepath, mime_type, max_wait_seconds=300, poll_interval=10):
+    """
+    Upload une vidéo via client.files.upload et attend son traitement.
+    Retourne l'objet File traité ou lève une exception.
+    """
+    if not gemini_client:
+        raise ConnectionError("Le client Gemini n'est pas initialisé.")
+
+    print(f"Début de l'upload vidéo via client.files: {filepath} ({mime_type})")
+    video_file = None # Initialise la variable pour le bloc finally
+    try:
+        # Lance l'upload
+        video_file = gemini_client.files.upload(path=filepath, mime_type=mime_type)
+        print(f"Upload initialisé. Nom du fichier distant: {video_file.name}. Attente du traitement...")
+
+        start_time = time.time()
+        # Boucle de polling tant que l'état est "PROCESSING"
+        while video_file.state == genai_types.FileState.PROCESSING:
+            elapsed_time = time.time() - start_time
+            # Vérifie le timeout
+            if elapsed_time > max_wait_seconds:
+                raise TimeoutError(f"Le traitement de la vidéo a dépassé le délai de {max_wait_seconds} secondes.")
+
+            print(f"Vidéo en cours de traitement... (État: {video_file.state.name}, {int(elapsed_time)}s écoulées)")
+            time.sleep(poll_interval)
+            # Récupère l'état mis à jour du fichier
+            video_file = gemini_client.files.get(name=video_file.name)
+
+        # Vérifie l'état final après la boucle
+        if video_file.state == genai_types.FileState.FAILED:
+            print(f"ERREUR: Le traitement de la vidéo a échoué. État: {video_file.state.name}")
+            raise ValueError("Le traitement de la vidéo a échoué côté serveur.")
+
+        if video_file.state == genai_types.FileState.ACTIVE:
+            print(f"Traitement vidéo terminé avec succès: {video_file.uri}")
+            return video_file # Retourne l'objet fichier SDK réussi
+
+        else:
+            # Gère d'autres états inattendus si nécessaire
+            print(f"AVERTISSEMENT: État inattendu du fichier vidéo après traitement: {video_file.state.name}")
+            raise RuntimeError(f"État inattendu du fichier vidéo: {video_file.state.name}")
 
+    except Exception as e:
+        print(f"Erreur lors de l'upload/traitement vidéo via client.files: {e}")
+        # Tente de supprimer le fichier distant en cas d'erreur pendant le polling/upload
+        if video_file and hasattr(video_file, 'name'):
+            try:
+                gemini_client.files.delete(name=video_file.name)
+                print(f"Tentative de nettoyage du fichier distant {video_file.name} après erreur.")
+            except Exception as delete_err:
+                 print(f"Échec du nettoyage du fichier distant {video_file.name} après erreur: {delete_err}")
+        raise # Relance l'exception originale pour qu'elle soit gérée par l'appelant
+
+# --- Fonctions de Recherche Web (inchangées - implémentez si nécessaire) ---
 def perform_web_search(query):
-    """Effectue une recherche web via l'API Serper."""
+    """Effectue une recherche web via l'API Serper (Exemple)."""
     serper_api_key = os.getenv("SERPER_API_KEY")
     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
-
-    try:
-        print(f"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)
-        data = response.json()
-        print("Résultats de recherche Serper obtenus.")
-        # print(json.dumps(data, indent=2)) # Décommenter pour voir les résultats bruts
-        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
-        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}")
-        return None
+    # ... (votre implémentation de la recherche Serper) ...
+    print(f"Recherche Web (simulation) pour : {query}")
+    # Simuler des résultats pour le test
+    # return {"organic": [{"title": "Résultat Web 1", "link": "#", "snippet": "Description du résultat 1..."}]}
+    return None # Désactivé par défaut
 
 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."
-
-    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 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 kg.get('attributes'):
-             for attr, value in kg['attributes'].items():
-                  results.append(f"- {attr}: {value}")
-
-
-    # Résultats organiques
+    """Met en forme les résultats de recherche (Exemple)."""
+    if not data: return "Aucun résultat de recherche web pertinent."
+    # ... (votre implémentation du formatage) ...
+    results = ["**Résultats Web:**"]
     if data.get('organic'):
-        results.append("**Pages web pertinentes :**")
-        for i, item in enumerate(data['organic'][:3], 1): # Top 3
-            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 item in data['organic'][:3]:
+            results.append(f"- {item.get('title', '')}: {item.get('snippet', '')}")
     return "\n".join(results)
 
+
+# --- Préparation Historique (inchangé) ---
 def prepare_gemini_history(chat_history):
-    """Convertit l'historique stocké en session au format attendu par Gemini API."""
+    """Convertit l'historique de session pour l'API Gemini (texte seulement)."""
     gemini_history = []
     for message in chat_history:
+        # Ne transmet que le texte brut des messages précédents
         role = 'user' if message['role'] == 'user' else 'model'
-        # Utiliser le 'raw_text' stocké pour Gemini
-        text_part = message.get('raw_text', '') # Fallback au cas où
-        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.
-        # Si une référence de fichier passée était nécessaire, il faudrait la stocker
-        # et la ré-attacher ici (potentiellement plus complexe).
-        gemini_history.append({'role': role, 'parts': parts})
+        text_part = message.get('raw_text', '') # Utilise raw_text stocké
+        # Ne pas inclure les fichiers/médias des tours précédents pour simplifier
+        if text_part: # N'ajoute que s'il y a du texte
+            gemini_history.append({'role': role, 'parts': [text_part]})
     return gemini_history
 
 # --- Routes Flask ---
@@ -177,185 +200,223 @@ def root():
 
 @app.route('/api/history', methods=['GET'])
 def get_history():
-    """Fournit l'historique de chat stocké en session au format JSON."""
+    """Fournit l'historique de chat (formaté pour affichage) en JSON."""
     if 'chat_history' not in session:
         session['chat_history'] = []
 
-    # Préparer l'historique pour l'affichage (contient déjà le HTML pour l'assistant)
+    # Prépare l'historique pour l'affichage (contient le HTML pour l'assistant)
     display_history = [
         {'role': msg.get('role', 'unknown'), 'text': msg.get('text', '')}
         for msg in session.get('chat_history', [])
     ]
-    print(f"API: Récupération de l'historique ({len(display_history)} messages)")
+    # print(f"API: Récupération historique ({len(display_history)} messages)") # Debug
     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."""
-    if not GEMINI_CONFIGURED:
+    """Gère les requêtes de chat (texte, fichier/vidéo uploadé, URL YouTube)."""
+    # Vérifie si Gemini est configuré correctement
+    if not GEMINI_CONFIGURED or not gemini_client:
         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
+        return jsonify({'success': False, 'error': "Le service IA n'est pas configuré correctement."}), 503
 
-    # Récupération des données du formulaire
+    # --- 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'
-    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'
+    youtube_url = request.form.get('youtube_url', '').strip() # Récupère le champ YouTube dédié
+    use_web_search = request.form.get('web_search', 'false').lower() == 'true'
+    use_advanced = request.form.get('advanced_reasoning', 'false').lower() == 'true'
+    file = request.files.get('file') # Récupère le fichier uploadé
 
-    # Validation simple
-    if not prompt and not file:
-        return jsonify({'success': False, 'error': 'Veuillez fournir un message ou un fichier.'}), 400
+    # --- Validation de l'entrée (au moins un type d'input requis) ---
+    if not file and not youtube_url and not prompt:
+        return jsonify({'success': False, 'error': 'Veuillez fournir un message, un fichier/vidéo ou un lien YouTube.'}), 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'}")
+    print(f"  Prompt: '{prompt[:50]}...'")
+    print(f"  Fichier: {file.filename if file else 'Non'}")
+    print(f"  URL YouTube: {youtube_url if youtube_url else 'Non'}")
+    print(f"  Web Search: {use_web_search}, Advanced: {use_advanced}")
 
-    # Initialiser l'historique de session si nécessaire
+    # Initialise l'historique de session si nécessaire
     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
+    # --- Variables pour le traitement ---
+    uploaded_media_part = None           # Part(file_data=...) pour Gemini
+    uploaded_filename_for_display = None # Nom à afficher dans le chat user
+    filepath_to_delete = None            # Chemin du fichier temporaire à supprimer
+    is_media_request = False             # True si fichier ou URL YT est l'input principal
+    media_type = None                    # 'file', 'video', 'youtube', ou 'text'
 
-    # --- Gestion de l'upload de fichier ---
-    if file and 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
-                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
-                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.")
-
-            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
-                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
+    # --- Traitement de l'entrée (Priorité: Fichier > YouTube > Texte) ---
+    try:
+        # 1. Traiter le fichier uploadé s'il existe
+        if file and file.filename != '':
+            is_media_request = True
+            media_type = 'file' # Par défaut, pourrait devenir 'video'
+            uploaded_filename_for_display = secure_filename(file.filename)
+
+            if not allowed_file(uploaded_filename_for_display):
+                raise ValueError(f"Type de fichier non autorisé: {uploaded_filename_for_display}")
+
+            # Sauvegarde temporaire du fichier
+            filepath = os.path.join(app.config['UPLOAD_FOLDER'], uploaded_filename_for_display)
+            file.save(filepath)
+            filepath_to_delete = filepath # Marque pour suppression future
+            print(f"  Fichier '{uploaded_filename_for_display}' sauvegardé -> '{filepath}'")
+            mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
+
+            # Utilise le polling pour les vidéos, upload direct pour les autres
+            if is_video_file(uploaded_filename_for_display):
+                media_type = 'video'
+                print("  Traitement VIDÉO Uploadée (avec polling)...")
+                # Appel bloquant qui attend le traitement
+                processed_media_file = upload_video_with_polling(filepath, mime_type)
+                # Crée le Part Gemini à partir de l'objet File retourné
+                uploaded_media_part = genai_types.Part(file_data=processed_media_file)
+            else:
+                print("  Traitement FICHIER standard...")
+                # Utilise l'upload global plus simple pour les non-vidéos
+                processed_media_file = genai.upload_file(path=filepath, mime_type=mime_type)
+                uploaded_media_part = genai_types.Part(file_data=processed_media_file)
+            print(f"  Part Média ({media_type}) créé: {processed_media_file.uri}")
+
+        # 2. Sinon, traiter l'URL YouTube si fournie et valide
+        elif youtube_url:
+             if not is_youtube_url(youtube_url):
+                 print(f"  AVERTISSEMENT: '{youtube_url}' n'est pas un lien YouTube valide, sera ignoré ou traité comme texte si prompt vide.")
+                 # Si le prompt est aussi vide, on ne fait rien de spécial ici,
+                 # la validation initiale aurait dû échouer. Si prompt existe, il sera traité.
+                 media_type = 'text' # Considéré comme texte simple si invalide
+             else:
+                is_media_request = True
+                media_type = 'youtube'
+                print("  Traitement LIEN YouTube...")
+                uploaded_filename_for_display = youtube_url # Affiche l'URL pour l'utilisateur
+                youtube_uri = youtube_url # Utilise l'URL validée comme URI
+                # Crée un Part FileData directement à partir de l'URI
+                # On peut spécifier un mime_type générique, Gemini gère les liens YT
+                uploaded_media_part = genai_types.Part(
+                    file_data=genai_types.FileData(file_uri=youtube_uri, mime_type="video/mp4")
+                )
+                print(f"  Part YouTube créé pour: {youtube_uri}")
+                # Ajoute un prompt par défaut si l'utilisateur n'en a pas mis
+                if not prompt:
+                    prompt = "Décris ou analyse le contenu de cette vidéo YouTube."
+                    print(f"  Prompt par défaut ajouté pour YouTube: '{prompt}'")
+
+        # 3. Si ni fichier ni URL YT valide, c'est une requête texte
+        elif prompt:
+            media_type = 'text'
+            print("  Traitement PROMPT texte seul.")
         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
-
-    # --- 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
-    }
-    session['chat_history'].append(user_history_entry)
-    session.modified = True # Indiquer que la session a été modifiée
-
-    # --- Préparation des 'parts' pour l'appel Gemini ACTUEL ---
-    current_gemini_parts = []
-    if uploaded_gemini_file:
-        current_gemini_parts.append(uploaded_gemini_file) # L'objet fichier uploadé
-
-    final_prompt_for_gemini = raw_user_text # Commencer avec le texte brut
-
-    # --- Recherche Web (si activée et si un prompt textuel existe) ---
-    if use_web_search and raw_user_text:
-        print("Activation de la recherche web...")
-        search_data = perform_web_search(raw_user_text)
-        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:
+            # Ce cas ne devrait pas arriver à cause de la validation initiale
+            raise ValueError("Aucune entrée valide (fichier, URL YouTube ou texte) fournie.")
+
+        # --- Préparer et stocker le message utilisateur dans l'historique ---
+        # Construit le texte qui sera affiché dans l'historique du chat
+        display_user_text = prompt # Par défaut, le prompt texte
+        if media_type == 'file' or media_type == 'video':
+            # Précède le prompt par le nom du fichier entre crochets
+            display_user_text = f"[{uploaded_filename_for_display}]" + (f" {prompt}" if prompt else "")
+        elif media_type == 'youtube':
+             # Précède par [YouTube], ajoute le prompt, puis l'URL sur une nouvelle ligne
+             display_user_text = f"[YouTube]" + (f" {prompt}" if prompt else "") + f"\n{uploaded_filename_for_display}"
+
+        user_history_entry = {
+            'role': 'user',
+            'text': display_user_text,    # Texte formaté pour l'affichage
+            'raw_text': prompt            # Texte brut original pour futurs appels Gemini
+            # Note: On ne stocke pas l'objet media_part dans la session
+        }
+        session['chat_history'].append(user_history_entry)
+        session.modified = True # Marque la session comme modifiée
+
+        # --- Préparer les 'parts' pour l'appel API Gemini ---
+        current_gemini_parts = []
+        # Ajouter le média (fichier uploadé ou URL YT) s'il existe
+        if uploaded_media_part:
+            current_gemini_parts.append(uploaded_media_part)
+
+        # Préparer le prompt textuel final (peut être enrichi par la recherche web)
+        final_prompt_for_gemini = prompt
+
+        # --- Recherche Web (Optionnelle, uniquement pour les requêtes texte) ---
+        if use_web_search and prompt and media_type == 'text':
+            print("  Activation Recherche Web...")
+            search_data = perform_web_search(prompt)
+            if search_data:
+                formatted_results = format_search_results(search_data)
+                # Construit un prompt enrichi
+                final_prompt_for_gemini = f"""Basé sur la question suivante et les informations web ci-dessous, fournis une réponse complète.
+
+Question Originale:
+"{prompt}"
+
+Informations Web Pertinentes:
 --- 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.")
-        else:
-            print("Aucun résultat de recherche web pertinent trouvé ou erreur, utilisation du prompt original.")
-            # final_prompt_for_gemini reste raw_user_text
+Réponse:"""
+                print("  Prompt enrichi avec les résultats web.")
+            else:
+                print("  Aucun résultat de recherche web trouvé ou pertinent.")
 
-    # Ajouter le texte (potentiellement enrichi) aux parts pour Gemini
-    current_gemini_parts.append(final_prompt_for_gemini)
+        # Ajouter la partie texte (originale ou enrichie) s'il y a du texte
+        if final_prompt_for_gemini:
+             current_gemini_parts.append(genai_types.Part(text=final_prompt_for_gemini))
 
-    # --- Appel à l'API Gemini ---
-    try:
-        # Préparer l'historique des messages PRÉCÉDENTS
+        # Vérification de sécurité : il doit y avoir au moins une partie (média ou texte)
+        if not current_gemini_parts:
+             print("ERREUR: Aucune partie (média ou texte) à envoyer à Gemini.")
+             raise ValueError("Impossible de traiter la requête : contenu vide.")
+
+
+        # --- Appel à l'API Gemini ---
+        # Prépare l'historique des messages PRÉCÉDENTS (texte seulement)
         gemini_history = prepare_gemini_history(session['chat_history'][:-1]) # Exclut le message actuel
-        print(f"Préparation de l'appel Gemini avec {len(gemini_history)} messages d'historique.")
-        # Construire le contenu complet pour l'appel
+        # Construit le contenu complet pour l'appel API
         contents_for_gemini = gemini_history + [{'role': 'user', 'parts': current_gemini_parts}]
 
-        # Choisir le nom du modèle à utiliser
-        selected_model_name = MODEL_PRO if use_advanced else MODEL_FLASH
-        print(f"Utilisation du modèle Gemini: {selected_model_name}")
+        # Sélectionne le modèle : Pro pour média ou si avancé demandé, sinon Flash
+        selected_model_name = MODEL_PRO if is_media_request or use_advanced else MODEL_FLASH
+        print(f"  Modèle sélectionné: {selected_model_name}")
 
-        # Créer l'instance du modèle spécifique pour cette requête
-        # Réutiliser les paramètres globaux (safety, system instruction)
+        # Crée l'instance du modèle spécifique pour cette requête
         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"  Envoi de la requête à {selected_model_name} ({len(contents_for_gemini)} messages/tours)...")
+        # Appel API (non-streamé pour correspondre au code précédent)
         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 ---
+        response_text_raw = ""
+        response_html = ""
         try:
+             # Accède au texte de la réponse. Peut lever une exception si bloqué.
              response_text_raw = response.text
-        except ValueError:
-            # Si response.text échoue, la réponse a probablement été bloquée.
-            print("ERREUR: La réponse de Gemini a été bloquée (probablement par les safety settings).")
-            print(f"Détails du blocage : {response.prompt_feedback}")
-            # Vous pouvez décider quoi renvoyer au client ici.
-            # Soit une erreur spécifique, soit un message générique.
+        except ValueError: # Typiquement levé si la réponse est bloquée par les filtres
+            print("  ERREUR: La réponse de Gemini a été bloquée (probablement par les safety settings).")
+            # Fournit les détails du blocage si disponibles
+            try: print(f"  Détails du blocage : {response.prompt_feedback}")
+            except Exception: pass # Ignore si prompt_feedback n'est pas accessible
             response_text_raw = "Désolé, ma réponse a été bloquée car elle pourrait enfreindre les règles de sécurité."
-            # Convertir ce message d'erreur en HTML aussi pour la cohérence
-            response_html = markdown.markdown(response_text_raw)
+        except Exception as resp_err: # Gère d'autres erreurs potentielles
+             print(f"  ERREUR inattendue lors de l'accès à response.text : {resp_err}")
+             print(f"  Réponse brute complète : {response}") # Log la réponse brute pour le debug
+             response_text_raw = "Désolé, une erreur interne s'est produite lors de la réception de la réponse."
 
-        else:
-            # Si response.text réussit, continuer normalement
-            print(f"Réponse reçue de Gemini (brute, début): '{response_text_raw[:100]}...'")
-            # Convertir la réponse Markdown en HTML pour l'affichage
-            response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
-            print("Réponse convertie en HTML.")
+        # Convertit la réponse (même les messages d'erreur) en HTML
+        print(f"  Réponse reçue (début): '{response_text_raw[:100]}...'")
+        response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
+        print("  Réponse convertie en HTML.")
 
-
-        # Ajouter la réponse de l'assistant à l'historique de session
+        # --- Stocker la réponse de l'assistant et retourner au client ---
         assistant_history_entry = {
             'role': 'assistant',
             'text': response_html,      # HTML pour l'affichage via get_history
@@ -364,61 +425,63 @@ En te basant sur ces informations ET sur ta connaissance générale, fournis une
         session['chat_history'].append(assistant_history_entry)
         session.modified = True
 
-        # Renvoyer la réponse HTML au frontend
-        print("Envoi de la réponse HTML au client.")
+        print("  Envoi de la réponse HTML au client.")
         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
+    # --- Gestion des Erreurs spécifiques (Timeout, Fichier invalide, etc.) ---
+    except (TimeoutError, ValueError, ConnectionError, FileNotFoundError) as e:
+        error_message = f"Erreur lors du traitement de la requête: {e}"
+        print(f"ERREUR (Traitement/Appel API): {error_message}")
+        # Retire le dernier message utilisateur de l'historique en cas d'erreur pour éviter les boucles
         if session.get('chat_history'):
             session['chat_history'].pop()
             session.modified = True
-            print("Le dernier message utilisateur a été retiré de l'historique suite à l'erreur.")
-        else:
-            print("L'historique était déjà vide lors de l'erreur.")
+            print("  Dernier message utilisateur retiré de l'historique après erreur.")
+        return jsonify({'success': False, 'error': error_message}), 500 # Erreur serveur
 
-        # 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
+    # --- Gestion des Erreurs Génériques/Inattendues ---
+    except Exception as e:
+        error_message = f"Une erreur interne inattendue est survenue: {e}"
+        print(f"ERREUR CRITIQUE INATTENDUE: {error_message}", exc_info=True) # Log la traceback complète
+        if session.get('chat_history'):
+            session['chat_history'].pop()
+            session.modified = True
+            print("  Dernier message utilisateur retiré de l'historique après erreur inattendue.")
+        return jsonify({'success': False, 'error': error_message}), 500
 
+    # --- Nettoyage (Exécuté dans tous les cas : succès ou erreur) ---
     finally:
-        # --- Nettoyage du fichier temporaire ---
         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é avec succès.")
+                print(f"  Fichier temporaire '{filepath_to_delete}' supprimé avec succès.")
             except OSError as e:
-                print(f"ERREUR lors de la suppression du fichier temporaire '{filepath_to_delete}': {e}")
+                print(f"  ERREUR lors de la suppression du fichier temporaire '{filepath_to_delete}': {e}")
 
 
 @app.route('/clear', methods=['POST'])
 def clear_chat():
     """Efface l'historique de chat dans la session."""
-    session.pop('chat_history', None)
-    # session.pop('web_search', None) # On ne stocke pas ça en session
+    session.pop('chat_history', None) # Supprime la clé de la session
     print("API: Historique de chat effacé via /clear.")
 
-    # Adapter la réponse selon si c'est une requête AJAX (fetch) ou une soumission classique
-    # Vérification si la requête vient probablement de fetch (simple)
-    is_ajax = 'XMLHttpRequest' == request.headers.get('X-Requested-With') or \
-              'application/json' in request.headers.get('Accept', '') # Plus robuste
+    # Détecte si la requête vient d'AJAX (fetch) pour répondre en JSON
+    is_ajax = request.headers.get('X-Requested-With') == 'XMLHttpRequest' or \
+              'application/json' in request.headers.get('Accept', '')
 
     if is_ajax:
          return jsonify({'success': True, 'message': 'Historique effacé.'})
     else:
-        # Comportement pour une soumission de formulaire classique (si jamais utilisé)
+        # Comportement pour une soumission de formulaire classique (moins probable ici)
         flash("Conversation effacée.", "info")
-        return redirect(url_for('root')) # Redirige vers la racine
+        return redirect(url_for('root')) # Redirige vers la page d'accueil
 
 
-# --- Démarrage de l'application ---
+# --- Démarrage de l'application Flask ---
 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 !
-    # Changer le port si nécessaire (ex: 5000, 5001, 8080)
-    # Utiliser un port différent si le port 5000 est déjà pris
+    # Utiliser un port différent si 5000 est déjà pris (ex: 5001)
     port = int(os.environ.get('PORT', 5001))
+    # debug=True : Rechargement auto, messages d'erreur détaillés (NE PAS UTILISER EN PRODUCTION)
+    # host='0.0.0.0' : Rend l'app accessible sur le réseau local
     app.run(debug=True, host='0.0.0.0', port=port)