#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
符号传承分析系统
胡汉三千年项目核心分析工具

功能：实现符号的溯源分析、形义关联、跨文明对比等功能
"""

import json
import sqlite3
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
from enum import Enum

class YinYangAttribute(Enum):
    """阴阳属性枚举"""
    YIN = "yin"      # 阴
    YANG = "yang"    # 阳
    NEUTRAL = "neutral"  # 中性

class EngravingType(Enum):
    """刻法类型枚举"""
    YIN_ENGRAVING = "yin_engraving"    # 阴刻
    YANG_ENGRAVING = "yang_engraving"  # 阳刻
    MIXED = "mixed"                    # 混合

class LinkType(Enum):
    """关联类型枚举"""
    DIRECT_EVOLUTION = "direct_evolution"        # 直接演化
    FUNCTIONAL_PARALLEL = "functional_parallel"  # 功能平行
    STRUCTURAL_SIMILARITY = "structural_similarity"  # 结构相似
    PHONETIC_CORRESPONDENCE = "phonetic_correspondence"  # 语音对应

@dataclass
class Symbol:
    """符号数据类"""
    symbol_id: str
    symbol_form: str
    symbol_name: str
    yin_yang_attribute: YinYangAttribute
    engraving_type: EngravingType
    origin_civilization: str
    origin_period: str
    description: str

@dataclass
class SymbolAttribute:
    """符号属性数据类"""
    attribute_type: str
    attribute_name: str
    attribute_value: str
    evidence_source: str
    confidence_level: str

@dataclass
class CrossCivilizationLink:
    """跨文明关联数据类"""
    source_symbol_id: str
    target_symbol_id: str
    link_type: LinkType
    link_strength: str
    transmission_path: str
    historical_evidence: str

class SymbolAnalysisSystem:
    """符号分析系统主类"""
    
    def __init__(self, db_path: str = "symbols.db"):
        """初始化分析系统"""
        self.db_path = db_path
        self.conn = None
        self._init_database()
    
    def _init_database(self):
        """初始化数据库"""
        self.conn = sqlite3.connect(self.db_path)
        self._create_tables()
        self._load_sample_data()
    
    def _create_tables(self):
        """创建数据库表"""
        cursor = self.conn.cursor()
        
        # 创建符号主表
        cursor.execute("""
        CREATE TABLE IF NOT EXISTS symbols (
            symbol_id TEXT PRIMARY KEY,
            symbol_form TEXT NOT NULL,
            symbol_name TEXT,
            yin_yang_attribute TEXT,
            engraving_type TEXT,
            origin_civilization TEXT,
            origin_period TEXT,
            description TEXT
        )
        """)
        
        # 创建符号属性表
        cursor.execute("""
        CREATE TABLE IF NOT EXISTS symbol_attributes (
            attribute_id INTEGER PRIMARY KEY AUTOINCREMENT,
            symbol_id TEXT,
            attribute_type TEXT,
            attribute_name TEXT,
            attribute_value TEXT,
            evidence_source TEXT,
            confidence_level TEXT,
            FOREIGN KEY (symbol_id) REFERENCES symbols(symbol_id)
        )
        """)
        
        # 创建跨文明关联表
        cursor.execute("""
        CREATE TABLE IF NOT EXISTS cross_civilization_links (
            link_id INTEGER PRIMARY KEY AUTOINCREMENT,
            source_symbol_id TEXT,
            target_symbol_id TEXT,
            link_type TEXT,
            link_strength TEXT,
            transmission_path TEXT,
            historical_evidence TEXT,
            FOREIGN KEY (source_symbol_id) REFERENCES symbols(symbol_id),
            FOREIGN KEY (target_symbol_id) REFERENCES symbols(symbol_id)
        )
        """)
        
        self.conn.commit()
    
    def _load_sample_data(self):
        """加载示例数据"""
        # 检查是否已有数据
        cursor = self.conn.cursor()
        cursor.execute("SELECT COUNT(*) FROM symbols")
        if cursor.fetchone()[0] > 0:
            return
        
        # 加载核心符号数据
        self._load_core_symbols()
    
    def _load_core_symbols(self):
        """加载核心符号数据"""
        cursor = self.conn.cursor()
        
        # P类符号（阴刻）
        p_symbols = [
            ("P_yin_001", "P", "拉丁字母P", "yin", "yin_engraving", "Greek", "8th century BCE", 
             "阴刻符号，象征凹陷、容纳的阴性特质"),
            ("Pi_yin_001", "Π", "希腊字母Pi", "yin", "yin_engraving", "Greek", "8th century BCE",
             "阴刻符号，两竖一横形成凹槽结构"),
            ("Fu_gua_yin", "否", "周易否卦", "yin", "yin_engraving", "Chinese", "Zhou Dynasty",
             "天地否卦，上乾下坤，象征阴盛阳衰的凹陷状态")
        ]
        
        # T类符号（阳刻）
        t_symbols = [
            ("T_yang_001", "T", "拉丁字母T", "yang", "yang_engraving", "Greek", "8th century BCE",
             "阳刻符号，象征凸起、支撑的阳性特质"),
            ("Tau_yang_001", "Τ", "希腊字母Tau", "yang", "yang_engraving", "Greek", "8th century BCE",
             "阳刻符号，一横一竖形成立柱结构"),
            ("Tai_gua_yang", "泰", "周易泰卦", "yang", "yang_engraving", "Chinese", "Zhou Dynasty",
             "地天泰卦，上坤下乾，象征阳盛阴衰的凸起状态")
        ]
        
        # 插入符号数据
        cursor.executemany("""
        INSERT OR IGNORE INTO symbols VALUES (?, ?, ?, ?, ?, ?, ?, ?)
        """, p_symbols + t_symbols)
        
        # 插入关联数据
        links = [
            ("Fu_gua_yin", "Pi_yin_001", "functional_parallel", "strong",
             "周易→希腊文明交流", "阴阳观的功能对应"),
            ("Pi_yin_001", "P_yin_001", "direct_evolution", "strong",
             "希腊字母→拉丁字母演化", "字母形态的直接继承"),
            ("Tai_gua_yang", "Tau_yang_001", "functional_parallel", "strong",
             "周易→希腊文明交流", "阴阳观的功能对应"),
            ("Tau_yang_001", "T_yang_001", "direct_evolution", "strong",
             "希腊字母→拉丁字母演化", "字母形态的直接继承")
        ]
        
        cursor.executemany("""
        INSERT OR IGNORE INTO cross_civilization_links 
        (source_symbol_id, target_symbol_id, link_type, link_strength, transmission_path, historical_evidence)
        VALUES (?, ?, ?, ?, ?, ?)
        """, links)
        
        self.conn.commit()
    
    def trace_symbol_origin(self, symbol_id: str) -> List[Tuple[str, str, str]]:
        """
        追踪符号的起源和传播路径
        
        Args:
            symbol_id: 符号ID
            
        Returns:
            List of (symbol_id, civilization, period) tuples representing the transmission path
        """
        cursor = self.conn.cursor()
        
        # 使用递归查询追踪传播路径
        query = """
        WITH RECURSIVE symbol_path AS (
            SELECT s.symbol_id, s.origin_civilization, s.origin_period, 0 as depth
            FROM symbols s
            WHERE s.symbol_id = ?
            
            UNION ALL
            
            SELECT s.symbol_id, s.origin_civilization, s.origin_period, sp.depth + 1
            FROM symbols s
            JOIN cross_civilization_links l ON s.symbol_id = l.target_symbol_id
            JOIN symbol_path sp ON l.source_symbol_id = sp.symbol_id
            WHERE sp.depth < 10  -- 防止无限递归
        )
        SELECT symbol_id, origin_civilization, origin_period
        FROM symbol_path
        ORDER BY depth DESC
        """
        
        cursor.execute(query, (symbol_id,))
        return cursor.fetchall()
    
    def analyze_yin_yang_correspondence(self, symbol_id: str) -> Dict:
        """
        分析符号的阴阳对应关系
        
        Args:
            symbol_id: 符号ID
            
        Returns:
            包含阴阳分析结果的字典
        """
        cursor = self.conn.cursor()
        
        # 获取符号基本信息
        cursor.execute("""
        SELECT symbol_form, symbol_name, yin_yang_attribute, engraving_type, description
        FROM symbols
        WHERE symbol_id = ?
        """, (symbol_id,))
        
        result = cursor.fetchone()
        if not result:
            return {"error": "Symbol not found"}
        
        symbol_form, symbol_name, yin_yang, engraving_type, description = result
        
        # 分析阴阳属性
        analysis = {
            "symbol_id": symbol_id,
            "symbol_form": symbol_form,
            "symbol_name": symbol_name,
            "yin_yang_attribute": yin_yang,
            "engraving_type": engraving_type,
            "description": description,
            "opposite_symbols": [],
            "similar_symbols": [],
            "geographical_correspondences": []
        }
        
        # 寻找对立符号
        opposite_yin_yang = "yang" if yin_yang == "yin" else "yin"
        cursor.execute("""
        SELECT symbol_id, symbol_form, symbol_name
        FROM symbols
        WHERE yin_yang_attribute = ?
        LIMIT 5
        """, (opposite_yin_yang,))
        
        analysis["opposite_symbols"] = [
            {"symbol_id": row[0], "form": row[1], "name": row[2]}
            for row in cursor.fetchall()
        ]
        
        # 寻找相似符号
        cursor.execute("""
        SELECT symbol_id, symbol_form, symbol_name
        FROM symbols
        WHERE yin_yang_attribute = ? AND symbol_id != ?
        LIMIT 5
        """, (yin_yang, symbol_id))
        
        analysis["similar_symbols"] = [
            {"symbol_id": row[0], "form": row[1], "name": row[2]}
            for row in cursor.fetchall()
        ]
        
        return analysis
    
    def find_cross_civilization_parallels(self, symbol_id: str) -> List[Dict]:
        """
        寻找跨文明的平行符号
        
        Args:
            symbol_id: 符号ID
            
        Returns:
            平行符号列表
        """
        cursor = self.conn.cursor()
        
        # 获取当前符号的属性
        cursor.execute("""
        SELECT yin_yang_attribute, engraving_type
        FROM symbols
        WHERE symbol_id = ?
        """, (symbol_id,))
        
        result = cursor.fetchone()
        if not result:
            return []
        
        yin_yang, engraving_type = result
        
        # 寻找具有相同阴阳属性和刻法类型的符号
        cursor.execute("""
        SELECT s.symbol_id, s.symbol_form, s.symbol_name, s.origin_civilization, s.origin_period
        FROM symbols s
        WHERE s.yin_yang_attribute = ? AND s.engraving_type = ? AND s.symbol_id != ?
        ORDER BY s.origin_period
        """, (yin_yang, engraving_type, symbol_id))
        
        parallels = []
        for row in cursor.fetchall():
            parallels.append({
                "symbol_id": row[0],
                "form": row[1],
                "name": row[2],
                "civilization": row[3],
                "period": row[4]
            })
        
        return parallels
    
    def create_symbol_family_tree(self, base_symbol_id: str) -> Dict:
        """
        创建符号家族树
        
        Args:
            base_symbol_id: 基础符号ID
            
        Returns:
            符号家族树结构
        """
        cursor = self.conn.cursor()
        
        # 获取基础符号信息
        cursor.execute("""
        SELECT symbol_form, symbol_name, origin_civilization, origin_period
        FROM symbols
        WHERE symbol_id = ?
        """, (base_symbol_id,))
        
        base_info = cursor.fetchone()
        if not base_info:
            return {"error": "Base symbol not found"}
        
        family_tree = {
            "base_symbol": {
                "id": base_symbol_id,
                "form": base_info[0],
                "name": base_info[1],
                "civilization": base_info[2],
                "period": base_info[3]
            },
            "ancestors": [],
            "descendants": [],
            "parallels": []
        }
        
        # 寻找祖先符号（来源）
        cursor.execute("""
        SELECT s.symbol_id, s.symbol_form, s.symbol_name, s.origin_civilization, s.origin_period
        FROM symbols s
        JOIN cross_civilization_links l ON s.symbol_id = l.source_symbol_id
        WHERE l.target_symbol_id = ? AND l.link_type = 'direct_evolution'
        """, (base_symbol_id,))
        
        for row in cursor.fetchall():
            family_tree["ancestors"].append({
                "id": row[0], "form": row[1], "name": row[2],
                "civilization": row[3], "period": row[4]
            })
        
        # 寻找后代符号（演化）
        cursor.execute("""
        SELECT s.symbol_id, s.symbol_form, s.symbol_name, s.origin_civilization, s.origin_period
        FROM symbols s
        JOIN cross_civilization_links l ON s.symbol_id = l.target_symbol_id
        WHERE l.source_symbol_id = ? AND l.link_type = 'direct_evolution'
        """, (base_symbol_id,))
        
        for row in cursor.fetchall():
            family_tree["descendants"].append({
                "id": row[0], "form": row[1], "name": row[2],
                "civilization": row[3], "period": row[4]
            })
        
        # 寻找平行符号
        family_tree["parallels"] = self.find_cross_civilization_parallels(base_symbol_id)
        
        return family_tree
    
    def export_analysis_report(self, symbol_id: str, output_format: str = "json") -> str:
        """
        导出符号分析报告
        
        Args:
            symbol_id: 符号ID
            output_format: 输出格式（json/markdown）
            
        Returns:
            分析报告内容
        """
        # 获取各种分析结果
        origin_path = self.trace_symbol_origin(symbol_id)
        yin_yang_analysis = self.analyze_yin_yang_correspondence(symbol_id)
        family_tree = self.create_symbol_family_tree(symbol_id)
        
        # 符号基本信息
        cursor = self.conn.cursor()
        cursor.execute("SELECT * FROM symbols WHERE symbol_id = ?", (symbol_id,))
        symbol_info = cursor.fetchone()
        
        if output_format == "json":
            report = {
                "symbol_info": dict(zip([col[0] for col in cursor.description], symbol_info)),
                "origin_path": origin_path,
                "yin_yang_analysis": yin_yang_analysis,
                "family_tree": family_tree
            }
            return json.dumps(report, ensure_ascii=False, indent=2)
        
        elif output_format == "markdown":
            markdown_report = f"""# 符号分析报告：{symbol_id}

