app.py

from flask import Flask, request, render_template, jsonify
import PIL.Image
from google import genai
from google.genai import types
import telebot
import os
from tempfile import NamedTemporaryFile
import tempfile
from datetime import datetime
import logging
import time

app = Flask(__name__)

# Configuration du logging pour débugger
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

# Configuration de Gemini
generation_config = {
  "temperature": 1,
  "max_output_tokens": 8192,
}

safety_settings = [
    types.SafetySetting(
        category="HARM_CATEGORY_HARASSMENT",
        threshold="BLOCK_NONE",
    ),
    types.SafetySetting(
        category="HARM_CATEGORY_HATE_SPEECH",
        threshold="BLOCK_NONE",
    ),
    types.SafetySetting(
        category="HARM_CATEGORY_SEXUALLY_EXPLICIT",
        threshold="BLOCK_NONE",
    ),
    types.SafetySetting(
        category="HARM_CATEGORY_DANGEROUS_CONTENT",
        threshold="BLOCK_NONE",
    ),
]

# Configuration des tokens et IDs
GOOGLE_API_KEY = os.environ.get("TOKEN")
TELEGRAM_BOT_TOKEN = "8180304240:AAGJZ_MJ6eKtbymxkqzjgOJCr6PWb7uas9U"
TELEGRAM_CHAT_ID = "-4972732072"

gen = GOOGLE_API_KEY 
client = genai.Client(api_key=gen)

# Initialisation du bot Telegram avec options avancées
try:
    bot = telebot.TeleBot(
        TELEGRAM_BOT_TOKEN,
        parse_mode='HTML',
        disable_web_page_preview=True,
        timeout=60,  # Timeout plus long
        num_threads=2  # Utiliser plusieurs threads
    )
    logger.info("Bot Telegram initialisé avec succès")
except Exception as e:
    logger.error(f"Erreur initialisation bot: {e}")
    bot = None

def send_image_to_telegram(image_path, caption="", max_retries=3):
    """Envoie une image vers le groupe Telegram avec pyTelegramBotAPI."""
    if not bot:
        return False, "Bot Telegram non initialisé"
    
    try:
        # Vérifications de base
        if not os.path.exists(image_path):
            logger.error(f"Le fichier {image_path} n'existe pas")
            return False, f"Le fichier {image_path} n'existe pas"
        
        file_size = os.path.getsize(image_path)
        if file_size > 50 * 1024 * 1024:  # 50MB limite pour les documents
            logger.error(f"Fichier trop volumineux: {file_size} bytes")
            return False, f"Fichier trop volumineux: {file_size} bytes (limite: 50MB)"
        
        if file_size == 0:
            logger.error(f"Fichier vide: {image_path}")
            return False, f"Fichier vide: {image_path}"
        
        logger.info(f"Envoi de l'image: {image_path} (taille: {file_size} bytes)")
        
        # Tentatives d'envoi avec retry automatique
        for attempt in range(max_retries):
            try:
                logger.info(f"Tentative {attempt + 1}/{max_retries}")
                
                with open(image_path, 'rb') as photo:
                    # Si le fichier est < 10MB, l'envoyer comme photo
                    if file_size < 10 * 1024 * 1024:
                        message = bot.send_photo(
                            chat_id=TELEGRAM_CHAT_ID,
                            photo=photo,
                            caption=caption[:1024] if caption else "",
                            timeout=120
                        )
                    else:
                        # Sinon l'envoyer comme document
                        message = bot.send_document(
                            chat_id=TELEGRAM_CHAT_ID,
                            document=photo,
                            caption=caption[:1024] if caption else "",
                            timeout=120
                        )
                
                logger.info(f"✅ Image envoyée avec succès (Message ID: {message.message_id})")
                return True, f"Image envoyée avec succès (tentative {attempt + 1})"
                
            except telebot.apihelper.ApiTelegramException as e:
                logger.error(f"Erreur API Telegram (tentative {attempt + 1}): {e}")
                if attempt == max_retries - 1:  # Dernière tentative
                    return False, f"Erreur API Telegram après {max_retries} tentatives: {str(e)}"
                time.sleep(2 ** attempt)  # Backoff exponentiel
                
            except Exception as e:
                logger.error(f"Erreur inattendue (tentative {attempt + 1}): {e}")
                if attempt == max_retries - 1:
                    return False, f"Erreur inattendue après {max_retries} tentatives: {str(e)}"
                time.sleep(2 ** attempt)
        
        return False, f"Échec après {max_retries} tentatives"
        
    except Exception as e:
        logger.error(f"Erreur critique lors de l'envoi: {str(e)}")
        return False, f"Erreur critique: {str(e)}"

