import os
import logging
import requests
import json
from django.conf import settings

logger = logging.getLogger(__name__)

# Assure-toi d'avoir GROQ_API_KEY dans ton .env
GROQ_API_URL = "https://api.groq.com/openai/v1/chat/completions"
# Modèle actuel Groq (mixtral-8x7b-32768 est déprécié → 400)
GROQ_CHAT_MODEL = "llama-3.1-8b-instant"
GROQ_QUIZ_MODEL = "llama-3.1-8b-instant"

def generate_quiz_questions(context_text, num_questions=3):
    """
    Génère un quiz JSON à partir d'un texte de cours via Groq.
    """
    api_key = os.getenv('GROQ_API_KEY')
    if not api_key:
        return {"error": "Clé API Groq manquante"}

    prompt = f"""
Tu es un expert pédagogique. Basé sur le texte de cours suivant, génère exactement {num_questions} questions à choix multiples (QCM) de niveau adapté.
Le texte du cours est :
\"\"\"
{context_text[:4000]}
\"\"\"

Format de réponse attendu (JSON strict, sans markdown) :
[
  {{
    "question": "Texte de la question",
    "options": ["Choix A", "Choix B", "Choix C", "Choix D"],
    "correct_index": 0
  }}
]
"""

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": GROQ_QUIZ_MODEL,
        "messages": [{"role": "user", "content": prompt}],
        "temperature": 0.5
    }

    fallback_quiz = [
        {"question": "Avez-vous bien lu le cours ?", "options": ["Oui", "Non"], "correct_index": 0}
    ]
    content = ""

    try:
        logger.info("[Groq Quiz] Envoi requête, contexte length=%s", len(context_text))
        response = requests.post(GROQ_API_URL, json=payload, headers=headers)
        logger.info("[Groq Quiz] Réponse status=%s", response.status_code)
        response.raise_for_status()
        result = response.json()
        choices = result.get('choices', [])
        if not choices or not choices[0].get('message'):
            logger.warning("[Groq Quiz] Réponse vide ou structure invalide")
            return fallback_quiz

        content = choices[0]['message'].get('content') or ""
        content = (content or "").strip()

        if not content:
            logger.warning("[Groq Quiz] Contenu de la réponse vide")
            return fallback_quiz

        # Nettoyage si l'IA ajoute du texte avant le JSON (ex: "Voici 15 questions...")
        if "```json" in content:
            content = content.split("```json")[1].split("```")[0].strip()
        elif "```" in content:
            parts = content.split("```")
            for p in parts:
                p = p.strip()
                if p.startswith("["):
                    content = p
                    break
        elif "[" in content and not content.strip().startswith("["):
            # Texte avant le JSON : extraire à partir du premier [
            start = content.find("[")
            content = content[start:].strip()

        parsed = json.loads(content)
        if isinstance(parsed, list) and len(parsed) > 0:
            return parsed
        return fallback_quiz
    except json.JSONDecodeError as e:
        logger.warning("[Groq Quiz] JSON invalide: %s - content preview: %s", e, (content[:200] if content else "vide"))
        content = ""
    except requests.RequestException as e:
        resp_text = getattr(getattr(e, "response", None), "text", None) or str(e)
        logger.warning("[Groq Quiz] RequestException status=%s body=%s", getattr(getattr(e, "response", None), "status_code", None), (resp_text[:500] if resp_text else "N/A"))
    except Exception as e:
        logger.warning("[Groq Quiz] Erreur: %s", e)
    return fallback_quiz


# ... (garde les imports et la fonction generate_quiz_questions existante)

def get_chat_response(context_text, user_message, chat_history=None, user_info=None):
    """
    Permet de discuter avec le contenu du cours ou de demander un résumé.
    context_text : Le texte du PDF de la leçon (extrait du PDF ou content_text).
    user_message : La question de l'étudiant (ex: "Fais-moi un résumé").
    user_info : dict optionnel avec first_name, last_name, email pour personnaliser.
    """
    if chat_history is None:
        chat_history = []
    api_key = os.getenv("GROQ_API_KEY")
    if not api_key:
        logger.warning("[Groq Chat] GROQ_API_KEY manquante dans .env")
        return "Erreur : Clé API Groq manquante. Ajoute GROQ_API_KEY dans le fichier .env du backend."

    # Tronquer si trop long (limite contexte Groq), mais garder un maximum de contenu utile
    max_context = 28000  # ~8k tokens pour laisser de la place à la réponse
    if len(context_text) > max_context:
        context_truncated = context_text[:max_context] + "\n\n[... contenu tronqué ...]"
    else:
        context_truncated = context_text

    user_block = ""
    if user_info and (user_info.get("first_name") or user_info.get("last_name") or user_info.get("email")):
        parts = []
        if user_info.get("first_name") or user_info.get("last_name"):
            parts.append(f"Prénom et nom : {user_info.get('first_name', '')} {user_info.get('last_name', '')}".strip())
        if user_info.get("email"):
            parts.append(f"Email : {user_info.get('email')}")
        user_block = "\nÉTUDIANT : " + " | ".join(parts) + "\n\n"

    system_prompt = f"""Tu es "Goonie", l'assistant pédagogique de la plateforme Goon. Tu as accès au contenu complet du cours ci-dessous et tu dois t'en servir pour répondre.
{user_block}
CONTENU DU COURS (utilise-le pour résumer, expliquer, répondre aux questions) :
---
{context_truncated}
---

RÈGLES :
1. Réponds en t'appuyant UNIQUEMENT sur le contenu du cours ci-dessus. Tu as bien accès à ce contenu.
2. Pour un résumé ou "points clés", fais une synthèse structurée (titres, listes) à partir de ce contenu.
3. Sois encourageant, clair et concis. Tu peux tutoyer l'étudiant.
4. Si une question sort du cadre du cours, dis-le poliment et propose de recentrer sur le cours.
"""

    messages = [{"role": "system", "content": system_prompt}]
    for msg in chat_history:
        messages.append(msg)
    messages.append({"role": "user", "content": user_message})

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    payload = {
        "model": GROQ_CHAT_MODEL,
        "messages": messages,
        "temperature": 0.7
    }

    try:
        logger.info("[Groq Chat] Envoi requête lesson_message=%s", user_message[:80])
        response = requests.post(GROQ_API_URL, json=payload, headers=headers)
        logger.info("[Groq Chat] Réponse status=%s", response.status_code)

        if response.status_code == 200:
            return response.json()["choices"][0]["message"]["content"]

        # Log détaillé en cas d'erreur (400, 401, 429, etc.)
        err_body = response.text[:800] if response.text else "vide"
        logger.warning("[Groq Chat] Erreur API status=%s body=%s", response.status_code, err_body)
        try:
            err_json = response.json()
            detail = err_json.get("error", {}).get("message", err_body) if isinstance(err_json.get("error"), dict) else err_body
        except Exception:
            detail = err_body
        return f"Erreur API ({response.status_code}) : {detail[:200]}"
    except requests.RequestException as e:
        resp = getattr(e, "response", None)
        err_body = getattr(resp, "text", None) if resp else None
        logger.exception("[Groq Chat] RequestException status=%s body=%s", getattr(resp, "status_code", None), (err_body or str(e))[:500])
        return "Désolé, problème de connexion à l'IA. Vérifie les logs du serveur Django."
    except Exception as e:
        logger.exception("[Groq Chat] Erreur inattendue: %s", e)
        return "Désolé, je suis momentanément indisponible."