coursecrafter/utils/config.py

"""
⚙️ Configuration Management for CourseCrafter AI

Centralized configuration system with environment variable support and validation.
"""

import os
import json
from typing import Dict, Any, Optional, List
from dataclasses import dataclass, field
from pathlib import Path
from dotenv import load_dotenv

from ..types import LLMProvider


@dataclass
class LLMProviderConfig:
    """Configuration for a specific LLM provider"""
    api_key: str
    model: str
    temperature: float = 0.7
    max_tokens: Optional[int] = None
    timeout: int = 60
    base_url: Optional[str] = None

class Config:
    """
    Centralized configuration management for Course Creator AI

    Handles environment variables, API keys, and URL configurations.
    """

    def __init__(self):
        # Load environment variables
        load_dotenv()

        # Initialize configuration
        self._config = self._load_default_config()
        self._validate_config()

    def _load_default_config(self) -> Dict[str, Any]:
        """Load default configuration with environment variable overrides"""
        # Get default model from env or fallback
        default_model = os.getenv("DEFAULT_MODEL", "gpt-4.1-nano")
        
        # Get default LLM provider from env or fallback to first available
        default_llm_provider = os.getenv("DEFAULT_LLM_PROVIDER", "openai")

        return {
            # LLM Provider Configurations
            "llm_providers": {
                "openai": {
                    "api_key": os.getenv("OPENAI_API_KEY", ""),
                    "model": os.getenv("OPENAI_MODEL", default_model),
                    "temperature": float(os.getenv("OPENAI_TEMPERATURE", "0.7")),
                    "max_tokens": int(os.getenv("OPENAI_MAX_TOKENS", "20000")) if os.getenv("OPENAI_MAX_TOKENS") else None,
                    "timeout": int(os.getenv("OPENAI_TIMEOUT", "60"))
                },
                "anthropic": {
                    "api_key": os.getenv("ANTHROPIC_API_KEY", ""),
                    "model": os.getenv("ANTHROPIC_MODEL", "claude-3-5-sonnet-20241022"),
                    "temperature": float(os.getenv("ANTHROPIC_TEMPERATURE", "0.7")),
                    "max_tokens": int(os.getenv("ANTHROPIC_MAX_TOKENS", "20000")) if os.getenv("ANTHROPIC_MAX_TOKENS") else None,
                    "timeout": int(os.getenv("ANTHROPIC_TIMEOUT", "60"))
                },
                "google": {
                    "api_key": os.getenv("GOOGLE_API_KEY", ""),
                    "model": os.getenv("GOOGLE_MODEL", "gemini-2.0-flash"),
                    "temperature": float(os.getenv("GOOGLE_TEMPERATURE", "0.7")),
                    "max_tokens": int(os.getenv("GOOGLE_MAX_TOKENS", "20000")) if os.getenv("GOOGLE_MAX_TOKENS") else None,
                    "timeout": int(os.getenv("GOOGLE_TIMEOUT", "60"))
                },
                "openai_compatible": {
                    "api_key": os.getenv("OPENAI_COMPATIBLE_API_KEY", "dummy"),
                    "base_url": os.getenv("OPENAI_COMPATIBLE_BASE_URL", ""),
                    "model": os.getenv("OPENAI_COMPATIBLE_MODEL", ""),
                    "temperature": float(os.getenv("OPENAI_COMPATIBLE_TEMPERATURE", "0.7")),
                    "max_tokens": int(os.getenv("OPENAI_COMPATIBLE_MAX_TOKENS", "20000")) if os.getenv("OPENAI_COMPATIBLE_MAX_TOKENS") else None,
                    "timeout": int(os.getenv("OPENAI_COMPATIBLE_TIMEOUT", "60"))
                }
            },

            # Course Generation Settings
            "course_generation": {
                "default_difficulty": "beginner",
                "default_lesson_count": 5,
                "max_lesson_duration": 30,
                "include_images": True,
                "include_flashcards": True,
                "include_quizzes": True,
                "research_depth": "comprehensive"
            },

            # Image Generation Settings
            "image_generation": {
                "pollinations_api_token": os.getenv("POLLINATIONS_API_TOKEN", ""),
                "pollinations_api_reference": os.getenv("POLLINATIONS_API_REFERENCE", ""),
                "default_width": 1280,
                "default_height": 720,
                "default_model": "gptimage",
                "enhance_prompts": True,
                "no_logo": True
            },

            # Export Settings
            "export": {
                "default_formats": ["pdf", "markdown"],
                "output_directory": os.getenv("COURSECRAFTER_OUTPUT_DIR", "./output"),
                "max_file_size": 50 * 1024 * 1024,  # 50MB
                "compression": True
            },

            # UI Settings
            "ui": {
                "theme": "soft",
                "show_progress": True,
                "auto_scroll": True,
                "max_concurrent_generations": 3
            },

            # System Settings
            "system": {
                "default_llm_provider": default_llm_provider,
                "max_turns": 25,
                "timeout": 300,  # 5 minutes
                "retry_attempts": 3,
                "log_level": os.getenv("LOG_LEVEL", "INFO"),
                "debug_mode": os.getenv("DEBUG", "false").lower() == "true"
            }
        }

    def _validate_config(self):
        """Validate configuration and warn about missing required settings"""
        warnings = []

        # Check LLM provider API keys
        for provider, config in self._config["llm_providers"].items():
            if provider == "openai_compatible":
                # For openai_compatible, check for base_url instead of api_key
                if not config.get("base_url"):
                    warnings.append(f"Missing base_url for {provider}")
            else:
                # For other providers, check for api_key
                if not config["api_key"]:
                    warnings.append(f"Missing API key for {provider}")

        # Check if at least one LLM provider is configured
        has_provider = False
        for provider, config in self._config["llm_providers"].items():
            if provider == "openai_compatible":
                if config.get("base_url"):
                    has_provider = True
                    break
            else:
                if config["api_key"]:
                    has_provider = True
                    break

        if not has_provider:
            # Only warn instead of raising error - allows app to start for UI configuration
            print("⚠️ Warning: No LLM providers configured. Please configure at least one provider in the UI.")

    def get_llm_config(self, provider: LLMProvider) -> LLMProviderConfig:
        """Get configuration for a specific LLM provider"""
        # Reload config to pick up any environment variable changes
        self._config = self._load_default_config()
        
        if provider not in self._config["llm_providers"]:
            raise ValueError(f"Unknown LLM provider: {provider}")

        config = self._config["llm_providers"][provider]
        return LLMProviderConfig(**config)

    def get_available_llm_providers(self) -> List[LLMProvider]:
        """Get list of available LLM providers with API keys"""
        # Reload config to pick up any environment variable changes
        self._config = self._load_default_config()
        
        available = []
        for provider, config in self._config["llm_providers"].items():
            if provider == "openai_compatible":
                # For openai_compatible, require base_url instead of api_key
                if config.get("base_url"):
                    available.append(provider)
            else:
                # For other providers, require api_key
                if config["api_key"]:
                    available.append(provider)
        return available

    def get_default_llm_provider(self) -> LLMProvider:
        """Get the default LLM provider, falling back to first available if not configured"""
        # Reload config to pick up any environment variable changes
        self._config = self._load_default_config()
        
        default_provider = self._config["system"]["default_llm_provider"]
        available_providers = self.get_available_llm_providers()
        
        # If the default provider is available, use it
        if default_provider in available_providers:
            return default_provider
        
        # Otherwise, use the first available provider
        if available_providers:
            print(f"⚠️ Default provider '{default_provider}' not configured, using '{available_providers[0]}'")
            return available_providers[0]
        
        # If no providers are available, return a fallback instead of raising an error
        print("⚠️ Warning: No LLM providers are configured. Returning 'google' as fallback.")
        return "google"  # Return a fallback provider that can be configured later

    def get_image_generation_config(self) -> Dict[str, Any]:
        """Get image generation configuration"""
        return self._config["image_generation"]

    def get(self, key: str, default: Any = None) -> Any:
        """Get a configuration value using dot notation"""
        keys = key.split(".")
        value = self._config

        try:
            for k in keys:
                value = value[k]
            return value
        except (KeyError, TypeError):
            return default

    def set(self, key: str, value: Any):
        """Set a configuration value using dot notation"""
        keys = key.split(".")
        config = self._config

        for k in keys[:-1]:
            if k not in config:
                config[k] = {}
            config = config[k]

        config[keys[-1]] = value

    def update_llm_provider(self, provider: LLMProvider, **kwargs):
        """Update LLM provider configuration"""
        if provider not in self._config["llm_providers"]:
            raise ValueError(f"Unknown LLM provider: {provider}")

        self._config["llm_providers"][provider].update(kwargs)

    def to_dict(self) -> Dict[str, Any]:
        """Convert configuration to dictionary"""
        return self._config.copy()

    def save_to_file(self, filepath: str):
        """Save configuration to JSON file"""
        with open(filepath, 'w') as f:
            json.dump(self._config, f, indent=2)

    @classmethod
    def load_from_file(cls, filepath: str) -> 'Config':
        """Load configuration from JSON file"""
        instance = cls()

        if os.path.exists(filepath):
            with open(filepath, 'r') as f:
                file_config = json.load(f)
                instance._config.update(file_config)

        instance._validate_config()
        return instance

# Global configuration instance
config = Config()