from .base_agent import BaseAgent
from typing import Dict, Any
import logging
import json

logger = logging.getLogger("AgentJSONAnalyser")

class AgentJsonAnalyser(BaseAgent):
    """
    Agent pour analyser les tickets JSON et en extraire les informations importantes.
    """
    def __init__(self, llm):
        super().__init__("AgentJsonAnalyser", llm)
        
        # Configuration locale de l'agent (remplace AgentConfig)
        self.temperature = 0.1  # Besoin d'analyse très précise
        self.top_p = 0.8
        self.max_tokens = 1500
        self.system_prompt = """Tu es un expert en analyse de tickets pour le support informatique de BRG_Lab.
Ton rôle est d'extraire et d'analyser les informations importantes des tickets JSON.
Organise ta réponse avec les sections suivantes:
1. Résumé du problème
2. Informations techniques essentielles (logiciels, versions, etc.)
3. Contexte client (urgence, impact)
4. Pistes d'analyse suggérées

Sois précis, factuel et synthétique dans ton analyse."""
        
        # Appliquer la configuration au LLM
        self._appliquer_config_locale()
        
        logger.info("AgentJsonAnalyser initialisé")
    
    def _appliquer_config_locale(self) -> None:
        """
        Applique la configuration locale au modèle LLM.
        """
        # Appliquer le prompt système
        if hasattr(self.llm, "prompt_system"):
            self.llm.prompt_system = self.system_prompt
        
        # Appliquer les paramètres
        if hasattr(self.llm, "configurer"):
            params = {
                "temperature": self.temperature,
                "top_p": self.top_p,
                "max_tokens": self.max_tokens
            }
            
            # Ajustements selon le type de modèle
            if "mistral_medium" in self.llm.__class__.__name__.lower():
                params["temperature"] += 0.05
                params["max_tokens"] = 1000
            elif "pixtral" in self.llm.__class__.__name__.lower():
                params["temperature"] -= 0.05
            elif "ollama" in self.llm.__class__.__name__.lower():
                params["temperature"] += 0.1
                params.update({
                    "num_ctx": 2048,
                    "repeat_penalty": 1.1,
                })
            
            self.llm.configurer(**params)
    
    def executer(self, ticket_data: Dict) -> str:
        """
        Analyse un ticket JSON pour en extraire les informations pertinentes
        
        Args:
            ticket_data: Dictionnaire contenant les données du ticket à analyser
            
        Returns:
            Réponse formatée contenant l'analyse du ticket
        """
        logger.info(f"Analyse du ticket: {ticket_data.get('code', 'Inconnu')}")
        print(f"AgentJsonAnalyser: Analyse du ticket {ticket_data.get('code', 'Inconnu')}")
        
        # Préparer le ticket pour l'analyse
        ticket_formate = self._formater_ticket_pour_analyse(ticket_data)
        
        # Créer le prompt pour l'analyse
        prompt = f"""Analyse ce ticket de support technique et fournis une synthèse structurée:

{ticket_formate}

Réponds de manière factuelle, en te basant uniquement sur les informations fournies."""
        
        try:
            logger.info("Interrogation du LLM")
            response = self.llm.interroger(prompt)
            logger.info(f"Réponse reçue: {len(response)} caractères")
            print(f"  Analyse terminée: {len(response)} caractères")
        except Exception as e:
            error_message = f"Erreur lors de l'analyse du ticket: {str(e)}"
            logger.error(error_message)
            response = f"ERREUR: {error_message}"
            print(f"  ERREUR: {error_message}")
        
        # Enregistrer l'historique avec le prompt complet pour la traçabilité
        self.ajouter_historique("analyse_ticket", 
                               {
                                   "ticket_id": ticket_data.get("code", "Inconnu"),
                                   "prompt": prompt,
                                   "temperature": self.temperature,
                                   "top_p": self.top_p,
                                   "max_tokens": self.max_tokens,
                                   "timestamp": self._get_timestamp()
                               }, 
                               response)
        
        return response
    
    def _formater_ticket_pour_analyse(self, ticket_data: Dict) -> str:
        """
        Formate les données du ticket pour l'analyse LLM
        
        Args:
            ticket_data: Les données du ticket
            
        Returns:
            Représentation textuelle formatée du ticket
        """
        # Initialiser avec les informations de base
        info = f"## TICKET {ticket_data.get('code', 'Inconnu')}: {ticket_data.get('name', 'Sans titre')}\n\n"
        
        # Ajouter la description
        description = ticket_data.get('description', '')
        if description:
            info += f"## DESCRIPTION\n{description}\n\n"
        
        # Ajouter les informations du ticket
        info += "## INFORMATIONS DU TICKET\n"
        for key, value in ticket_data.items():
            if key not in ['code', 'name', 'description', 'messages', 'metadata'] and value:
                info += f"- {key}: {value}\n"
        info += "\n"
        
        # Ajouter les messages (conversations)
        messages = ticket_data.get('messages', [])
        if messages:
            info += "## ÉCHANGES ET MESSAGES\n"
            for i, msg in enumerate(messages):
                sender = msg.get('from', 'Inconnu')
                date = msg.get('date', 'Date inconnue')
                content = msg.get('content', '')
                info += f"### Message {i+1} - De: {sender} - Date: {date}\n{content}\n\n"
        
        # Ajouter les métadonnées techniques si présentes
        metadata = ticket_data.get('metadata', {})
        if metadata:
            info += "## MÉTADONNÉES TECHNIQUES\n"
            info += json.dumps(metadata, indent=2, ensure_ascii=False)
            info += "\n"
        
        return info
    
    def _get_timestamp(self) -> str:
        """Retourne un timestamp au format YYYYMMDD_HHMMSS"""
        from datetime import datetime
        return datetime.now().strftime("%Y%m%d_%H%M%S")