"""Plugin Factory for Domain-Specific Scoring"""
import logging
from typing import Dict, Optional, List
from .base_plugin import BaseDomainPlugin

logger = logging.getLogger(__name__)


class DomainPluginFactory:
    """Factory for registering and instantiating domain plugins"""
    
    _plugins: Dict[str, type] = {}
    _instances: Dict[str, BaseDomainPlugin] = {}  # Singleton instances
    
    @classmethod
    def register(cls, domain_type: str, plugin_class: type):
        """Register a plugin class"""
        if not issubclass(plugin_class, BaseDomainPlugin):
            raise TypeError(f"{plugin_class} must inherit from BaseDomainPlugin")
        
        cls._plugins[domain_type] = plugin_class
        logger.info(f"Registered domain plugin: {domain_type}")
    
    @classmethod
    def get_plugin(cls, domain_type: str) -> Optional[BaseDomainPlugin]:
        """Get plugin instance (singleton pattern)"""
        if domain_type not in cls._plugins:
            logger.warning(f"Plugin not found: {domain_type}")
            return None
        
        # Return cached instance or create new one
        if domain_type not in cls._instances:
            cls._instances[domain_type] = cls._plugins[domain_type]()
        
        return cls._instances[domain_type]
    
    @classmethod
    def list_available_domains(cls) -> List[str]:
        """List all registered domain types"""
        return list(cls._plugins.keys())
    
    @classmethod
    def is_domain_available(cls, domain_type: str) -> bool:
        """Check if domain plugin is registered"""
        return domain_type in cls._plugins
    
    @classmethod
    def get_domain_info(cls, domain_type: str) -> Optional[Dict]:
        """Get domain plugin information"""
        plugin = cls.get_plugin(domain_type)
        if not plugin:
            return None
        
        return {
            'domain_type': plugin.domain_type,
            'required_fields': plugin.get_required_fields(),
            'optional_fields': plugin.get_optional_fields(),
            'feature_weights': plugin.feature_weights
        }
    
    @classmethod
    def clear_cache(cls):
        """Clear singleton instances (useful for testing)"""
        cls._instances.clear()


# Auto-registration helper decorator
def register_plugin(domain_type: str):
    """Decorator to auto-register plugins"""
    def decorator(plugin_class):
        DomainPluginFactory.register(domain_type, plugin_class)
        return plugin_class
    return decorator