from .base_llm import BaseLLM
import requests
import os

class DeepSeek(BaseLLM):
    """
    Classe pour l'intégration avec l'API DeepSeek
    Cette classe hérite de la classe de base BaseLLM
    """
    
    def __init__(self):
        """
        Initialisation des attributs spécifiques à DeepSeek
        """
        super().__init__("deepseek-chat")
        
        # Configuration initiale
        self.configurer(
            temperature=0.2,
            top_p=1,
            frequency_penalty=0,
            presence_penalty=0,
            max_tokens=4096,
            logprobs=False,
            top_logprobs=0,
            tool_choice=""
        )
    
    def urlBase(self) -> str:
        """
        Retourne l'URL de base de l'API DeepSeek
        """
        return "https://api.deepseek.com/"
    
    def cleAPI(self) -> str:
        """
        Retourne la clé API DeepSeek
        """
        return "sk-d359d9236ca84a5986f889631832d1e6"
    
    def urlFonction(self) -> str:
        """
        Retourne l'URL de la fonction par défaut pour DeepSeek
        """
        return "chat/completions"
    
    def _preparer_contenu(self, question: str) -> dict:
        """
        Prépare le contenu de la requête pour l'API DeepSeek
        
        Args:
            question: La question ou instruction à envoyer
            
        Returns:
            Dictionnaire contenant les données de la requête
        """
        payload = {
            "model": self.modele,
            "messages": [
                {"role": "system", "content": self.prompt_system},
                {"role": "user", "content": question}
            ],
            "temperature": self.params.get("temperature", 0.2),
            "top_p": self.params.get("top_p", 1),
            "frequency_penalty": self.params.get("frequency_penalty", 0),
            "presence_penalty": self.params.get("presence_penalty", 0),
            "max_tokens": self.params.get("max_tokens", 4096)
        }
        
        # Ajouter les paramètres optionnels s'ils sont définis
        if self.params.get("logprobs", False):
            payload["logprobs"] = True
            
        if self.params.get("top_logprobs", 0) > 0:
            payload["top_logprobs"] = self.params.get("top_logprobs")
            
        if self.params.get("tool_choice", ""):
            payload["tool_choice"] = self.params.get("tool_choice")
            
        return payload
    
    def _traiter_reponse(self, reponse: requests.Response) -> str:
        """
        Traite la réponse de l'API DeepSeek pour en extraire le texte généré
        
        Args:
            reponse: Objet Response de la requête HTTP
            
        Returns:
            Texte généré par le modèle
        """
        data = reponse.json()
        return data["choices"][0]["message"]["content"]
    
    def interroger_avec_image(self, image_path: str, question: str) -> str:
        """
        Ce modèle ne supporte pas directement l'analyse d'images, cette méthode est fournie
        pour la compatibilité avec l'interface BaseLLM mais utilise uniquement le texte.
        
        Args:
            image_path: Chemin vers l'image à analyser (ignoré par ce modèle)
            question: Question ou instructions pour l'analyse
            
        Returns:
            Réponse du modèle à la question, en indiquant que l'analyse d'image n'est pas supportée
        """
        image_name = os.path.basename(image_path)
        prompt = f"""[Note: Ce modèle n'a pas accès à l'image demandée: {image_name}]

Question concernant l'image: 
{question}

Veuillez noter que je ne peux pas traiter directement les images. Voici une réponse basée uniquement sur le texte de la question."""
        
        return self.interroger(prompt)