"""
Assistant IA pour Étude de marché, BMC, BP, Pitch.
Utilise l'API Groq (même clé que formations).
"""
import os
import logging
import requests

logger = logging.getLogger(__name__)

GROQ_API_URL = "https://api.groq.com/openai/v1/chat/completions"
GROQ_CHAT_MODEL = "llama-3.1-8b-instant"
MAX_CONTEXT_CHARS = 12000  # garder de la place pour la réponse

PAGE_PROMPTS = {
    "market": """Tu es l'assistant IA de la plateforme Goon, spécialisé dans l'étude de marché.
L'enquête est remplie sur le terrain ; l'utilisateur a les réponses dans l'outil. Tu l'aides à :
- analyser et résumer les réponses (tendances, âges, besoins, canaux),
- interpréter les graphiques et donner des insights,
- formuler des conclusions pour son projet.
Ne remplis pas de champs : ton rôle est l'analyse des réponses et des graphiques. Réponds en français, court et actionable.""",

    "bmc": """Tu es l'assistant IA de la plateforme Goon, spécialisé dans le Business Model Canvas (BMC).
L'utilisateur remplit les 9 blocs : Partenaires clés, Activités, Ressources, Proposition de valeur, Relation client, Canaux, Segments clients, Structure de coûts, Flux de revenus.
Tu l'aides à :
- proposer des idées ou du texte pour un bloc donné (suggestions concises),
- vérifier la cohérence entre blocs (segments ↔ proposition de valeur ↔ canaux).
Réponds en français, de façon courte. Si tu proposes du texte pour un bloc, indique clairement pour quel bloc.""",

    "bp": """Tu es l'assistant IA de la plateforme Goon, spécialisé dans le Business Plan (BP).
L'utilisateur remplit un plan d'affaire (promoteur, projet, marché, technique, finance, etc.).
Tu l'aides à :
- rédiger ou améliorer des sections (promoteur, présentation projet, étude de marché, stratégie, chiffres),
- vérifier la cohérence des chiffres (BFR, financement, recettes/dépenses).
Réponds en français, de façon courte et professionnelle.""",

    "pitch": """Tu es l'assistant IA de la plateforme Goon, spécialisé dans le Pitch Deck (présentation orale / slides).
L'utilisateur rédige un pitch en 13 diapos (Green Lands) : projet, problème, solution, marché, modèle économique, réalisations, roadmap, besoins, vision, conclusion.
Tu l'aides à :
- proposer des formulations percutantes pour une slide (accroche, problème, solution, vision 5 ans, mot de la fin),
- renforcer l'impact et la clarté du message.
Réponds en français, de façon courte et percutante.""",
}


def _truncate_context(context_str: str, max_len: int = MAX_CONTEXT_CHARS) -> str:
    if len(context_str) <= max_len:
        return context_str
    return context_str[:max_len] + "\n\n[... contenu tronqué ...]"


