"""
Classe base abstrata para provedores de LLM
"""
from abc import ABC, abstractmethod
from typing import Dict, Any, Optional


class BaseLLM(ABC):
    """Classe abstrata para provedores de LLM"""

    def __init__(self, model_id: str, **kwargs):
        """
        Inicializa o provider LLM

        Args:
            model_id: ID do modelo
            **kwargs: Configurações adicionais
        """
        self.model_id = model_id
        self.config = kwargs
        self.last_error: str = ""

    @abstractmethod
    def generate(
        self,
        prompt: str,
        temperature: float = 0.3,
        max_tokens: int = 512,
        **kwargs
    ) -> str:
        """
        Gera resposta a partir de um prompt

        Args:
            prompt: Texto do prompt
            temperature: Temperatura de geração (0.0-2.0)
            max_tokens: Máximo de tokens na resposta
            **kwargs: Parâmetros adicionais específicos do provider

        Returns:
            Texto gerado
        """
        pass

    @abstractmethod
    def is_available(self) -> bool:
        """
        Verifica se o provider está disponível

        Returns:
            True se disponível, False caso contrário
        """
        pass

    @abstractmethod
    def get_model_info(self) -> Dict[str, Any]:
        """
        Retorna informações sobre o modelo

        Returns:
            Dicionário com informações do modelo
        """
        pass

    def validate_parameters(
        self,
        temperature: float,
        max_tokens: int
    ) -> tuple[bool, str]:
        """
        Valida parâmetros de geração

        Args:
            temperature: Temperatura de geração
            max_tokens: Máximo de tokens

        Returns:
            Tupla (válido, mensagem_erro)
        """
        if not 0.0 <= temperature <= 2.0:
            return False, "Temperature deve estar entre 0.0 e 2.0"

        if max_tokens < 1 or max_tokens > 4096:
            return False, "Max tokens deve estar entre 1 e 4096"

        return True, ""

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}(model_id='{self.model_id}')"