# ml_engine/processor.py
# (V12.4 - Hybrid Scoring Core: Added Error Guard for Titan & Patterns)

import asyncio
import traceback
import numpy as np

# استيراد المحركات الثلاثة
try:
    from ml_engine.titan_engine import TitanEngine
except ImportError:
    print("❌ [Processor] لم يتم العثور على titan_engine.py!")
    TitanEngine = None

from ml_engine.monte_carlo import MonteCarloAnalyzer
from ml_engine.patterns import ChartPatternAnalyzer # محرك الأنماط V11.1

class MLProcessor:
    def __init__(self, market_context, data_manager, learning_hub):
        self.market_context = market_context
        self.data_manager = data_manager
        self.learning_hub = learning_hub
        
        # 1. المحرك الرئيسي (Titan) - القناص (50%)
        self.titan = TitanEngine() if TitanEngine else None
        
        # 2. المحرك المساند (Patterns) - المتخصصون (40%)
        # نستخدم نفس النسخة الموجودة في DataManager لتوفير الذاكرة إذا أمكن
        if self.data_manager and self.data_manager.pattern_analyzer:
             self.pattern_engine = self.data_manager.pattern_analyzer
        else:
             self.pattern_engine = ChartPatternAnalyzer()

        # 3. المحرك الاحتمالي (Monte Carlo) - المدقق (10%)
        self.mc_analyzer = MonteCarloAnalyzer()
        
        self.initialized = False

    async def initialize(self):
        """تهيئة جميع المحركات الفرعية"""
        if not self.initialized:
            print("⚙️ [Processor] تهيئة نظام التقييم الهجين...")
            tasks = []
            if self.titan and not self.titan.initialized:
                tasks.append(self.titan.initialize())
            if self.pattern_engine and not self.pattern_engine.initialized:
                tasks.append(self.pattern_engine.initialize())
            
            if tasks:
                await asyncio.gather(*tasks)
            self.initialized = True
            print("✅ [Processor] النظام الهجين جاهز.")

    async def process_and_score_symbol_enhanced(self, raw_data):
        """
        المعالجة المركزية الهجينة (Hybrid Core Processing)
        """
        if not self.initialized: await self.initialize()
        symbol = raw_data.get('symbol')
        ohlcv_data = raw_data.get('ohlcv')
        
        if not symbol or not ohlcv_data: return None

        # 🔥 تهيئة الدرجات الافتراضية للبدء 🔥
        score_titan = 0.0
        score_patterns = 0.0
        score_mc = 0.5
        titan_res = {}
        pattern_res = {'pattern_confidence': 0.0, 'details': {}}
        
        try:
            # --- 1. تشغيل المحركات بالتسلسل مع حماية فردية ---
            
            # أ. تشغيل Titan (50%)
            if self.titan:
                try:
                    # يجب استخدام to_thread هنا لأن TitanEngine يستخدم Pandas الذي ليس async-safe
                    titan_res = await asyncio.to_thread(self.titan.predict, ohlcv_data)
                    score_titan = titan_res.get('score', 0.0)
                except Exception as e:
                    # print(f"❌ [Processor] Titan Engine FAILED for {symbol}: {e}") # إلغاء التعليق إذا أردت رؤية الأخطاء
                    # traceback.print_exc()
                    score_titan = 0.0 # ضمان إرجاع صفر عند الفشل

            # ب. تشغيل الأنماط (40%)
            if self.pattern_engine:
                try:
                    pattern_res = await self.pattern_engine.detect_chart_patterns(ohlcv_data)
                    score_patterns = pattern_res.get('pattern_confidence', 0.0)
                except Exception as e:
                    # print(f"❌ [Processor] Pattern Engine FAILED for {symbol}: {e}")
                    # traceback.print_exc()
                    score_patterns = 0.0 # ضمان إرجاع صفر عند الفشل

            # ج. مهمة مونت كارلو (10%)
            if '1h' in ohlcv_data:
                 try:
                    closes = np.array([c[4] for c in ohlcv_data['1h']])
                    # تشغيل سريع غير متزامن للمحاكاة
                    mc_res = self.mc_analyzer.generate_1h_price_distribution_simple(closes)
                    # تطبيع النتيجة لتكون بين 0 و 1 (هي أصلاً احتمالية)
                    score_mc = mc_res.get('mc_prob_gain', 0.5)
                 except Exception:
                    score_mc = 0.5 # القيمة المحايدة في حال الفشل

            # --- 2. تطبيق المعادلة الهجينة (The Hybrid Formula) ---
            # Titan (50%) + Patterns (40%) + MC (10%)
            hybrid_score = (score_titan * 0.50) + (score_patterns * 0.40) + (score_mc * 0.10)

            # تجميع النتيجة النهائية
            analysis_result = {
                'symbol': symbol,
                'current_price': raw_data.get('current_price', 0.0),
                'enhanced_final_score': hybrid_score, # الدرجة النهائية المعتمدة
                
                # تفاصيل للشفافية (Audit Trail)
                'components': {
                    'titan_score': score_titan,
                    'patterns_score': score_patterns,
                    'mc_score': score_mc
                },
                'titan_details': titan_res,
                'pattern_details': pattern_res.get('details', {}),
                
                # عينة بيانات للحارس
                'ohlcv_sample': {tf: data[-1] for tf, data in ohlcv_data.items() if data}
            }

            return analysis_result

        except Exception as e:
            print(f"❌ [Processor] خطأ كارثي في معالجة {symbol} (خارج النطاق المحمي): {e}")
            traceback.print_exc()
            return None

print("✅ ML Processor V12.4 (Hybrid Core) loaded with robust error handling.")