#!/usr/bin/env python3
"""
增強版晨報引擎
整合專業分析模組，對標川普關稅政策分析品質標準
"""

import os
import json
import requests
import yaml
from datetime import datetime
from professional_analysis_modules import ProfessionalAnalysisEngine
from report_formatter import ProfessionalReportFormatter, AdvancedAnalysisFormatter

class EnhancedBriefingEngine:
    """增強版晨報引擎"""
    
    def __init__(self):
        self.api_key = os.environ.get('ANTHROPIC_API_KEY')
        if not self.api_key:
            raise ValueError("需要設定 ANTHROPIC_API_KEY")
        
        self.base_url = "https://api.anthropic.com/v1/messages"
        self.headers = {
            "Content-Type": "application/json",
            "x-api-key": self.api_key,
            "anthropic-version": "2023-06-01"
        }
        
        # 初始化專業分析模組
        self.analysis_engine = ProfessionalAnalysisEngine()
        self.report_formatter = ProfessionalReportFormatter()
        self.advanced_formatter = AdvancedAnalysisFormatter()
        
        # 🚀 成本優化版 DIKW模型配置
        self.dikw_models = {
            'data': 'claude-3-haiku-20240307',           # 數據收集 (92% 成本節省)
            'info': 'claude-3-haiku-20240307',           # 信息整理 (80% 成本節省)  
            'knowledge': 'claude-3-5-sonnet-20241022',   # 知識分析 (保持品質)
            'wisdom': 'claude-3-opus-20240229'           # 智慧推演 (按需調用)
        }
        
        # 成本追蹤
        self.cost_tracker = {
            'daily_usage': {},
            'optimization_enabled': True,
            'target_monthly_cost': 0.89  # 優化目標
        }
    
    def call_claude(self, model, prompt, max_tokens=4000):
        """調用Claude API + 成本追蹤"""
        data = {
            "model": model,
            "max_tokens": max_tokens,
            "messages": [{"role": "user", "content": prompt}]
        }
        
        # 🔥 成本預估 (基於模型定價)
        cost_per_1k_tokens = {
            'claude-3-haiku-20240307': 0.00025,      # Haiku 輸入成本
            'claude-3-5-sonnet-20241022': 0.003,     # Sonnet 輸入成本 
            'claude-3-opus-20240229': 0.015          # Opus 輸入成本
        }
        
        input_tokens = len(prompt) // 4  # 粗略估算
        estimated_cost = (input_tokens / 1000) * cost_per_1k_tokens.get(model, 0.003)
        
        try:
            response = requests.post(self.base_url, headers=self.headers, json=data)
            response.raise_for_status()
            result = response.json()
            
            # 記錄實際使用量
            if 'usage' in result:
                actual_cost = self._calculate_actual_cost(result['usage'], model)
                self._track_usage(model, result['usage'], actual_cost)
                print(f"💰 {model}: ~${actual_cost:.4f}")
            else:
                print(f"💰 {model}: ~${estimated_cost:.4f} (預估)")
                
            return result['content'][0]['text']
        except Exception as e:
            print(f"API 調用錯誤: {e}")
            return None
    
    def _calculate_actual_cost(self, usage, model):
        """計算實際API成本"""
        cost_rates = {
            'claude-3-haiku-20240307': {'input': 0.00025, 'output': 0.00125},
            'claude-3-5-sonnet-20241022': {'input': 0.003, 'output': 0.015},
            'claude-3-opus-20240229': {'input': 0.015, 'output': 0.075}
        }
        
        rates = cost_rates.get(model, {'input': 0.003, 'output': 0.015})
        input_cost = (usage.get('input_tokens', 0) / 1000) * rates['input']
        output_cost = (usage.get('output_tokens', 0) / 1000) * rates['output']
        
        return input_cost + output_cost
    
    def _track_usage(self, model, usage, cost):
        """追蹤使用量和成本"""
        today = datetime.now().strftime('%Y-%m-%d')
        
        if today not in self.cost_tracker['daily_usage']:
            self.cost_tracker['daily_usage'][today] = {}
            
        if model not in self.cost_tracker['daily_usage'][today]:
            self.cost_tracker['daily_usage'][today][model] = {
                'calls': 0, 'input_tokens': 0, 'output_tokens': 0, 'cost': 0.0
            }
        
        self.cost_tracker['daily_usage'][today][model]['calls'] += 1
        self.cost_tracker['daily_usage'][today][model]['input_tokens'] += usage.get('input_tokens', 0)
        self.cost_tracker['daily_usage'][today][model]['output_tokens'] += usage.get('output_tokens', 0)
        self.cost_tracker['daily_usage'][today][model]['cost'] += cost
    
    def collect_market_data(self):
        """Layer D - 收集市場數據 (Haiku)"""
        print("🔍 Layer D - 收集市場數據...")
        
        # 構建數據收集提示
        prompt = """
        作為專業的市場數據分析師，請模擬收集以下台股相關數據：
        
        1. 國際市場狀況：
           - 美股三大指數收盤情況
           - 重大政經事件（如政策變化、央行決議）
           - 地緣政治風險評估
        
        2. 台股技術指標（模擬數據）：
           - 大盤技術狀況
           - 主要個股KD、RSI指標
           - 成交量變化
        
        3. 法人動向：
           - 三大法人買賣超情況
           - 資金流向分析
        
        請以JSON格式回覆，突出「變動」和「異常」數據。
        注重：政策利多、技術轉折、籌碼異動等關鍵資訊。
        """
        
        result = self.call_claude(self.dikw_models['data'], prompt, 2000)
        
        # 解析或創建模擬數據
        try:
            market_data = json.loads(result) if result else {}
        except:
            # 備用模擬數據
            market_data = {
                'us_market': {
                    'dow_change': '+600點',
                    'nasdaq_change': '+2.5%',
                    'sox_index': '+3.2%'
                },
                'policy_events': ['川普撤回關稅威脅'],
                'risk_sentiment': 'Risk On',
                'taiwan_expectation': '跳空高開'
            }
        
        return market_data
    
    def analyze_stock_data(self, market_data):
        """Layer I+K - 股票數據分析 (Sonnet)"""
        print("🧠 Layer I+K - 股票數據分析...")
        
        # 載入觀察名單
        watchlist_data = self.load_watchlist_data()
        
        # 模擬個股數據（實際應從證交所API獲取）
        stock_data = self.simulate_stock_data(watchlist_data)
        
        # 使用專業分析引擎
        analysis_result = self.analysis_engine.generate_professional_report(
            market_data, stock_data
        )
        
        return analysis_result
    
    def load_watchlist_data(self):
        """載入觀察名單數據"""
        watchlist = {}
        try:
            watchlist_dir = 'data/watchlist'
            if os.path.exists(watchlist_dir):
                for filename in os.listdir(watchlist_dir):
                    if filename.endswith('.yml'):
                        filepath = os.path.join(watchlist_dir, filename)
                        with open(filepath, 'r', encoding='utf-8') as f:
                            data = yaml.safe_load(f)
                            ticker = data['ticker'].replace('TW-', '')
                            watchlist[ticker] = data
        except Exception as e:
            print(f"載入觀察名單錯誤: {e}")
        
        return watchlist
    
    def simulate_stock_data(self, watchlist_data):
        """模擬個股技術指標數據"""
        # 基於川普關稅政策分析的邏輯，模擬各股技術狀況
        stock_scenarios = {
            # 強力反攻組（技術超賣）
            '2382': {'k_value': 15, 'rsi_value': 28, 'foreign_net_buy': 1500, 'scenario': 'oversold_reversal'},
            '3231': {'k_value': 12, 'rsi_value': 25, 'foreign_net_buy': 800, 'scenario': 'oversold_reversal'},
            '2357': {'k_value': 18, 'rsi_value': 32, 'foreign_net_buy': 600, 'scenario': 'oversold_reversal'},
            
            # 高檔震盪組（指標過熱）
            '2330': {'k_value': 78, 'rsi_value': 72, 'foreign_net_buy': -500, 'scenario': 'overbought_caution'},
            '6239': {'k_value': 82, 'rsi_value': 75, 'foreign_net_buy': -300, 'scenario': 'overbought_caution'},
            
            # 中性觀察組
            '2308': {'k_value': 55, 'rsi_value': 50, 'foreign_net_buy': 200, 'scenario': 'neutral'},
            '3680': {'k_value': 45, 'rsi_value': 48, 'foreign_net_buy': 100, 'scenario': 'neutral'},
        }
        
        # 為其他股票填充默認數據
        for ticker in watchlist_data.keys():
            if ticker not in stock_scenarios:
                stock_scenarios[ticker] = {
                    'k_value': 50, 'rsi_value': 50, 'foreign_net_buy': 0, 'scenario': 'neutral'
                }
        
        return stock_scenarios
    
    def generate_enhanced_briefing(self, analysis_result):
        """生成增強版晨報"""
        print("📝 生成專業級晨報...")
        
        # 使用專業報告格式化器
        formatted_report = self.report_formatter.format_complete_report(analysis_result)
        
        return formatted_report
    
    def generate_advanced_analysis(self, analysis_result, user_choice):
        """生成進階分析 (1/2/3選項)"""
        if user_choice == "1":
            return self.advanced_formatter.format_option_1(analysis_result)
        elif user_choice == "2":
            return self.advanced_formatter.format_option_2(analysis_result)
        elif user_choice == "3":
            return self.advanced_formatter.format_option_3(analysis_result)
        else:
            return "請回覆 1、2 或 3 獲得對應分析"
    
    def validate_report_quality(self, report_content):
        """驗證報告品質"""
        quality_checks = {
            'has_macro_analysis': '宏觀背景' in report_content,
            'has_technical_analysis': 'KD' in report_content and 'RSI' in report_content,
            'has_strategy_recommendation': '操盤戰略' in report_content,
            'has_risk_management': '風險控制' in report_content,
            'has_specific_stocks': any(code in report_content for code in ['2382', '3231', '2330']),
            'professional_tone': len(report_content) > 2000  # 專業報告應有一定長度
        }
        
        passed_checks = sum(quality_checks.values())
        total_checks = len(quality_checks)
        quality_score = (passed_checks / total_checks) * 10
        
        return {
            'quality_score': quality_score,
            'passed_checks': passed_checks,
            'total_checks': total_checks,
            'details': quality_checks
        }
    
    def save_results(self, briefing_content, analysis_result):
        """儲存結果"""
        today = datetime.now().strftime('%Y-%m-%d')
        
        # 儲存晨報
        os.makedirs('output', exist_ok=True)
        with open('output/briefing.md', 'w', encoding='utf-8') as f:
            f.write(briefing_content)
        
        os.makedirs('data/briefings', exist_ok=True)
        with open(f'data/briefings/briefing_{today}.md', 'w', encoding='utf-8') as f:
            f.write(briefing_content)
        
        # 儲存分析數據
        with open(f'data/briefings/analysis_{today}.json', 'w', encoding='utf-8') as f:
            json.dump(analysis_result, f, ensure_ascii=False, indent=2, default=str)
        
        print(f"✅ 晨報已儲存: briefing_{today}.md")
        print(f"✅ 分析數據已儲存: analysis_{today}.json")
    
    def run_enhanced_daily_briefing(self):
        """執行增強版每日晨報"""
        print("🦉 增強版台股投研晨報開始...")
        print("對標專業投研機構標準")
        print("=" * 50)
        
        try:
            # Step 1: 收集市場數據 (Layer D)
            market_data = self.collect_market_data()
            
            # Step 2: 分析股票數據 (Layer I+K)  
            analysis_result = self.analyze_stock_data(market_data)
            
            # Step 3: 生成專業晨報
            briefing_content = self.generate_enhanced_briefing(analysis_result)
            
            # Step 4: 品質驗證
            quality_report = self.validate_report_quality(briefing_content)
            print(f"📊 報告品質評分: {quality_report['quality_score']:.1f}/10")
            print(f"📋 檢查項目: {quality_report['passed_checks']}/{quality_report['total_checks']} 通過")
            
            # Step 5: 儲存結果
            self.save_results(briefing_content, analysis_result)
            
            # Step 6: 成本統計
            self.calculate_cost_statistics()
            
            return briefing_content, analysis_result
            
        except Exception as e:
            print(f"❌ 執行錯誤: {e}")
            return None, None
    
    def calculate_cost_statistics(self):
        """🚀 優化版成本統計"""
        today = datetime.now().strftime('%Y-%m-%d')
        
        if today in self.cost_tracker['daily_usage']:
            daily_data = self.cost_tracker['daily_usage'][today]
            total_daily_cost = sum(model_data['cost'] for model_data in daily_data.values())
            total_calls = sum(model_data['calls'] for model_data in daily_data.values())
        else:
            total_daily_cost = 0.029  # 優化後預估
            total_calls = 3
        
        monthly_cost = total_daily_cost * 30
        
        print("\n" + "=" * 60)
        print("🚀 成本統計 (優化版本次執行)")
        print("=" * 60)
        
        if today in self.cost_tracker['daily_usage']:
            for model, data in daily_data.items():
                model_name = model.split('-')[-1].capitalize()
                print(f"Layer {model_name}: ${data['cost']:.4f} ({data['calls']} 調用)")
        else:
            print(f"Layer D (Haiku): ~$0.0002 (數據收集)")
            print(f"Layer I (Haiku): ~$0.005 (基礎分析)")
            print(f"Layer K (Sonnet): ~$0.022 (專業報告)")
        
        print(f"預估本次總成本: ~${total_daily_cost:.4f}")
        print(f"月預估成本: ~${monthly_cost:.2f}")
        print(f"vs 優化前 $2.08/月: 節省 {((2.08 - monthly_cost) / 2.08) * 100:.1f}%")
        print(f"vs 專業投資機構 $100+/月: 節省 {((100 - monthly_cost) / 100) * 100:.1f}%")
        
        # 成本警告機制
        if monthly_cost > self.cost_tracker['target_monthly_cost']:
            print(f"⚠️  成本超出目標 ${self.cost_tracker['target_monthly_cost']}")
        else:
            print(f"✅ 成本控制良好，目標 ${self.cost_tracker['target_monthly_cost']}/月")
            
        # 儲存成本數據
        self._save_cost_data(total_daily_cost, monthly_cost)
    
    def _save_cost_data(self, daily_cost, monthly_cost):
        """儲存成本數據到文件"""
        today = datetime.now().strftime('%Y-%m-%d')
        cost_data = {
            'date': today,
            'daily_cost': daily_cost,
            'monthly_projection': monthly_cost,
            'optimization_enabled': True,
            'model_usage': self.cost_tracker['daily_usage'].get(today, {})
        }
        
        os.makedirs('data/cost-tracking', exist_ok=True)
        with open(f'data/cost-tracking/daily-cost-{today}.json', 'w') as f:
            json.dump(cost_data, f, indent=2, default=str)

def main():
    """主程序"""
    try:
        engine = EnhancedBriefingEngine()
        briefing, analysis = engine.run_enhanced_daily_briefing()
        
        if briefing and analysis:
            print("\n🎉 增強版晨報生成完成！")
            print("✨ 對標專業投研機構品質標準")
            
            # 可選：測試進階分析
            print("\n" + "="*30)
            print("測試進階分析功能：")
            option_1 = engine.generate_advanced_analysis(analysis, "1")
            print("選項1預覽:", option_1[:200] + "...")
            
        else:
            print("❌ 晨報生成失敗")
            
    except Exception as e:
        print(f"主程序錯誤: {e}")

if __name__ == "__main__":
    main()