from enum import Enum
from typing import Optional

from logger import Logger


class LLMInterface(Enum):
    OPENAI = "OpenAI"
    HUGGINGFACE = "HuggingFace"
    # Add your own if you like (then adjust the LLMFactory)


class AgentPreset:
    def __init__(self, interface: LLMInterface, model_name: str, temperature: Optional[float] = None, 
                 max_tokens: Optional[int] = None, repeat_penalty: Optional[float] = None):
        """
        Initialize an AgentPreset with LLM configuration parameters.
        
        Args:
            interface: The model interface to use (e.g., OPENAI, HUGGINGFACE)
            model_name: Name of the model to use
            temperature: Controls randomness in responses (0.0-1.0)
            max_tokens: Maximum number of tokens to generate in response
            repeat_penalty: Penalty for token repetition
        """
        self.interface = interface
        self.model_name = model_name
        self.temperature = temperature
        self.max_tokens = max_tokens
        self.repeat_penalty = repeat_penalty
    
    def get_interface(self) -> LLMInterface:
        """
        Get the model interface.
        
        Returns:
            LLMInterface: The interface used for this agent.
        """
        return self.interface
    
    def get_model_name(self) -> str:
        """
        Get the model name.
        
        Returns:
            str: The name of the model.
        """
        return self.model_name
    
    def get_temperature(self) -> float | None:
        """
        Get the temperature setting.
        
        Returns:
            float: The temperature value controlling randomness.
        """
        return self.temperature
    
    def get_max_tokens(self) -> int | None:
        """
        Get the maximum tokens setting.
        
        Returns:
            int: The maximum number of tokens for generation.
        """
        return self.max_tokens
    
    def get_repeat_penalty(self) -> float | None:
        """
        Get the repeat penalty setting.
        
        Returns:
            float: The penalty value for token repetition.
        """
        return self.repeat_penalty


class Args:
    LOGGER = Logger.set_logger()
    primary_llm_interface=LLMInterface.OPENAI
    # secondary_llm_interface=LLMInterface.HUGGINGFACE
    vlm_interface=LLMInterface.OPENAI
    primary_model="qwen2.5-qwq-35b-eureka-cubed-abliterated-uncensored"
    secondary_model="qwen2.5-7b-instruct-1m"
    vision_model="qwen/qwen2.5-vl-7b"
    api_base="http://127.0.0.1:1234/v1"  # LM Studio local endpoint
    api_key=None
    token = ""  # Not needed when using OpenAILike API
    # Agent presets
    PRIMARY_AGENT_PRESET = AgentPreset(
        primary_llm_interface, primary_model,
        temperature = None, max_tokens = 2048, repeat_penalty = None
        )
    SECONDARY_AGENT_PRESET = AgentPreset(
        primary_llm_interface, secondary_model,
        temperature = None, max_tokens = 2048, repeat_penalty = None
        )
    VISION_AGENT_PRESET = AgentPreset(
        vlm_interface, vision_model,
        temperature = None, max_tokens = 2048, repeat_penalty = None
        )
    class AlfredParams:
        # Maximum number of interactions between Manager and Solver
        MAX_INTERACTIONS = 6
        # Maximum number of interactions between Solver and it's assistants
        MAX_SOLVING_EFFORT = 6
        # Verification happening every few messages to see whether the manager agent got stuck
        AUDIT_INTERVAL = 3