def send_message_to_telegram(message, max_retries=3):
    """Envoie un message texte vers le groupe Telegram."""
    if not bot:
        return False, "Bot Telegram non initialisé"
    
    try:
        # Diviser le message s'il est trop long (limite Telegram: 4096 caractères)
        max_length = 4000  # On garde une marge
        messages = []
        
        if len(message) <= max_length:
            messages = [message]
        else:
            # Diviser le message en chunks
            for i in range(0, len(message), max_length):
                chunk = message[i:i + max_length]
                messages.append(chunk)
        
        # Envoyer chaque partie
        for i, msg_part in enumerate(messages):
            for attempt in range(max_retries):
                try:
                    logger.info(f"Envoi message partie {i + 1}/{len(messages)} (tentative {attempt + 1})")
                    
                    sent_message = bot.send_message(
                        chat_id=TELEGRAM_CHAT_ID,
                        text=msg_part,
                        parse_mode='HTML',
                        timeout=60
                    )
                    
                    logger.info(f"✅ Message partie {i + 1} envoyé (ID: {sent_message.message_id})")
                    break  # Sortir de la boucle de retry si réussi
                    
                except telebot.apihelper.ApiTelegramException as e:
                    logger.error(f"Erreur API Telegram partie {i + 1} (tentative {attempt + 1}): {e}")
                    if attempt == max_retries - 1:
                        return False, f"Erreur API après {max_retries} tentatives: {str(e)}"
                    time.sleep(2 ** attempt)
                    
                except Exception as e:
                    logger.error(f"Erreur inattendue partie {i + 1} (tentative {attempt + 1}): {e}")
                    if attempt == max_retries - 1:
                        return False, f"Erreur inattendue après {max_retries} tentatives: {str(e)}"
                    time.sleep(2 ** attempt)
        
        return True, f"Message envoyé avec succès ({len(messages)} partie(s))"
        
    except Exception as e:
        logger.error(f"Erreur critique envoi message: {str(e)}")
        return False, f"Erreur critique: {str(e)}"

def test_bot_permissions():
    """Teste les permissions du bot dans le groupe."""
    if not bot:
        return False, "Bot Telegram non initialisé"
    
    try:
        logger.info("Test des permissions du bot...")
        
        # Obtenir les informations du chat
        chat = bot.get_chat(TELEGRAM_CHAT_ID)
        logger.info(f"Chat trouvé: {chat.title if hasattr(chat, 'title') else 'Chat privé'}")
        
        # Obtenir les informations du bot
        bot_info = bot.get_me()
        logger.info(f"Bot: @{bot_info.username} ({bot_info.first_name})")
        
        # Tester l'envoi d'un message simple
        test_message = bot.send_message(
            chat_id=TELEGRAM_CHAT_ID,
            text="🔧 Test de permissions réussi",
            timeout=30
        )
        
        return True, f"Bot @{bot_info.username} autorisé dans '{chat.title if hasattr(chat, 'title') else 'le chat'}'"
        
    except telebot.apihelper.ApiTelegramException as e:
        logger.error(f"Erreur API lors du test: {e}")
        return False, f"Erreur API Telegram: {str(e)}"
    except Exception as e:
        logger.error(f"Erreur lors du test des permissions: {str(e)}")
        return False, f"Erreur: {str(e)}"