## 符号基本信息
- **符号形态**: {symbol_info[1]}
- **符号名称**: {symbol_info[2]}
- **阴阳属性**: {symbol_info[3]}
- **刻法类型**: {symbol_info[4]}
- **起源文明**: {symbol_info[5]}
- **起源时期**: {symbol_info[6]}
- **描述**: {symbol_info[7]}

## 起源传播路径
"""
            
            for i, (sym_id, civ, period) in enumerate(origin_path):
                markdown_report += f"{i+1}. {sym_id} ({civ}, {period})\n"
            
            markdown_report += f"""
## 阴阳对应分析
- **对立符号**: {len(yin_yang_analysis.get('opposite_symbols', []))} 个
- **相似符号**: {len(yin_yang_analysis.get('similar_symbols', []))} 个

## 符号家族树
- **祖先符号**: {len(family_tree.get('ancestors', []))} 个
- **后代符号**: {len(family_tree.get('descendants', []))} 个
- **平行符号**: {len(family_tree.get('parallels', []))} 个
"""
            
            return markdown_report
        
        else:
            return "Unsupported output format"

# 使用示例
def main():
    """主函数示例"""
    # 创建分析系统
    analyzer = SymbolAnalysisSystem()
    
    # 分析P符号
    print("=== P符号分析 ===")
    p_analysis = analyzer.analyze_yin_yang_correspondence("P_yin_001")
    print(json.dumps(p_analysis, ensure_ascii=False, indent=2))
    
    # 追踪P符号起源
    print("\n=== P符号起源追踪 ===")
    p_origin = analyzer.trace_symbol_origin("P_yin_001")
    for sym_id, civ, period in p_origin:
        print(f"{sym_id}: {civ} ({period})")
    
    # 导出分析报告
    print("\n=== P符号分析报告 ===")
    report = analyzer.export_analysis_report("P_yin_001", "markdown")
    print(report)

if __name__ == "__main__":
    main()