"""
Framework loader for dynamic loading of ethical frameworks from configuration.
"""
from dataclasses import dataclass, field
from typing import List, Dict, Any, Optional
import yaml
from pathlib import Path
import logging

logger = logging.getLogger(__name__)

@dataclass
class EthicalFramework:
    """Represents an ethical framework with its configuration."""
    name: str
    description: str
    key_principles: List[str]
    weight: float = 1.0
    category: str = ""
    enabled: bool = True
    metadata: Dict[str, Any] = field(default_factory=dict)
    
    def to_dict(self) -> Dict[str, Any]:
        """Convert framework to dictionary for serialization."""
        return {
            "name": self.name,
            "description": self.description,
            "key_principles": self.key_principles,
            "weight": self.weight,
            "category": self.category,
            "enabled": self.enabled,
            "metadata": self.metadata
        }

class FrameworkLoader:
    """Loads and manages ethical frameworks from configuration."""
    
    def __init__(self, config_path: str = "config/frameworks.yaml"):
        """Initialize the framework loader.
        
        Args:
            config_path: Path to the frameworks configuration YAML file
        """
        self.config_path = Path(config_path)
        self.frameworks: Dict[str, EthicalFramework] = {}
        self.settings: Dict[str, Any] = {}
        self._load_frameworks()
    
    def _load_frameworks(self) -> None:
        """Load frameworks from the configuration file."""
        try:
            with open(self.config_path, 'r') as f:
                config = yaml.safe_load(f)
                
            # Load settings
            self.settings = config.get('settings', {})
            
            # Load frameworks
            for fw_config in config.get('frameworks', []):
                try:
                    framework = EthicalFramework(**fw_config)
                    self.frameworks[framework.name] = framework
                    logger.info(f"Loaded framework: {framework.name}")
                except Exception as e:
                    logger.error(f"Failed to load framework {fw_config.get('name', 'unknown')}: {e}")
            
            logger.info(f"Successfully loaded {len(self.frameworks)} frameworks")
            
        except FileNotFoundError:
            logger.error(f"Framework configuration file not found: {self.config_path}")
            raise
        except yaml.YAMLError as e:
            logger.error(f"Error parsing YAML configuration: {e}")
            raise
    
    def get_framework(self, name: str) -> Optional[EthicalFramework]:
        """Get a framework by name."""
        return self.frameworks.get(name)
    
    def get_active_frameworks(self) -> List[EthicalFramework]:
        """Get all enabled frameworks."""
        return [fw for fw in self.frameworks.values() if fw.enabled]
    
    def get_default_frameworks(self) -> List[EthicalFramework]:
        """Get frameworks marked as default in settings."""
        default_names = self.settings.get('default_frameworks', [])
        return [fw for name, fw in self.frameworks.items() 
                if name in default_names and fw.enabled]
    
    def reload(self) -> None:
        """Reload frameworks from the configuration file."""
        self.frameworks = {}
        self._load_frameworks()

# Global instance for easy import
framework_loader = FrameworkLoader()