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

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)

def send_image_to_telegram(image_path, caption=""):
    """Envoie une image vers le groupe Telegram avec meilleure gestion d'erreurs."""
    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendPhoto"
    
    try:
        # Vérifier que le fichier existe et est lisible
        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"
        
        # Vérifier la taille du fichier (limite Telegram: 10MB pour les photos via API)
        file_size = os.path.getsize(image_path)
        if file_size > 10 * 1024 * 1024:  # 10MB pour l'API Bot
            logger.error(f"Fichier trop volumineux: {file_size} bytes")
            return False, f"Fichier trop volumineux: {file_size} bytes (limite: 10MB)"
        
        # Vérifier que le fichier n'est pas vide
        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)")
        logger.info(f"Chat ID: {TELEGRAM_CHAT_ID}")
        logger.info(f"Caption: {caption}")
        
        # Ouvrir et envoyer le fichier
        with open(image_path, 'rb') as photo:
            files = {'photo': ('image.jpg', photo, 'image/jpeg')}
            data = {
                'chat_id': TELEGRAM_CHAT_ID,
                'caption': caption[:1024] if caption else ""  # Telegram limite les captions à 1024 caractères
            }
            
            logger.debug(f"Données envoyées: {data}")
            response = requests.post(url, files=files, data=data, timeout=120)
            
            logger.info(f"Réponse HTTP: {response.status_code}")
            logger.debug(f"Contenu de la réponse: {response.text}")
            
            if response.status_code == 200:
                response_json = response.json()
                if response_json.get('ok'):
                    logger.info("Image envoyée avec succès")
                    return True, "Image envoyée avec succès"
                else:
                    error_msg = response_json.get('description', 'Erreur inconnue')
                    logger.error(f"Erreur API Telegram: {error_msg}")
                    return False, f"Erreur API Telegram: {error_msg}"
            else:
                logger.error(f"Erreur HTTP {response.status_code}: {response.text}")
                return False, f"Erreur HTTP {response.status_code}: {response.text}"
                
    except requests.exceptions.Timeout:
        logger.error("Timeout lors de l'envoi vers Telegram")
        return False, "Timeout lors de l'envoi vers Telegram"
    except requests.exceptions.RequestException as e:
        logger.error(f"Erreur de requête: {str(e)}")
        return False, f"Erreur de requête: {str(e)}"
    except Exception as e:
        logger.error(f"Erreur inattendue: {str(e)}")
        return False, f"Erreur inattendue: {str(e)}"

def test_bot_permissions():
    """Teste les permissions du bot dans le groupe."""
    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/getChat"
    
    try:
        data = {'chat_id': TELEGRAM_CHAT_ID}
        response = requests.post(url, data=data, timeout=30)
        
        logger.info(f"Test permissions - Status: {response.status_code}")
        logger.debug(f"Test permissions - Response: {response.text}")
        
        if response.status_code == 200:
            chat_info = response.json()
            if chat_info.get('ok'):
                return True, f"Bot autorisé dans le chat: {chat_info['result'].get('title', 'Chat sans titre')}"
            else:
                return False, f"Erreur API: {chat_info.get('description')}"
        else:
            return False, f"Erreur HTTP: {response.status_code} - {response.text}"
            
    except Exception as e:
        logger.error(f"Erreur test permissions: {str(e)}")
        return False, f"Erreur: {str(e)}"

def send_message_to_telegram(message):
    """Envoie un message texte vers le groupe Telegram."""
    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
    
    try:
        data = {
            'chat_id': TELEGRAM_CHAT_ID,
            'text': message,
            'parse_mode': 'HTML'
        }
        
        response = requests.post(url, data=data, timeout=30)
        
        if response.status_code == 200:
            response_json = response.json()
            if response_json.get('ok'):
                return True, "Message envoyé avec succès"
            else:
                return False, f"Erreur API: {response_json.get('description')}"
        else:
            return False, f"Erreur Telegram: {response.status_code} - {response.text}"
            
    except Exception as e:
        logger.error(f"Erreur envoi message: {str(e)}")
        return False, f"Erreur lors de l'envoi: {str(e)}"

# Nouvelle route pour tester les permissions
@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
    })

@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 des permissions avant envoi
        perm_success, perm_message = test_bot_permissions()
        logger.info(f"Test permissions: {perm_success} - {perm_message}")

        # 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[:3500]}..."
        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_permissions": {"success": perm_success, "message": perm_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
        }), 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")
    return jsonify({
        "success": success,
        "message": message
    })

@app.route('/debug_telegram', methods=['GET'])
def debug_telegram():
    """Route pour débugger les problèmes Telegram."""
    results = {}
    
    # Test 1: Permissions du bot
    perm_success, perm_message = test_bot_permissions()
    results['permissions'] = {"success": perm_success, "message": perm_message}
    
    # Test 2: Envoi d'un message simple
    msg_success, msg_message = send_message_to_telegram("🔧 Test de débogage")
    results['message_test'] = {"success": msg_success, "message": msg_message}
    
    # Test 3: 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)