"""
AI Configuration Utilities

Provides functions for retrieving AI provider and model configurations
for different divination types.
"""

from django.conf import settings


def get_ai_config(divination_type):
    """
    Get AI provider and model configuration for a specific divination type.
    
    Args:
        divination_type (str): The divination type ('bazi', 'number', 'liuyao')
    
    Returns:
        dict: Configuration containing 'provider' and 'model' keys
    """
    try:
        # Import here to avoid circular imports
        from ai.models import AIProviderConfig
        return AIProviderConfig.get_config(divination_type)
    except Exception:
        # Fallback to settings if model is not available (e.g., during migrations)
        return get_fallback_config()


def get_fallback_config():
    """
    Get fallback configuration from Django settings.
    
    Returns:
        dict: Configuration containing 'provider' and 'model' keys
    """
    provider = getattr(settings, 'DEFAULT_LLM_PROVIDER', 'groq')
    
    if provider == 'groq':
        model = getattr(settings, 'GROQ_MODEL', 'llama-3.3-70b-versatile')
    else:
        model = getattr(settings, 'OPENAI_MODEL', 'gpt-4o')
    
    return {
        'provider': provider,
        'model': model
    }


def get_available_providers():
    """
    Get list of available AI providers.
    
    Returns:
        list: List of tuples (provider_code, provider_name)
    """
    try:
        from ai.models import AIProviderConfig
        return AIProviderConfig.PROVIDER_CHOICES
    except Exception:
        return [
            ('groq', 'Groq'),
            ('openai', 'OpenAI'),
        ]


def get_available_models(provider):
    """
    Get available models for a specific provider.
    
    Args:
        provider (str): The provider code ('groq' or 'openai')
    
    Returns:
        list: List of tuples (model_code, model_name)
    """
    try:
        from ai.models import AIProviderConfig
        return AIProviderConfig.get_available_models(provider)
    except Exception:
        # Fallback model choices
        if provider == 'groq':
            return [
                ('llama-3.3-70b-versatile', 'Llama 3.3 70B (Best quality & context - 128k)'),
                ('meta-llama/llama-4-maverick-17b-128e-instruct', 'Llama 4 Maverick 17B (Good balance - 128k)'),
                ('llama-3.1-8b-instant', 'Llama 3.1 8B (Faster - 128k)'),
            ]
        elif provider == 'openai':
            return [
                ('gpt-4o', 'GPT-4o (Latest version, best quality)'),
                ('gpt-4-turbo', 'GPT-4 Turbo (Fast with good quality)'),
                ('gpt-3.5-turbo', 'GPT-3.5 Turbo (Fastest, good for simpler tasks)'),
                ('gpt-4', 'GPT-4 (Original GPT-4)'),
                ('gpt-4.1', 'GPT-4.1'),
                ('gpt-5', 'GPT-5'),
            ]
        return []


def is_valid_provider_model_combination(provider, model):
    """
    Check if a provider and model combination is valid.
    
    Args:
        provider (str): The provider code
        model (str): The model code
    
    Returns:
        bool: True if the combination is valid, False otherwise
    """
    available_models = get_available_models(provider)
    valid_model_codes = [model_code for model_code, _ in available_models]
    return model in valid_model_codes