def get_bot_status():
    """Obtient le statut du bot et des connexions."""
    status = {
        "bot_initialized": bot is not None,
        "bot_info": None,
        "chat_info": None,
        "api_accessible": False
    }
    
    if bot:
        try:
            # Informations du bot
            bot_info = bot.get_me()
            status["bot_info"] = {
                "username": bot_info.username,
                "first_name": bot_info.first_name,
                "id": bot_info.id,
                "is_bot": bot_info.is_bot
            }
            status["api_accessible"] = True
            
            # Informations du chat
            try:
                chat = bot.get_chat(TELEGRAM_CHAT_ID)
                status["chat_info"] = {
                    "id": chat.id,
                    "type": chat.type,
                    "title": getattr(chat, 'title', 'N/A'),
                    "member_count": getattr(chat, 'member_count', 'N/A')
                }
            except Exception as e:
                status["chat_error"] = str(e)
                
        except Exception as e:
            status["bot_error"] = str(e)
    
    return status

# Routes Flask
@app.route('/bot_status', methods=['GET'])
def bot_status():
    """Route pour obtenir le statut du bot."""
    return jsonify(get_bot_status())

@app.route('/test_bot_permissions', methods=['GET'])
def test_bot_permissions_route():
    """Route pour tester les permissions du bot."""
    success, message = test_bot_permissions()
    return jsonify({
        "success": success,
        "message": message,
        "bot_status": get_bot_status()
    })

@app.route('/', methods=['GET'])
def svt():
    """Renders the SVT page."""
    return render_template("svt.html")

methodologie_svt = {
    "Restitution organisée des connaissances": """
**Restitution organisée des connaissances (ROC)**

**Objectif:** Exposer, dans un texte structuré, scientifiquement et grammaticalement correct, illustré si nécessaire, des connaissances sur un point du programme.

**Structure de la ROC:**

*   **Introduction:**
    *   Contexte: Synthèse des savoirs (prérequis) nécessaires pour aborder le thème.
    *   Problème: Reformulation de la consigne sous forme interrogative, découlant logiquement du contexte.
    *   Plan: Annonce des parties du développement.
*   **Développement:**
    *   Au moins deux paragraphes séparés par une ligne, débutant par un titre souligné.
    *   Titres: Reprise des parties annoncées dans le plan.
    *   Contenu: Solution du problème, articulation logique des paragraphes.
    *   Schéma: Si la consigne l'exige.
*   **Conclusion:**
    *   Réponse logique au problème posé dans l'introduction.
    *   Intégration des aspects développés.
    *   Correspondance à la thématique de l'exercice.

**Conseils:**

*   L'exercice ne comporte pas de documents.
*   Le sujet comporte un thème, un contexte et une consigne.
*   L'exercice est pondéré sur 7 à 8 points.
""",
    "Exploitation du document": """
**Exploitation de documents (ED)**

**Objectif:** Trouver le lien entre les informations présentées par un des documents et les connaissances d'un segment de connaissances (partie du programme) en vue de la résolution d'un problème scientifique.

**Structure de l'ED:**

*   **Introduction** (écrite au brouillon) : Problème (reformulation de la consigne)
*   **Pour chaque document :**
    *   **Présentation (CP1):** Type de document + titre (cf. titre).
    *   **Analyse (CP2):** Description du fait expérimental (comparaison de courbes, résultats d'expérience) et/ou présentation du fait d'observation (changement de coloration, % de phénotypes). détaille bien cette partie 
    *   **Information saisie (CP3):** Conclusion partielle, fait à interpréter.
    *   **Mise en relation (CP4):** Interprétation de l'information saisie en utilisant les connaissances acquises, signification permettant la résolution du problème.
*   **Synthèse des mises en relation (CP5)** : Lien pertinent et cohérent entre toutes les significations (mise en relation) des informations utiles pour résoudre le problème (répondre à la consigne). Cette partie est séparée du reste par deux lignes.

**Conseils:**

*   L'exercice comporte un thème, un contexte, une consigne, un ou deux documents, et une pondération (7-8 points).
*   Le contexte établit le lien entre le thème et les documents.
*   La consigne guide l'élève dans les différentes tâches.
*   Les documents doivent comporter un titre et une source, être pertinents, lisibles, et suivre l'ordre chronologique de la résolution.
*   Ne pas paraphraser, copier ou faire une description intégrale dans l'analyse (CP2).
*   La tâche 4 (CP4) est spécifique à cet exercice.
*   Mentionner le document traité (ex: Document 1).

réponse attendu uniquement en langue française.
""",
    "Synthèse": """
**Élaboration d'une synthèse (ES)**

**Objectif:** Dégager des informations pertinentes d'un ensemble de documents en vue de résoudre un problème scientifique. La résolution du problème ne fait pas appel directement aux connaissances du cours.

**Structure de l'ES:**

*   **Introduction** (écrite au brouillon) : Problème (reformulation de la consigne)
*   **Pour chaque document :**
    *   **Présentation (CP1):** Type de document + titre (cf. titre).
    *   **Analyse (CP2):** Description du fait expérimental (comparaison de courbes, résultats d'expérience) et/ou présentation du fait d'observation (changement de coloration, % de phénotypes).
    *   **Conclusion partielle (CP3):** Synthèse de l'analyse, élément de réponse au problème.
*   **Conclusion générale (CP4):** Récapitulation des conclusions partielles, réponse à la consigne.

**Conseils:**

*   L'exercice comporte un thème, un contexte, une consigne, deux ou trois documents, et une pondération (5 points).
*   Le contexte établit le lien entre le thème et les documents.
*   La consigne guide l'élève dans les différentes tâches.
*   Les documents doivent comporter un titre et une source, être pertinents, lisibles, et suivre l'ordre chronologique de la résolution.
*   Ne pas paraphraser, copier ou faire une description intégrale dans l'analyse (CP2).
*   La tâche 3 (CP3) est spécifique à cet exercice.
*   Mentionner le document traité (ex: Document 1).
*   Toutes les informations nécessaires sont dans les documents.
"""
}

