"""
Platform Factory
Factory class for creating platform-specific implementations.
"""
from enum import Enum
from typing import Type, Dict, Any, Optional
import logging


class Platform(Enum):
    """支持的平台枚举"""
    ANDROID = "android"
    IOS = "ios"
    WINDOWS = "windows"
    WEB = "web"
    # 未来可扩展
    # MACOS = "macos"
    # LINUX = "linux"


class PlatformFactory:
    """
    平台工厂类
    
    用于注册和创建平台特定的实现。
    """
    
    _logger = logging.getLogger("PlatformFactory")
    
    # 注册的平台实现
    _device_classes: Dict[Platform, Type] = {}
    _state_classes: Dict[Platform, Type] = {}
    _event_classes: Dict[Platform, Dict[str, Type]] = {}
    
    @classmethod
    def register_device(cls, platform: Platform, device_class: Type) -> None:
        """
        注册设备类
        
        :param platform: 平台类型
        :param device_class: 设备类
        """
        cls._device_classes[platform] = device_class
        cls._logger.info(f"Registered device class for {platform.value}: {device_class.__name__}")
    
    @classmethod
    def register_state(cls, platform: Platform, state_class: Type) -> None:
        """
        注册状态类
        
        :param platform: 平台类型
        :param state_class: 状态类
        """
        cls._state_classes[platform] = state_class
        cls._logger.info(f"Registered state class for {platform.value}: {state_class.__name__}")
    
    @classmethod
    def register_events(cls, platform: Platform, event_classes: Dict[str, Type]) -> None:
        """
        注册事件类
        
        :param platform: 平台类型
        :param event_classes: 事件类字典 {事件类型名: 事件类}
        """
        cls._event_classes[platform] = event_classes
        cls._logger.info(f"Registered {len(event_classes)} event classes for {platform.value}")
    
    @classmethod
    def register_platform(cls, platform: Platform,
                         device_class: Type,
                         state_class: Type,
                         event_classes: Dict[str, Type]) -> None:
        """
        一次性注册平台所有类
        
        :param platform: 平台类型
        :param device_class: 设备类
        :param state_class: 状态类
        :param event_classes: 事件类字典
        """
        cls.register_device(platform, device_class)
        cls.register_state(platform, state_class)
        cls.register_events(platform, event_classes)
    
    # ==================== 工厂方法 ====================
    
    @classmethod
    def _to_platform(cls, platform_input: Any) -> Platform:
        """Helper to convert string or Enum to Platform Enum"""
        if isinstance(platform_input, Platform):
            return platform_input
        try:
            return Platform(platform_input)
        except ValueError:
            raise ValueError(f"Invalid platform: {platform_input}. Available: {[p.value for p in cls._device_classes.keys()]}")

    @classmethod
    def create_device(cls, platform: Any, **kwargs) -> 'AbstractDevice':
        """
        创建设备实例
        
        :param platform: 平台类型 (Enum 或 str)
        :param kwargs: 设备初始化参数
        :return: 设备实例
        :raises ValueError: 如果平台未注册
        """
        platform_enum = cls._to_platform(platform)
        if platform_enum not in cls._device_classes:
            available = [p.value for p in cls._device_classes.keys()]
            raise ValueError(
                f"Platform '{platform_enum.value}' is not registered. "
                f"Available platforms: {available}"
            )
        return cls._device_classes[platform_enum](**kwargs)
    
    @classmethod
    def get_event_class(cls, platform: Any, event_type: str) -> Type:
        """
        获取事件类
        
        :param platform: 平台类型 (Enum 或 str)
        :param event_type: 事件类型名
        :return: 事件类
        """
        platform_enum = cls._to_platform(platform)
        if platform_enum not in cls._event_classes:
            raise ValueError(f"No event classes registered for platform: {platform_enum.value}")
        if event_type not in cls._event_classes[platform_enum]:
            raise ValueError(f"Event type '{event_type}' not found for platform: {platform_enum.value}")
        return cls._event_classes[platform_enum][event_type]