import uuid
from typing import Dict, List, Optional
from datetime import datetime
import json

# Pour Groq Chat API (si vous utilisez Groq)
import requests
from config import GROQ_API_KEY, GROQ_CHAT_MODEL

# Stockage en mémoire (remplacez par une base de données en production)
conversation_store: Dict[str, List[Dict]] = {}

def generate_chat_response(
    user_input: str,
    conversation_id: Optional[str] = None,
    system_prompt: Optional[str] = None
) -> str:
    """
    Génère une réponse de chatbot pour une entrée utilisateur
    """
    # 1. Gérer la conversation
    if not conversation_id:
        conversation_id = str(uuid.uuid4())
        conversation_store[conversation_id] = []
    
    # 2. Ajouter le message utilisateur à l'historique
    conversation_store[conversation_id].append({
        "role": "user",
        "content": user_input,
        "timestamp": datetime.now().isoformat()
    })
    
    # 3. Préparer le prompt système
    if not system_prompt:
        system_prompt = """Tu es un assistant vocal amical et utile. 
        Tes réponses doivent être naturelles à l'oral, concises 
        (max 2-3 phrases) et adaptées à une synthèse vocale."""
    
    # 4. Préparer les messages pour l'API Groq
    messages = [{"role": "system", "content": system_prompt}]
    
    # Ajouter l'historique (limité aux derniers messages pour le contexte)
    history = conversation_store[conversation_id][-5:]  # Derniers 5 échanges
    for msg in history:
        messages.append({"role": msg["role"], "content": msg["content"]})
    
    # 5. Appeler l'API Groq Chat
    try:
        response_text = call_groq_chat_api(messages)
    except Exception as e:
        # Fallback simple
        response_text = f"Désolé, je ne peux pas répondre pour le moment. Erreur: {str(e)}"
    
    # 6. Ajouter la réponse à l'historique
    conversation_store[conversation_id].append({
        "role": "assistant",
        "content": response_text,
        "timestamp": datetime.now().isoformat()
    })
    
    return response_text

def call_groq_chat_api(messages: List[Dict]) -> str:
    """
    Appelle l'API Groq Chat
    """
    if not GROQ_API_KEY:
        raise RuntimeError("GROQ_API_KEY non configurée")
    
    url = "https://api.groq.com/openai/v1/chat/completions"
    
    headers = {
        "Authorization": f"Bearer {GROQ_API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": GROQ_CHAT_MODEL,
        "messages": messages,
        "temperature": 0.7,
        "max_tokens": 150,  # Limité pour les réponses vocales
        "top_p": 0.9,
    }
    
    response = requests.post(url, headers=headers, json=payload, timeout=30)
    response.raise_for_status()
    
    result = response.json()
    return result["choices"][0]["message"]["content"]

def get_conversation_history(conversation_id: str) -> List[Dict]:
    """
    Récupère l'historique d'une conversation
    """
    return conversation_store.get(conversation_id, [])

def clear_conversation(conversation_id: str):
    """
    Efface une conversation
    """
    if conversation_id in conversation_store:
        del conversation_store[conversation_id]