@app.route('/svt_submit', methods=['POST'])
def svt_submit():
    """Handles the submission of SVT exercises."""
    option = request.form.get('option')
    images = request.files.getlist('images')

    logger.info(f"Traitement d'un exercice SVT: {option}")
    logger.info(f"Nombre d'images reçues: {len(images)}")

    content = [f"J'aimerais que tu traites entièrement cet exercice en respectant scrupuleusement la méthodologie d'SVT suivante :\n\n{methodologie_svt[option]}\n\nLe type d'exercice selon la méthodologie est : {option}. Voici les images de l'exercice:"]
    temp_files = []
    telegram_results = []

    try:
        # Test du statut du bot avant traitement
        bot_status = get_bot_status()
        logger.info(f"Statut du bot: {bot_status}")

        # Traitement des images
        for i, image in enumerate(images):
            if image and image.filename:
                logger.info(f"Traitement de l'image {i+1}: {image.filename}")
                
                # Créer un fichier temporaire avec l'extension correcte
                file_extension = os.path.splitext(image.filename)[1].lower()
                if not file_extension:
                    file_extension = '.jpg'  # Extension par défaut
                
                with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file:
                    # Sauvegarder l'image
                    image.save(temp_file.name)
                    temp_files.append(temp_file.name)
                    
                    # Vérifier que l'image a été sauvegardée correctement
                    if os.path.getsize(temp_file.name) > 0:
                        logger.info(f"Image sauvegardée: {temp_file.name} ({os.path.getsize(temp_file.name)} bytes)")
                        
                        # Ajouter l'image au contenu pour Gemini
                        try:
                            pil_image = PIL.Image.open(temp_file.name)
                            content.append(pil_image)
                            logger.info(f"Image ajoutée au contenu Gemini: {pil_image.size}")
                        except Exception as e:
                            logger.error(f"Erreur lors de l'ouverture de l'image pour Gemini: {e}")
                        
                        # Envoi de l'image vers Telegram
                        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                        caption = f"📚 Exercice SVT - {option}\n🕐 {timestamp}\n📄 Image {i+1}/{len([img for img in images if img.filename])}"
                        
                        logger.info(f"Tentative d'envoi vers Telegram: {temp_file.name}")
                        success, message = send_image_to_telegram(temp_file.name, caption)
                        telegram_results.append({
                            'image': f"Image {i+1} - {image.filename}",
                            'success': success,
                            'message': message
                        })
                        
                        if success:
                            logger.info(f"✅ Image {i+1} envoyée avec succès")
                        else:
                            logger.error(f"❌ Échec envoi image {i+1}: {message}")
                    else:
                        logger.error(f"Fichier temporaire vide pour l'image {i+1}")
                        telegram_results.append({
                            'image': f"Image {i+1} - {image.filename}",
                            'success': False,
                            'message': "Fichier temporaire vide"
                        })

        logger.info(f"Résultats Telegram: {telegram_results}")

        # Génération de la réponse avec Gemini
        logger.info("Génération de la réponse avec Gemini...")
        response = client.models.generate_content(
            model="gemini-2.5-flash",
            contents=[content],
            config=types.GenerateContentConfig(
                safety_settings=safety_settings,
            )
        )
        
        answer = response.candidates[0].content.parts[0].text
        logger.info("Réponse générée avec succès")
        
        # Envoi de la réponse vers Telegram
        telegram_message = f"🤖 <b>Réponse générée</b>\n\n📝 <b>Type:</b> {option}\n\n{answer}"
        msg_success, msg_message = send_message_to_telegram(telegram_message)
        logger.info(f"Envoi réponse Telegram: {msg_success} - {msg_message}")
        
        return jsonify({
            "response": answer,
            "telegram_status": telegram_results,
            "bot_status": bot_status,
            "response_sent": {"success": msg_success, "message": msg_message}
        })

    except Exception as e:
        logger.error(f"Erreur lors du traitement: {str(e)}")
        error_message = f"❌ <b>Erreur lors du traitement</b>\n\n🔍 <b>Type:</b> {option}\n💥 <b>Erreur:</b> {str(e)}"
        send_message_to_telegram(error_message)
        
        return jsonify({
            "error": "Erreur lors du traitement",
            "details": str(e),
            "telegram_status": telegram_results,
            "bot_status": get_bot_status()
        }), 500
        
    finally:
        # Nettoyage des fichiers temporaires
        for temp_file in temp_files:
            try:
                if os.path.exists(temp_file):
                    os.unlink(temp_file)
                    logger.info(f"Fichier temporaire supprimé: {temp_file}")
            except Exception as e:
                logger.error(f"Erreur lors de la suppression du fichier {temp_file}: {e}")

