"""
服务容器模块 - 提供线程安全的服务实例管理
"""
import threading
from typing import Dict, Type, TypeVar, Optional
import logging

logger = logging.getLogger(__name__)

T = TypeVar('T')

class ServiceContainer:
    """线程安全的服务容器，实现依赖注入和单例管理"""
    
    def __init__(self):
        self._services: Dict[Type, object] = {}
        self._factories: Dict[Type, callable] = {}
        self._lock = threading.RLock()
        
    def register_singleton(self, service_type: Type[T], factory: callable) -> None:
        """注册单例服务工厂"""
        with self._lock:
            self._factories[service_type] = factory
            logger.debug(f"Registered singleton factory for {service_type.__name__}")
            
    def get_service(self, service_type: Type[T]) -> T:
        """获取服务实例（懒加载单例）"""
        with self._lock:
            # 检查是否已存在实例
            if service_type in self._services:
                return self._services[service_type]
                
            # 检查是否有工厂方法
            if service_type not in self._factories:
                raise ValueError(f"No factory registered for service type: {service_type}")
                
            # 创建新实例
            factory = self._factories[service_type]
            try:
                instance = factory()
                self._services[service_type] = instance
                logger.debug(f"Created new instance of {service_type.__name__}")
                return instance
            except Exception as e:
                logger.error(f"Failed to create instance of {service_type.__name__}: {e}")
                raise
                
    def has_service(self, service_type: Type[T]) -> bool:
        """检查是否有服务注册"""
        with self._lock:
            return service_type in self._factories
            
    def clear_cache(self, service_type: Optional[Type[T]] = None) -> None:
        """清理服务缓存"""
        with self._lock:
            if service_type:
                self._services.pop(service_type, None)
                logger.debug(f"Cleared cache for {service_type.__name__}")
            else:
                self._services.clear()
                logger.debug("Cleared all service cache")

# 全局服务容器实例
_container: Optional[ServiceContainer] = None
_container_lock = threading.Lock()

def get_container() -> ServiceContainer:
    """获取全局服务容器实例"""
    global _container
    if _container is None:
        with _container_lock:
            if _container is None:
                _container = ServiceContainer()
    return _container

def register_default_services():
    """注册默认的服务实现"""
    from .render_service import DefaultRenderService, RenderService
    from .template_service import DefaultTemplateService, TemplateService
    from .task_service import DefaultTaskService, TaskService
    
    container = get_container()
    
    # 注册渲染服务
    container.register_singleton(RenderService, lambda: DefaultRenderService())
    
    # 注册模板服务
    def create_template_service():
        service = DefaultTemplateService()
        service.load_local_templates()
        return service
    container.register_singleton(TemplateService, create_template_service)
    
    # 注册任务服务（依赖其他服务）
    def create_task_service():
        render_service = container.get_service(RenderService)
        template_service = container.get_service(TemplateService)
        return DefaultTaskService(render_service, template_service)
    container.register_singleton(TaskService, create_task_service)
    
    logger.info("Default services registered successfully")

# 便捷函数
def get_render_service() -> 'RenderService':
    """获取渲染服务实例"""
    from .render_service import RenderService
    return get_container().get_service(RenderService)

def get_template_service() -> 'TemplateService':
    """获取模板服务实例"""
    from .template_service import TemplateService
    return get_container().get_service(TemplateService)

def get_task_service() -> 'TaskService':
    """获取任务服务实例"""
    from .task_service import TaskService
    return get_container().get_service(TaskService)