app.py

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 Markdown en HTML

# --- Configuration Initiale ---
load_dotenv() # Charge les variables depuis .env

app = Flask(__name__)
# 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'
# 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
# Augmenter la limite pour les vidéos (ex: 100MB) - Ajustez si nécessaire
app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024

# 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 ---
# 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:
        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:
        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 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 (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
    # ... (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 (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'):
        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 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'
        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 ---

@app.route('/')
def root():
    """Sert la page HTML principale."""
    return render_template('index.html')

@app.route('/api/history', methods=['GET'])
def get_history():
    """Fournit l'historique de chat (formaté pour affichage) en JSON."""
    if 'chat_history' not in session:
        session['chat_history'] = []

    # 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 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 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

    # --- Récupération des données du formulaire ---
    prompt = request.form.get('prompt', '').strip()
    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 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: '{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}")

    # Initialise l'historique de session si nécessaire
    if 'chat_history' not in session:
        session['chat_history'] = []

    # --- 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'

    # --- 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:
            # 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 ---

Réponse:"""
                print("  Prompt enrichi avec les résultats web.")
            else:
                print("  Aucun résultat de recherche web trouvé ou pertinent.")

        # 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))

        # 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
        # Construit le contenu complet pour l'appel API
        contents_for_gemini = gemini_history + [{'role': 'user', 'parts': current_gemini_parts}]

        # 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é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,
            system_instruction=SYSTEM_INSTRUCTION
        )

        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)

        # --- 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: # 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é."
        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."

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

        # --- 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
            'raw_text': response_text_raw # Texte brut pour les futurs appels Gemini
        }
        session['chat_history'].append(assistant_history_entry)
        session.modified = True

        print("  Envoi de la réponse HTML au client.")
        return jsonify({'success': True, 'message': response_html})

    # --- 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("  Dernier message utilisateur retiré de l'historique après erreur.")
        return jsonify({'success': False, 'error': error_message}), 500 # Erreur serveur

    # --- 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:
        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.")
            except OSError as 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) # Supprime la clé de la session
    print("API: Historique de chat effacé via /clear.")

    # 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 (moins probable ici)
        flash("Conversation effacée.", "info")
        return redirect(url_for('root')) # Redirige vers la page d'accueil


# --- Démarrage de l'application Flask ---
if __name__ == '__main__':
    print("Démarrage du serveur Flask...")
    # 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)