"""
测试向量点积计算逻辑
======================
验证 Strategist 推导的宏观因子向量与 PM 的敏感度矩阵计算是否正确
"""

import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).parent))

from core.world_book import WorldBook
from skills.strategist import MacroStrategist
from skills.pm import PortfolioManager


def test_macro_vector_calculation():
    """测试宏观因子向量计算"""
    print("=" * 60)
    print("测试 1: 宏观因子向量推导")
    print("=" * 60)
    
    # 创建 WorldBook
    wb = WorldBook(data_dir="data/test")
    
    # 创建 Strategist
    strategist = MacroStrategist(wb)
    
    # 模拟新闻分析结果
    narrative_json = {
        "narratives": [
            {
                "topic": "央行宣布全面降息，支持数字经济发展",
                "level_a_count": 1,
                "level_b_count": 0,
                "avg_score": 85,
                "max_score": 90,
                "related_etfs": ["515230"],
                "lifecycle_stage": "fermentation"
            },
            {
                "topic": "地缘紧张局势升级，避险情绪升温",
                "level_a_count": 0,
                "level_b_count": 1,
                "avg_score": 70,
                "max_score": 75,
                "related_etfs": ["518880"],
                "lifecycle_stage": "incubation"
            }
        ]
    }
    
    # 推导宏观因子向量
    print("\n输入新闻:")
    for n in narrative_json['narratives']:
        print(f"  - {n['topic']} (Level A: {n['level_a_count']}, Level B: {n['level_b_count']})")
    
    print("\n推导宏观因子向量:")
    factor_vector = strategist.infer_macro_factor_vector(narrative_json)
    
    print(f"\n结果: {factor_vector}")
    
    return wb, factor_vector


def test_sensitivity_calculation(wb: WorldBook, factor_vector: dict):
    """测试敏感度矩阵计算"""
    print("\n" + "=" * 60)
    print("测试 2: 向量点积计算")
    print("=" * 60)
    
    # 创建 PM
    pm = PortfolioManager(wb, total_capital=1000000)
    
    # 测试案例 1: 软件ETF
    print("\n案例 1: 软件与数字经济 (tech_software)")
    print("-" * 60)
    macro_score_software = pm.calculate_macro_sensitivity_score("tech_software")
    print(f"最终得分: {macro_score_software}")
    
    # 测试案例 2: 银行ETF
    print("\n案例 2: 银行/高股息 (finance_bank)")
    print("-" * 60)
    macro_score_bank = pm.calculate_macro_sensitivity_score("finance_bank")
    print(f"最终得分: {macro_score_bank}")
    
    # 测试案例 3: 黄金ETF
    print("\n案例 3: 资源与黄金 (resources_gold)")
    print("-" * 60)
    macro_score_gold = pm.calculate_macro_sensitivity_score("resources_gold")
    print(f"最终得分: {macro_score_gold}")
    
    # 对比分析
    print("\n" + "=" * 60)
    print("对比分析")
    print("=" * 60)
    print(f"软件ETF得分: {macro_score_software}")
    print(f"银行ETF得分: {macro_score_bank}")
    print(f"黄金ETF得分: {macro_score_gold}")
    
    print("\n结论:")
    if macro_score_software > macro_score_bank:
        print("✓ 软件ETF > 银行ETF (符合预期: 降息利好成长股，利空银行息差)")
    
    if macro_score_gold > 0:
        print("✓ 黄金ETF得分为正 (符合预期: 地缘紧张利好黄金避险)")


def test_trust_index_calculation(wb: WorldBook):
    """测试完整的 Trust Index 计算"""
    print("\n" + "=" * 60)
    print("测试 3: Trust Index 计算")
    print("=" * 60)
    
    pm = PortfolioManager(wb, total_capital=1000000)
    
    # 模拟叙事评分和资金流评分
    test_cases = [
        {
            "etf_code": "515230",
            "asset_id": "tech_software",
            "name": "软件ETF",
            "narrative_score": 85,
            "flow_score": 70
        },
        {
            "etf_code": "512800",
            "asset_id": "finance_bank",
            "name": "银行ETF",
            "narrative_score": 50,
            "flow_score": 60
        },
        {
            "etf_code": "518880",
            "asset_id": "resources_gold",
            "name": "黄金ETF",
            "narrative_score": 70,
            "flow_score": 55
        }
    ]
    
    print("\n计算各标的 Trust Index:")
    results = []
    
    for case in test_cases:
        print(f"\n{case['name']} ({case['etf_code']}):")
        print(f"  叙事评分: {case['narrative_score']}")
        print(f"  资金流评分: {case['flow_score']}")
        
        trust_result = pm.calculate_trust_index(
            case['etf_code'],
            case['asset_id'],
            case['narrative_score'],
            case['flow_score']
        )
        
        results.append({**case, **trust_result})
        
        print(f"  → Trust Index: {trust_result['trust_index']} ({trust_result['verdict']})")
    
    # 排序
    results.sort(key=lambda x: x['trust_index'], reverse=True)
    
    print("\n" + "=" * 60)
    print("最终排名")
    print("=" * 60)
    for i, result in enumerate(results, 1):
        print(f"{i}. {result['name']} - Trust Index: {result['trust_index']} "
              f"(Macro: {result['macro_score']:.2f}, Narrative: {result['narrative_score']}, "
              f"Flow: {result['flow_score']}) → {result['verdict']}")


def main():
    """主测试函数"""
    print("\n" + "🧪 " * 30)
    print("MND-IA 向量点积计算测试")
    print("🧪 " * 30)
    
    try:
        # 测试 1: 宏观因子向量推导
        wb, factor_vector = test_macro_vector_calculation()
        
        # 测试 2: 敏感度矩阵点积计算
        test_sensitivity_calculation(wb, factor_vector)
        
        # 测试 3: 完整 Trust Index 计算
        test_trust_index_calculation(wb)
        
        print("\n" + "✅ " * 30)
        print("所有测试完成！")
        print("✅ " * 30)
        
    except Exception as e:
        print(f"\n❌ 测试失败: {e}")
        import traceback
        traceback.print_exc()


if __name__ == "__main__":
    main()