#!/usr/bin/env python3
"""
Wikipedia内容解析器
从Wikipedia页面提取结构化信息
"""

import re
from typing import Dict, List, Optional, Any
from dataclasses import dataclass


@dataclass
class ParseConfig:
    """解析配置"""
    extract_education: bool = True      # 学历
    extract_career: bool = True          # 职业履历
    extract_awards: bool = True          # 勋章
    extract_family: bool = False         # 家庭（敏感）
    extract_social: bool = True          # 社交媒体
    clean_html: bool = True              # 清理HTML
    language: str = "en"                 # 语言


class WikipediaParser:
    """Wikipedia内容解析器"""
    
    # 教育经历模式
    EDUCATION_PATTERNS = {
        'en': [
            r'Alma mater[:\s]+([^<\n]+)',
            r'Education[:\s]+([^<\n]+)',
            r'College[:\s]+([^<\n]+)',
            r'University[:\s]+([^<\n]+)',
        ],
        'zh': [
            r'学历[:\s　]+([^<\n]+)',
            r'毕业[院校学校]+[:\s　]+([^<\n]+)',
            r'受教育[程度背景]+[:\s　]+([^<\n]+)',
        ],
        'ja': [
            r'学歴[:\s　]+([^<\n]+)',
            r'学校[:\s　]+([^<\n]+)',
        ]
    }
    
    # 军衔/职务模式
    RANK_PATTERNS = {
        'en': [
            r'Service years[:\s]+([^<\n]+)',
            r'Service branch[:\s]+([^<\n]+)',
            r'Rank[:\s]+([^<\n]+)',
            r'Position[:\s]+([^<\n]+)',
            r'Commands?[:\s]+([^<\n]+)',
        ],
        'zh': [
            r'军衔[:\s　]+([^<\n]+)',
            r'职务[:\s　]+([^<\n]+)',
            r'军职[:\s　]+([^<\n]+)',
            r'服役[:\s　]+([^<\n]+)',
        ],
        'ja': [
            r'階級[:\s　]+([^<\n]+)',
            r'役職[:\s　]+([^<\n]+)',
        ]
    }
    
    # 出生信息模式
    BIRTH_PATTERNS = {
        'en': [
            r'Born[:\s]+([^<\n]+)',
            r'Birth date[:\s]+([^<\n]+)',
            r'Birth place[:\s]+([^<\n]+)',
        ],
        'zh': [
            r'出生[年月日期]+[:\s　]+([^<\n]+)',
            r'出生地[:\s　]+([^<\n]+)',
        ],
        'ja': [
            r'生年月日[:\s　]+([^<\n]+)',
            r'出生地[:\s　]+([^<\n]+)',
        ]
    }
    
    # 社交媒体模式
    SOCIAL_PATTERNS = {
        'en': [
            r'Twitter[:\s]+([^<\n]+)',
            r'@(\w+)',
            r'Facebook[:\s]+([^<\n]+)',
            r'Instagram[:\s]+([^<\n]+)',
        ],
        'zh': [
            r'推特[:\s　]+([^<\n]+)',
            r'微博[:\s　]+([^<\n]+)',
        ],
        'ja': [
            r'Twitter[:\s　]+([^<\n]+)',
        ]
    }
    
    def __init__(self, config: ParseConfig = None):
        self.config = config or ParseConfig()
        self.lang = self.config.language
        
    def extract_field(self, text: str, patterns: List[str]) -> str:
        """使用多个模式提取字段"""
        for pattern in patterns:
            match = re.search(pattern, text, re.IGNORECASE)
            if match:
                return match.group(1).strip()
        return ""
    
    def parse_wikipedia(self, markdown: str, html: str = "") -> Dict[str, Any]:
        """解析Wikipedia内容"""
        result = {}
        
        # 提取学历
        if self.config.extract_education:
            edu_patterns = self.EDUCATION_PATTERNS.get(self.lang, self.EDUCATION_PATTERNS['en'])
            result['education'] = self.extract_field(markdown, edu_patterns)
            
        # 提取军衔/职务
        if self.config.extract_career:
            rank_patterns = self.RANK_PATTERNS.get(self.lang, self.RANK_PATTERNS['en'])
            result['rank_or_position'] = self.extract_field(markdown, rank_patterns)
            
        # 提取出生信息
        birth_patterns = self.BIRTH_PATTERNS.get(self.lang, self.BIRTH_PATTERNS['en'])
        birth_info = self.extract_field(markdown, birth_patterns)
        if birth_info:
            result['birth_info'] = birth_info
            
        # 提取社交媒体
        if self.config.extract_social:
            social_patterns = self.SOCIAL_PATTERNS.get(self.lang, self.SOCIAL_PATTERNS['en'])
            for p in social_patterns:
                match = re.search(p, markdown, re.IGNORECASE)
                if match:
                    result['social_media'] = match.group(1).strip()
                    break
                    
        return result
    
    def parse_infobox(self, html: str) -> Dict[str, Any]:
        """解析信息框"""
        result = {}
        
        # 提取表格数据
        infobox_pattern = r'class="[^"]*infobox[^"]*"[^>]*>(.*?)</table>'
        match = re.search(infobox_pattern, html, re.DOTALL | re.IGNORECASE)
        
        if match:
            infobox_html = match.group(1)
            
            # 提取图片
            img_match = re.search(r'<img[^>]+src="([^"]+)"', infobox_html)
            if img_match:
                result['image_url'] = img_match.group(1)
                
            # 提取键值对
            key_value_pattern = r'<th[^>]*>([^<]+)</th>\s*<td[^>]*>([^<]+)</td>'
            for key, value in re.findall(key_value_pattern, infobox_html):
                key = key.strip()
                value = value.strip()
                result[key.lower()] = value
                
        return result
    
    def extract_table_data(self, html: str) -> List[Dict]:
        """提取表格数据"""
        tables = []
        
        # 查找表格
        table_pattern = r'<table[^>]*>(.*?)</table>'
        for table_html in re.findall(table_pattern, html, re.DOTALL | re.IGNORECASE):
            rows = []
            # 提取表头
            header_pattern = r'<th[^>]*>([^<]+)</th>'
            headers = re.findall(header_pattern, table_html)
            
            # 提取数据行
            row_pattern = r'<tr[^>]*>(.*?)</tr>'
            for row_html in re.findall(row_pattern, table_html):
                cells = re.findall(r'<td[^>]*>([^<]*)</td>', row_html)
                if cells and len(cells) == len(headers):
                    row_dict = {headers[i].strip(): cells[i].strip() for i in range(len(headers))}
                    rows.append(row_dict)
                    
            if rows:
                tables.append(rows)
                
        return tables
    
    def clean_text(self, text: str) -> str:
        """清理文本"""
        if not text:
            return ""
            
        # 移除HTML标签
        text = re.sub(r'<[^>]+>', '', text)
        # 移除多余空白
        text = re.sub(r'\s+', ' ', text)
        # 移除引用标记
        text = re.sub(r'\[\d+\]', '', text)
        # 移除参考符号
        text = re.sub(r'\[参\s*考\s*\]', '', text)
        
        return text.strip()


def parse_target(target_name: str, fetch_result: Dict, config: ParseConfig = None) -> Dict:
    """
    解析目标数据
    
    Args:
        target_name: 目标名称
        fetch_result: 采集结果，包含 markdown 和 html
        config: 解析配置
        
    Returns:
        解析后的数据
    """
    parser = WikipediaParser(config)
    
    result = {
        'name': target_name,
        'collection_time': fetch_result.get('collection_time', ''),
    }
    
    # 解析正文
    if fetch_result.get('markdown'):
        parsed = parser.parse_wikipedia(fetch_result['markdown'])
        result.update(parsed)
        
    # 解析信息框
    if fetch_result.get('html'):
        infobox = parser.parse_infobox(fetch_result['html'])
        result.update(infobox)
        
    return result


if __name__ == "__main__":
    print("Wikipedia Parser Module")
    print("用法: from parser import WikipediaParser, parse_target")