#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
文本立场分析模块 - 人物画像技能
分析目标人物的公开言论，量化政治光谱坐标

创建时间：2026-04-03
开发者：瞰宇 (Kàn Yǔ)
"""

import json
from typing import Dict, List, Tuple, Optional
from dataclasses import dataclass, asdict
from collections import Counter
import re


@dataclass
class PoliticalSpectrum:
    """政治光谱坐标"""
    economic: float  # 左翼-右翼 (-1到+1)
    social: float  # 自由主义-保守主义 (-1到+1)
    international: float  # 民族主义-全球主义 (-1到+1)
    intervention: float  # 孤立主义-干预主义 (-1到+1)
    
    def to_dict(self) -> Dict[str, float]:
        """转换为字典"""
        return {
            "经济立场": self.economic,
            "社会立场": self.social,
            "国际立场": self.international,
            "干预立场": self.intervention
        }


@dataclass
class StanceEvolution:
    """立场演变轨迹"""
    period: str  # 时间段
    spectrum: PoliticalSpectrum
    key_events: List[str]  # 关键事件
    description: str  # 描述


@dataclass
class PolicyStance:
    """政策立场"""
    category: str  # 议题类别
    topic: str  # 具体议题
    stance: str  # 立场（支持、反对、中立等）
    intensity: int  # 强度（-3到+3）
    flexibility: str  # 灵活性（低、中、高）
    evidence: List[str]  # 支持证据


class TextAnalyzer:
    """
    文本立场分析器
    分析公开言论，量化政治光谱坐标
    """
    
    # 政治关键词库（示例，实际应该更完整）
    KEYWORDS = {
        "economic": {
            "left": ["税收", "社会福利", "公共投资", "财富再分配", "工人权利", "最低工资"],
            "right": ["减税", "小政府", "市场自由", "私有化", "放松管制", "企业减负"]
        },
        "social": {
            "liberal": ["多元", "包容", "平等", "自由", "权利", "多样性"],
            "conservative": ["传统", "价值", "家庭", "秩序", "道德", "保守"]
        },
        "international": {
            "nationalist": ["主权", "民族", "爱国", "国家利益", "边境", "本国优先"],
            "globalist": ["合作", "国际", "全球", "多边", "联盟", "开放"]
        },
        "intervention": {
            "isolation": ["不干涉", "主权独立", "国内事务", "避免冲突", "和平"],
            "intervention": ["干预", "军事行动", "制裁", "强硬立场", "捍卫"]
        }
    }
    
    def __init__(self):
        """初始化文本分析器"""
        self.statements = []
        self.spectrum_history = []
    
    def load_statements(self, statements: List[Dict]):
        """
        加载言论数据
        
        Args:
            statements: 言论列表
        """
        self.statements = statements
    
    def analyze_spectrum(self, text: str) -> PoliticalSpectrum:
        """
        分析文本的政治光谱坐标
        
        Args:
            text: 文本内容
            
        Returns:
            PoliticalSpectrum对象
        """
        text_lower = text.lower()
        
        # 计算各维度得分
        economic = self._calculate_dimension_score(
            text_lower, 
            self.KEYWORDS["economic"]["left"], 
            self.KEYWORDS["economic"]["right"]
        )
        
        social = self._calculate_dimension_score(
            text_lower,
            self.KEYWORDS["social"]["liberal"],
            self.KEYWORDS["social"]["conservative"]
        )
        
        international = self._calculate_dimension_score(
            text_lower,
            self.KEYWORDS["international"]["globalist"],
            self.KEYWORDS["international"]["nationalist"]
        )
        
        intervention = self._calculate_dimension_score(
            text_lower,
            self.KEYWORDS["intervention"]["isolation"],
            self.KEYWORDS["intervention"]["intervention"]
        )
        
        return PoliticalSpectrum(
            economic=economic,
            social=social,
            international=international,
            intervention=intervention
        )
    
    def _calculate_dimension_score(
        self, 
        text: str, 
        negative_keywords: List[str], 
        positive_keywords: List[str]
    ) -> float:
        """
        计算某一维度的得分
        
        Args:
            text: 文本
            negative_keywords: 负向关键词
            positive_keywords: 正向关键词
            
        Returns:
            归一化得分（-1到+1）
        """
        neg_count = sum(1 for kw in negative_keywords if kw in text)
        pos_count = sum(1 for kw in positive_keywords if kw in text)
        
        total = neg_count + pos_count
        if total == 0:
            return 0.0
        
        # 计算得分并归一化到[-1, 1]
        score = (pos_count - neg_count) / total
        return score
    
    def analyze_overall_spectrum(self) -> PoliticalSpectrum:
        """
        分析整体政治光谱（基于所有言论）
        
        Returns:
            整体政治光谱坐标
        """
        if not self.statements:
            return PoliticalSpectrum(0.0, 0.0, 0.0, 0.0)
        
        # 合并所有言论文本
        all_text = " ".join([s.get("content", "") for s in self.statements])
        
        return self.analyze_spectrum(all_text)
    
    def analyze_temporal_evolution(
        self, 
        periods: List[Tuple[str, str, str]]
    ) -> List[StanceEvolution]:
        """
        分析立场演变轨迹
        
        Args:
            periods: 时间段列表，每个元素为 (period_name, start_date, end_date)
            
        Returns:
            立场演变轨迹列表
        """
        evolutions = []
        
        for period_name, start_date, end_date in periods:
            # 筛选该时间段的言论
            period_statements = [
                s for s in self.statements 
                if start_date <= s.get("date", "") <= end_date
            ]
            
            if period_statements:
                # 分析该时间段的立场
                period_text = " ".join([s.get("content", "") for s in period_statements])
                spectrum = self.analyze_spectrum(period_text)
                
                evolution = StanceEvolution(
                    period=period_name,
                    spectrum=spectrum,
                    key_events=[],
                    description=f"{period_name}期间的立场分析"
                )
                
                evolutions.append(evolution)
        
        self.spectrum_history = evolutions
        return evolutions
    
    def analyze_policy_stances(self) -> List[PolicyStance]:
        """
        分析政策立场
        
        Returns:
            政策立场列表
        """
        # TODO: 实际实现中，这里应该：
        # 1. 识别重大议题
        # 2. 分析每个议题上的立场
        # 3. 评估立场强度和灵活性
        
        # 返回示例数据
        return []
    
    def generate_spectrum_report(self) -> Dict:
        """
        生成政治光谱分析报告
        
        Returns:
            分析报告字典
        """
        overall_spectrum = self.analyze_overall_spectrum()
        
        report = {
            "政治光谱坐标": overall_spectrum.to_dict(),
            "立场解读": self._interpret_spectrum(overall_spectrum),
            "立场演变轨迹": [
                {
                    "时间段": e.period,
                    "光谱坐标": e.spectrum.to_dict(),
                    "描述": e.description
                }
                for e in self.spectrum_history
            ]
        }
        
        return report
    
    def _interpret_spectrum(self, spectrum: PoliticalSpectrum) -> Dict[str, str]:
        """
        解读政治光谱坐标
        
        Args:
            spectrum: 政治光谱坐标
            
        Returns:
            解读结果
        """
        def _interpret_value(value: float) -> str:
            if value > 0.5:
                return "强正向"
            elif value > 0.2:
                return "中正向"
            elif value > -0.2:
                return "中立"
            elif value > -0.5:
                return "中负向"
            else:
                return "强负向"
        
        return {
            "经济立场": _interpret_value(spectrum.economic),
            "社会立场": _interpret_value(spectrum.social),
            "国际立场": _interpret_value(spectrum.international),
            "干预立场": _interpret_value(spectrum.intervention)
        }


def main():
    """测试文本分析器"""
    analyzer = TextAnalyzer()
    
    # 示例言论数据
    statements = [
        {
            "content": "我们需要减税，让市场自由运作，减少政府干预。",
            "date": "2020-01-01"
        },
        {
            "content": "保护国家主权是我们的首要任务，边境安全不容妥协。",
            "date": "2021-06-15"
        },
        {
            "content": "我们需要与盟友合作，共同应对全球挑战。",
            "date": "2022-03-10"
        }
    ]
    
    analyzer.load_statements(statements)
    
    # 分析整体政治光谱
    print("=== 政治光谱分析 ===")
    spectrum = analyzer.analyze_overall_spectrum()
    print(json.dumps(spectrum.to_dict(), ensure_ascii=False, indent=2))
    
    # 生成报告
    print("\n=== 分析报告 ===")
    report = analyzer.generate_spectrum_report()
    print(json.dumps(report, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()