@app.route('/test_telegram', methods=['GET'])
def test_telegram():
    """Route pour tester la connexion Telegram."""
    success, message = send_message_to_telegram("🧪 Test de connexion du bot SVT avec pyTelegramBotAPI")
    return jsonify({
        "success": success,
        "message": message,
        "bot_status": get_bot_status()
    })

@app.route('/debug_telegram', methods=['GET'])
def debug_telegram():
    """Route pour débugger les problèmes Telegram."""
    results = {}
    
    # Test 1: Statut du bot
    results['bot_status'] = get_bot_status()
    
    # Test 2: Permissions du bot
    perm_success, perm_message = test_bot_permissions()
    results['permissions'] = {"success": perm_success, "message": perm_message}
    
    # Test 3: Envoi d'un message simple
    msg_success, msg_message = send_message_to_telegram("🔧 Test de débogage avec pyTelegramBotAPI")
    results['message_test'] = {"success": msg_success, "message": msg_message}
    
    # Test 4: Vérification des variables d'environnement
    results['config'] = {
        "bot_token_set": bool(TELEGRAM_BOT_TOKEN),
        "chat_id_set": bool(TELEGRAM_CHAT_ID),
        "bot_token_format": TELEGRAM_BOT_TOKEN.startswith("8180304240:") if TELEGRAM_BOT_TOKEN else False,
        "chat_id_format": TELEGRAM_CHAT_ID.startswith("-") if TELEGRAM_CHAT_ID else False
    }
    
    return jsonify(results)

if __name__ == '__main__':
    app.run(debug=True)