import os
import json
from typing import Dict, List, Any, Optional
from datetime import datetime

from agents.base_agent import Agent
from core.factory import LLMFactory

class AgentAnalyseImage(Agent):
    """
    Agent pour analyser des images avec LlamaVision
    """
    def __init__(self, nom: str = "AgentAnalyseImage"):
        """
        Initialisation de l'agent d'analyse d'image
        
        Args:
            nom: Nom de l'agent
        """
        super().__init__(nom)
        self.llm = LLMFactory.create("llamavision")
        self.questions_standard = [
            "Décris en détail ce que tu vois sur cette image.",
            "Quels sont les éléments principaux visibles sur cette image?",
            "Y a-t-il du texte visible sur cette image? Si oui, peux-tu le transcrire?",
            "Quelle est l'ambiance générale de cette image?"
        ]
    
    def executer(self, image_path: str, json_data: Optional[Dict[str, Any]] = None, 
                question: Optional[str] = None) -> Dict[str, Any]:
        """
        Analyse une image avec Llama Vision
        
        Args:
            image_path: Chemin vers l'image à analyser
            json_data: Données JSON optionnelles associées à l'image
            question: Question à poser au modèle (si None, utilise les questions standard)
            
        Returns:
            Résultats de l'analyse sous forme de dictionnaire
        """
        # Vérification de l'existence de l'image
        if not os.path.exists(image_path):
            resultat = {"erreur": f"L'image {image_path} n'existe pas"}
            self.ajouter_historique("analyse_image_erreur", image_path, resultat)
            return resultat
        
        # Chargement de l'image
        with open(image_path, "rb") as image_file:
            image_data = image_file.read()
        
        # Préparation de la liste des questions à poser
        questions_a_poser = [question] if question else self.questions_standard
        
        # Exécution de l'analyse pour chaque question
        resultats = {
            "image": image_path,
            "timestamp": datetime.now().isoformat(),
            "analyses": []
        }
        
        # Traitement pour chaque question
        for q in questions_a_poser:
            try:
                # Ajout des données JSON si fournies
                if json_data:
                    q_enrichie = f"{q}\n\nContexte: {json.dumps(json_data, ensure_ascii=False)}"
                else:
                    q_enrichie = q
                
                # Appel du modèle via la factory
                reponse = self.llm.generate(q_enrichie, images=[image_data])
                
                # Ajout du résultat
                resultats["analyses"].append({
                    "question": q,
                    "reponse": reponse
                })
                
                # Ajout à l'historique
                self.ajouter_historique("analyse_image", q, reponse[:200] + "...")
            except Exception as e:
                resultats["analyses"].append({
                    "question": q,
                    "erreur": str(e)
                })
                self.ajouter_historique("analyse_image_erreur", q, str(e))
        
        return resultats
    
    def sauvegarder_resultats(self, chemin_fichier: str, resultats: Dict[str, Any]) -> bool:
        """
        Sauvegarde les résultats d'analyse dans un fichier JSON
        
        Args:
            chemin_fichier: Chemin où sauvegarder le fichier de résultats
            resultats: Dictionnaire de résultats à sauvegarder
            
        Returns:
            True si la sauvegarde a réussi, False sinon
        """
        try:
            # Création du dossier parent si nécessaire
            os.makedirs(os.path.dirname(os.path.abspath(chemin_fichier)), exist_ok=True)
            
            with open(chemin_fichier, 'w', encoding='utf-8') as f:
                json.dump(resultats, f, ensure_ascii=False, indent=2)
            
            self.ajouter_historique("sauvegarder_resultats", chemin_fichier, "Résultats sauvegardés")
            return True
        except Exception as e:
            self.ajouter_historique("sauvegarder_resultats_erreur", chemin_fichier, str(e))
            return False