def get_assistant_reply(page: str, user_message: str, context: dict) -> str:
    """
    Appelle Groq avec le bon prompt selon la page (market, bmc, bp, pitch).
    context : dict avec les données de la page (réponses, blocs BMC, sections BP, slides pitch, etc.)
    """
    api_key = os.getenv("GROQ_API_KEY")
    if not api_key:
        logger.warning("[Assistant] GROQ_API_KEY manquante")
        return "Erreur : Clé API Groq manquante. Contactez l’administrateur."

    system_prompt = PAGE_PROMPTS.get(
        page,
        "Tu es l'assistant IA de la plateforme Goon. Tu aides l'utilisateur sur son projet entrepreneurial. Réponds en français, de façon courte."
    )

    # Construire le bloc contexte à partir du dict (résumé texte)
    context_parts = []
    if context:
        for key, value in context.items():
            if value is None or value == "":
                continue
            if isinstance(value, (list, dict)):
                import json
                try:
                    value = json.dumps(value, ensure_ascii=False)[:2000]
                except Exception:
                    value = str(value)[:2000]
            else:
                value = str(value).strip()[:2000]
            if value:
                context_parts.append(f"{key}:\n{value}")
    context_text = "\n\n---\n\n".join(context_parts) if context_parts else "Aucune donnée fournie pour l’instant."
    context_text = _truncate_context(context_text)

    system_prompt += f"""

DONNÉES ACTUELLES DE L'UTILISATEUR (sur cette page) :
---
{context_text}
---

Réponds uniquement à la question ou demande de l'utilisateur en t'appuyant sur ces données si pertinent. Sois concis (2-4 phrases si suffisant)."""

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json",
    }
    payload = {
        "model": GROQ_CHAT_MODEL,
        "messages": [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_message.strip()},
        ],
        "temperature": 0.6,
    }

    try:
        logger.info("[Assistant] page=%s message=%s", page, user_message[:60])
        response = requests.post(GROQ_API_URL, json=payload, headers=headers, timeout=30)
        logger.info("[Assistant] status=%s", response.status_code)

        if response.status_code == 200:
            result = response.json()
            content = (result.get("choices") or [{}])[0].get("message", {}).get("content") or ""
            return content.strip()

        err_body = (response.text or "")[:500]
        logger.warning("[Assistant] API error %s %s", response.status_code, err_body)
        return f"Désolé, l’IA est temporairement indisponible (erreur {response.status_code}). Réessaie dans un instant."

    except requests.RequestException as e:
        logger.exception("[Assistant] RequestException: %s", e)
        return "Désolé, problème de connexion à l’IA. Réessaie plus tard."
    except Exception as e:
        logger.exception("[Assistant] Erreur: %s", e)
        return "Désolé, une erreur inattendue s’est produite."


def suggest_document_template(page: str, context: dict) -> str:
    """
    Suggère un template PDF (classic | modern | minimal) selon le contexte du projet.
    page: "bmc" | "pitch"
    context: dict avec les données (blocs BMC, slides pitch, etc.)
    Retourne "classic", "modern" ou "minimal".
    """
    api_key = os.getenv("GROQ_API_KEY")
    if not api_key:
        logger.warning("[SuggestTemplate] GROQ_API_KEY manquante")
        return "classic"

    context_parts = []
    if context:
        for key, value in context.items():
            if value is None or value == "":
                continue
            if isinstance(value, (list, dict)):
                import json
                try:
                    value = json.dumps(value, ensure_ascii=False)[:1500]
                except Exception:
                    value = str(value)[:1500]
            else:
                value = str(value).strip()[:1500]
            if value:
                context_parts.append(f"{key}: {value}")
    context_text = "\n".join(context_parts) if context_parts else "Projet en cours de remplissage."

    system = f"""Tu es un expert en design de documents professionnels. Pour un document "{page}" (Business Model Canvas ou Pitch Deck), tu dois choisir le style PDF le plus adapté au projet décrit ci-dessous.

Styles disponibles:
- classic: emerald, chaleureux, standard (recommandé par défaut).
- modern: vert foncé, plus affirmé, pour projets tech/innovation.
- minimal: gris, épuré, pour projets sobres ou institutionnels.

Contexte du projet:
{context_text}

Réponds UNIQUEMENT par un seul mot: classic, modern ou minimal. Aucune autre réponse."""

    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
    payload = {
        "model": GROQ_CHAT_MODEL,
        "messages": [
            {"role": "system", "content": system},
            {"role": "user", "content": "Quel style PDF recommandes-tu pour ce document ? Un seul mot."},
        ],
        "temperature": 0.3,
    }

    try:
        response = requests.post(GROQ_API_URL, json=payload, headers=headers, timeout=15)
        if response.status_code == 200:
            result = response.json()
            content = (result.get("choices") or [{}])[0].get("message", {}).get("content") or ""
            content_lower = content.strip().lower()
            for choice in ("modern", "minimal", "classic"):
                if choice in content_lower.split():
                    return choice
            if content_lower.split():
                first = content_lower.split()[0]
                if first in ("classic", "modern", "minimal"):
                    return first
        return "classic"
    except Exception as e:
        logger.warning("[SuggestTemplate] %s", e)
        return "classic"
