#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Template Manager
模板管理器 - 负责管理和加载海报模板
"""

import logging
from typing import Dict, Any, List, Optional, Type
from pathlib import Path

from ..config import PosterGenerationConfig, ResourceConfig
from ..exceptions import ResourceNotFoundError, PosterGenerationError
from .templates import BaseTemplate, VibrantTemplate, BusinessTemplate, CollageTemplate

logger = logging.getLogger(__name__)


class TemplateManager:
    """
    模板管理器
    负责注册、管理和提供海报模板
    """

    def __init__(self, poster_config: PosterGenerationConfig, resource_config: ResourceConfig):
        """
        初始化模板管理器

        Args:
            poster_config: 海报生成配置
            resource_config: 资源配置
        """
        self.poster_config = poster_config
        self.resource_config = resource_config
        
        # 注册内置模板
        self.templates: Dict[str, Type[BaseTemplate]] = {
            "vibrant": VibrantTemplate,
            "business": BusinessTemplate,
            "collage": CollageTemplate
        }
        
        # 模板实例缓存
        self._template_cache: Dict[str, BaseTemplate] = {}
        
        logger.info(f"模板管理器初始化完成，注册模板: {list(self.templates.keys())}")

    def get_template(self, template_name: str) -> BaseTemplate:
        """
        获取模板实例

        Args:
            template_name: 模板名称

        Returns:
            模板实例

        Raises:
            ResourceNotFoundError: 模板不存在时抛出
        """
        if template_name not in self.templates:
            available_templates = list(self.templates.keys())
            raise ResourceNotFoundError(
                f"模板 '{template_name}' 不存在。可用模板: {available_templates}"
            )
        
        # 检查缓存
        if template_name in self._template_cache:
            return self._template_cache[template_name]
        
        try:
            # 创建模板实例
            template_class = self.templates[template_name]
            
            # 获取模板配置
            template_config = self._get_template_config(template_name)
            
            # 实例化模板
            template_instance = template_class(
                size=self.poster_config.default_size,
                config=template_config
            )
            
            # 缓存实例
            self._template_cache[template_name] = template_instance
            
            logger.debug(f"模板 '{template_name}' 创建成功")
            return template_instance
            
        except Exception as e:
            raise PosterGenerationError(f"创建模板 '{template_name}' 失败: {str(e)}")

    def _get_template_config(self, template_name: str) -> Dict[str, Any]:
        """获取模板特定的配置"""
        
        # 基础配置
        base_config = {
            "size": self.poster_config.default_size,
            "color_themes": self.poster_config.color_themes,
            "font_configs": self.poster_config.font_configs,
            "text_effects": self.poster_config.text_effects
        }
        
        # 模板特定配置
        if template_name == "vibrant":
            base_config.update({
                "glass_effect": self.poster_config.glass_effect,
                "default_theme": self.poster_config.default_color_theme
            })
        elif template_name == "business":
            base_config.update({
                "professional_colors": True,
                "layout_style": "symmetrical"
            })
        elif template_name == "collage":
            base_config.update({
                "grid_style": "dynamic",
                "max_images": 6
            })
        
        # 添加资源路径
        base_config["font_directory"] = self._get_font_directory()
        base_config["assets_directory"] = self._get_assets_directory()
        
        return base_config

    def _get_font_directory(self) -> Optional[str]:
        """获取字体目录路径"""
        font_dir = self.resource_config.find_resource_directory("fonts")
        return str(font_dir) if font_dir else None

    def _get_assets_directory(self) -> Optional[str]:
        """获取资源目录路径"""
        assets_dir = self.resource_config.find_resource_directory("images")
        return str(assets_dir) if assets_dir else None

    def register_template(self, name: str, template_class: Type[BaseTemplate]) -> None:
        """
        注册新模板

        Args:
            name: 模板名称
            template_class: 模板类
        """
        if not issubclass(template_class, BaseTemplate):
            raise ValueError(f"模板类必须继承自 BaseTemplate")
        
        self.templates[name] = template_class
        
        # 清除缓存中的旧实例（如果存在）
        if name in self._template_cache:
            del self._template_cache[name]
        
        logger.info(f"模板 '{name}' 注册成功")

    def unregister_template(self, name: str) -> None:
        """
        注销模板

        Args:
            name: 模板名称
        """
        if name in self.templates:
            del self.templates[name]
        
        if name in self._template_cache:
            del self._template_cache[name]
        
        logger.info(f"模板 '{name}' 已注销")

    def get_available_templates(self) -> List[str]:
        """
        获取可用模板列表

        Returns:
            模板名称列表
        """
        return list(self.templates.keys())

    def get_template_info(self, template_name: str) -> Dict[str, Any]:
        """
        获取模板信息

        Args:
            template_name: 模板名称

        Returns:
            模板信息字典
        """
        if template_name not in self.templates:
            raise ResourceNotFoundError(f"模板 '{template_name}' 不存在")
        
        template_class = self.templates[template_name]
        
        return {
            "name": template_name,
            "class_name": template_class.__name__,
            "description": getattr(template_class, "__doc__", "无描述"),
            "supported_features": getattr(template_class, "SUPPORTED_FEATURES", []),
            "default_size": self.poster_config.default_size,
            "is_cached": template_name in self._template_cache
        }

    def get_all_templates_info(self) -> Dict[str, Dict[str, Any]]:
        """
        获取所有模板的信息

        Returns:
            模板信息字典
        """
        return {name: self.get_template_info(name) for name in self.templates.keys()}

    def validate_template_config(self, template_name: str) -> Dict[str, Any]:
        """
        验证模板配置

        Args:
            template_name: 模板名称

        Returns:
            验证结果
        """
        validation_result = {
            "template_name": template_name,
            "exists": template_name in self.templates,
            "config_valid": True,
            "missing_resources": [],
            "warnings": []
        }
        
        if not validation_result["exists"]:
            validation_result["config_valid"] = False
            return validation_result
        
        try:
            # 检查字体资源
            font_dir = self._get_font_directory()
            if not font_dir or not Path(font_dir).exists():
                validation_result["missing_resources"].append("font_directory")
                validation_result["warnings"].append("字体目录不存在，可能影响文本渲染")
            
            # 检查模板特定资源
            if template_name == "vibrant":
                # 检查毛玻璃效果配置
                if not self.poster_config.glass_effect:
                    validation_result["warnings"].append("缺少毛玻璃效果配置")
            
            # 尝试创建模板实例
            try:
                template = self.get_template(template_name)
                validation_result["instance_created"] = True
            except Exception as e:
                validation_result["config_valid"] = False
                validation_result["warnings"].append(f"模板实例创建失败: {str(e)}")
                
        except Exception as e:
            validation_result["config_valid"] = False
            validation_result["warnings"].append(f"配置验证失败: {str(e)}")
        
        return validation_result

    def clear_cache(self) -> None:
        """清除模板实例缓存"""
        self._template_cache.clear()
        logger.info("模板缓存已清除")

    def get_cache_info(self) -> Dict[str, Any]:
        """获取缓存信息"""
        return {
            "cached_templates": list(self._template_cache.keys()),
            "cache_size": len(self._template_cache),
            "total_templates": len(self.templates)
        }

    def reload_template(self, template_name: str) -> None:
        """
        重新加载模板

        Args:
            template_name: 模板名称
        """
        if template_name in self._template_cache:
            del self._template_cache[template_name]
            logger.info(f"模板 '{template_name}' 已重新加载")

    def get_manager_info(self) -> Dict[str, Any]:
        """获取管理器信息"""
        return {
            "available_templates": self.get_available_templates(),
            "cache_info": self.get_cache_info(),
            "poster_config": {
                "default_size": self.poster_config.default_size,
                "available_themes": list(self.poster_config.color_themes.keys()),
                "font_configs": list(self.poster_config.font_configs.keys())
            },
            "resource_paths": {
                "font_directory": self._get_font_directory(),
                "assets_directory": self._get_assets_directory()
            }
        } 