from typing import Dict, Optional, List
import re
import logging

from models.base import LLMProvider
from core.templates import TemplateManager, ContentType

logger = logging.getLogger(__name__)


class ContentGenerator:
    """内容生成引擎

    核心功能：
    - 基于模板生成内容
    - 批量生成多个版本
    - 内容优化和改写
    """

    def __init__(self, llm_provider: LLMProvider):
        self.llm = llm_provider
        self.template_manager = TemplateManager()

    def generate(
        self,
        content_type: str,
        params: Dict,
        style: str = "轻松活泼",
        **llm_kwargs
    ) -> Dict:
        """生成内容

        Args:
            content_type: 内容类型 (product_review, lifestyle, ootd 等)
            params: 模板参数字典
            style: 写作风格
            **llm_kwargs: LLM 额外参数

        Returns:
            包含 title, content, tags, word_count 的字典
        """
        try:
            # 获取并渲染模板
            system_prompt, user_prompt = self.template_manager.render_prompt(
                content_type,
                style=style,
                **params
            )

            # 构建消息
            messages = [
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_prompt}
            ]

            # 生成内容
            content = self.llm.generate(messages, **llm_kwargs)

            # 提取标题
            title = self._extract_title(content)

            # 提取标签
            tags = self._extract_tags(content)

            # 添加默认标签
            default_tags = self.template_manager.get_default_tags(content_type)
            all_tags = list(set(tags + default_tags))

            return {
                "title": title,
                "content": content,
                "tags": all_tags,
                "content_type": content_type,
                "word_count": len(content),
                "char_count": len(content.replace(" ", ""))
            }

        except Exception as e:
            logger.error(f"Content generation failed: {e}")
            raise

    def generate_batch(
        self,
        content_type: str,
        params: Dict,
        count: int = 3,
        **kwargs
    ) -> List[Dict]:
        """批量生成多个版本

        Args:
            content_type: 内容类型
            params: 模板参数
            count: 生成数量
            **kwargs: 额外参数

        Returns:
            生成结果列表
        """
        results = []
        base_temperature = kwargs.get('temperature', 0.7)

        for i in range(count):
            # 调整temperature以获得不同结果
            temp = max(0.3, min(1.5, base_temperature + (i - 1) * 0.15))

            result = self.generate(
                content_type,
                params,
                **{**kwargs, 'temperature': temp}
            )
            result['version'] = i + 1
            results.append(result)

        return results

    def optimize(self, content: str, instruction: str) -> str:
        """优化已有内容

        Args:
            content: 待优化内容
            instruction: 优化指令

        Returns:
            优化后的内容
        """
        messages = [
            {
                "role": "system",
                "content": "你是小红书内容优化专家，擅长改进文案质量和吸引力。"
            },
            {
                "role": "user",
                "content": f"请根据以下要求优化文案，保持原意：\n\n要求：{instruction}\n\n原文案：\n{content}"
            }
        ]
        return self.llm.generate(messages)

    def rewrite(self, content: str, target_style: str) -> str:
        """改写内容风格

        Args:
            content: 原内容
            target_style: 目标风格 (如：幽默风趣、文艺清新、专业干货)

        Returns:
            改写后的内容
        """
        messages = [
            {
                "role": "system",
                "content": f"你是小红书文案改写专家，擅长将文案改写为{target_style}风格。"
            },
            {
                "role": "user",
                "content": f"请将以下文案改写为{target_style}风格：\n\n{content}"
            }
        ]
        return self.llm.generate(messages)

    def generate_hashtags(self, content: str, count: int = 5) -> List[str]:
        """生成相关话题标签

        Args:
            content: 内容文本
            count: 生成数量

        Returns:
            标签列表
        """
        messages = [
            {
                "role": "system",
                "content": "你是小红书话题标签专家，擅长根据内容推荐精准的话题标签。"
            },
            {
                "role": "user",
                "content": f"请为以下内容推荐{count}个相关的话题标签，只返回标签列表：\n\n{content}"
            }
        ]
        result = self.llm.generate(messages, max_tokens=200)
        tags = re.findall(r'#(\S+)', result)
        return [f"#{tag}" for tag in tags[:count]]

    def generate_title(self, content: str, count: int = 3) -> List[str]:
        """生成标题选项

        Args:
            content: 内容文本
            count: 生成数量

        Returns:
            标题列表
        """
        messages = [
            {
                "role": "system",
                "content": "你是小红书标题专家，擅长创作吸睛标题。"
            },
            {
                "role": "user",
                "content": f"请为以下内容生成{count}个吸睛标题，每个标题单独一行：\n\n{content[:500]}"
            }
        ]
        result = self.llm.generate(messages, max_tokens=300)
        titles = [line.strip().lstrip('#').strip() for line in result.split('\n') if line.strip()]
        return titles[:count]

    # ===== 私有方法 =====

    def _extract_title(self, content: str) -> str:
        """从内容中提取标题"""
        lines = content.strip().split('\n')
        if lines:
            # 移除 markdown 标题符号
            title = lines[0].strip('#').strip()
            # 移除 emoji 后获取纯文本标题
            title = re.sub(r'[^\w\s\u4e00-\u9fff\u3000-\u303f\uff00-\uffef]', '', title).strip()
            return title[:50] if title else "未命名标题"
        return "未命名标题"

    def _extract_tags(self, content: str) -> List[str]:
        """提取话题标签"""
        tags = re.findall(r'#(\S+)', content)
        return [f"#{tag}" for tag in set(tags)]


class ContentOptimizer:
    """内容优化器

    提供内容优化、A/B 测试、数据分析功能
    """

    def __init__(self, llm_provider: LLMProvider):
        self.llm = llm_provider

    def analyze_quality(self, content: str) -> Dict:
        """分析内容质量

        Args:
            content: 内容文本

        Returns:
            质量分析结果
        """
        messages = [
            {
                "role": "system",
                "content": """你是小红书内容质量分析师。请从以下维度分析内容质量：
1. 标题吸引力 (1-10分)
2. 内容完整性 (1-10分)
3. 情绪共鸣度 (1-10分)
4. 互动引导性 (1-10分)
5. 标签相关性 (1-10分)

返回 JSON 格式结果。"""
            },
            {
                "role": "user",
                "content": f"请分析以下内容质量：\n\n{content}"
            }
        ]
        result = self.llm.generate(messages, max_tokens=500)

        # 简单解析（实际应用中应该用 JSON 解析）
        return {
            "raw_analysis": result,
            "recommendations": self._generate_recommendations(result)
        }

    def _generate_recommendations(self, analysis: str) -> List[str]:
        """根据分析生成优化建议"""
        messages = [
            {
                "role": "system",
                "content": "你是内容优化顾问，根据分析结果给出具体改进建议。"
            },
            {
                "role": "user",
                "content": f"根据以下分析，给出3-5条具体改进建议：\n\n{analysis}"
            }
        ]
        result = self.llm.generate(messages, max_tokens=400)
        return [line.strip().lstrip('-•*').strip() for line in result.split('\n') if line.strip()]
