Update app.py

app.py

@@ -13,13 +13,14 @@ from datetime import datetime
 from r2 import R2Service
 from LLM import LLMService
 from data_manager import DataManager
-from ML import MLProcessor as FeatureProcessor
+from ML import MLProcessor
 from learning_engine import LearningEngine
 from sentiment_news import SentimentAnalyzer
 from trade_manager import TradeManager
 import state
-from helpers import safe_float_conversion, _apply_patience_logic, local_analyze_opportunity, local_re_analyze_trade, validate_candidate_data_enhanced
+from helpers import safe_float_conversion, validate_candidate_data_enhanced
 
+# المتغيرات العامة
 r2_service_global = None
 data_manager_global = None
 llm_service_global = None
@@ -57,7 +58,7 @@ class StateManager:
 state_manager = StateManager()
 
 async def monitor_market_async():
-    """مراقبة السوق بدون نظام الحيتان العام"""
+    """مراقبة السوق"""
     global data_manager_global, sentiment_analyzer_global
     
     if not await state_manager.wait_for_initialization():
@@ -95,354 +96,164 @@ async def monitor_market_async():
             state.MARKET_STATE_OK = True
             await asyncio.sleep(60)
 
-async def analyze_market_strategy(market_context):
-    """تحليل استراتيجية السوق بدون اعتماد على الحيتان العامة"""
+async def run_3_layer_analysis():
+    """
+    تشغيل النظام الطبقي المكون من 3 طبقات:
+    الطبقة 1: data_manager - الفحص السريع
+    الطبقة 2: MLProcessor - التحليل المتقدم  
+    الطبقة 3: LLMService - النموذج الضخم
+    """
     try:
-        prompt = f"Analyze current market conditions and determine trading strategy.\n\nMarket Data:\n- BTC Sentiment: {market_context.get('btc_sentiment')}\n- Fear & Greed Index: {market_context.get('fear_and_greed_index')}\n\nOutput JSON:\n{{\"primary_strategy\": \"STRATEGY_NAME\",\"reasoning\": \"Brief reasoning\",\"risk_tolerance\": 5,\"optimal_scan_count\": 100}}"
-        response = await llm_service_global._call_llm(prompt)
-        try:
-            from helpers import parse_json_from_response
-            json_str = parse_json_from_response(response)
-            strategy_data = json.loads(json_str)
-        except:
-            strategy_data = {
-                "primary_strategy": "GENERIC",
-                "reasoning": "Fallback strategy due to analysis error",
-                "risk_tolerance": 5,
-                "optimal_scan_count": 100
-            }
-        return strategy_data
-    except Exception as error:
-        print(f"❌ فشل تحليل استراتيجية السوق: {error}")
-        return {
-            "primary_strategy": "GENERIC",
-            "reasoning": "Fallback due to analysis error",
-            "risk_tolerance": 5,
-            "optimal_scan_count": 100
-        }
-
-async def find_strategy_specific_candidates(strategy, scan_count):
-    """البحث عن مرشحين متوافقين مع الاستراتيجية"""
-    try:
-        all_candidates = await data_manager_global.find_high_potential_candidates(scan_count * 2)
-        if not all_candidates: 
-            return []
-            
-        market_context = await data_manager_global.get_market_context_async()
-        if not market_context: 
-            return []
-            
-        feature_processor = FeatureProcessor(market_context, data_manager_global, learning_engine_global)
-        processed_candidates = []
+        print("🎯 بدء النظام الطبقي المكون من 3 طبقات...")
         
-        for candidate in all_candidates[:30]:
-            try:
-                symbol_with_reasons = [{'symbol': candidate['symbol'], 'reasons': candidate.get('reasons', [])}]
-                ohlcv_data = await data_manager_global.get_fast_pass_data_async(symbol_with_reasons)
-                if ohlcv_data and ohlcv_data[0]:
-                    processed = await feature_processor.process_and_score_symbol_enhanced(ohlcv_data[0])
-                    if processed: 
-                        processed_candidates.append(processed)
-            except Exception as e: 
-                print(f"❌ Failed to process {candidate.get('symbol')}: {e}")
-                
-        if not processed_candidates: 
-            return []
-            
-        if strategy != 'GENERIC':
-            strategy_candidates = []
-            for candidate in processed_candidates:
-                base_scores = candidate.get('base_strategy_scores', {})
-                strategy_score = base_scores.get(strategy, 0)
-                if strategy_score > 0.2:
-                    candidate['strategy_match_score'] = strategy_score
-                    strategy_candidates.append(candidate)
-            sorted_candidates = sorted(strategy_candidates, key=lambda x: x.get('strategy_match_score', 0), reverse=True)
-            top_candidates = sorted_candidates[:15]
-        else:
-            sorted_candidates = sorted(processed_candidates, key=lambda x: x.get('enhanced_final_score', 0), reverse=True)
-            top_candidates = sorted_candidates[:15]
-            
-        return top_candidates
-    except Exception as error:
-        print(f"❌ Advanced filtering failed: {error}")
-        return []
+        if not await state_manager.wait_for_initialization():
+            print("❌ الخدمات غير مهيأة بالكامل")
+            return None
 
-async def enhanced_llm_analysis_with_whale_data(candidate):
-    """تحليل محسن يشمل بيانات حيتان للمرشحين النهائيين"""
-    global symbol_whale_monitor_global
-    
-    try:
-        print(f"🧠 بدء التحليل المتقدم لـ {candidate['symbol']}...")
+        # الطبقة 1: الفحص السريع لجميع العملات
+        print("\n🔍 الطبقة 1: الفحص السريع (data_manager)...")
+        layer1_candidates = await data_manager_global.layer1_rapid_screening()
         
-        # 1. الحصول على تحليل النموذج الضخم الأساسي
-        llm_analysis = await llm_service_global.get_trading_decision(candidate)
-        if not llm_analysis:
-            print(f"❌ فشل التحليل الأساسي لـ {candidate['symbol']}")
+        if not layer1_candidates:
+            print("❌ لم يتم العثور على مرشحين في الطبقة 1")
             return None
         
-        # 2. إضافة بيانات الحيتان للمرشحين النهائيين فقط
-        print(f"🐋 جلب بيانات الحيتان لـ {candidate['symbol']}...")
-        whale_analysis = await symbol_whale_monitor_global.get_symbol_whale_activity(
-            candidate['symbol'],
-            candidate.get('contract_address')
-        )
-        
-        # 3. دمج النتائج
-        enhanced_analysis = {
-            **llm_analysis,
-            'whale_analysis': whale_analysis.get('llm_friendly_summary', {}),
-            'combined_confidence': await calculate_combined_confidence(
-                llm_analysis.get('confidence_level', 0.5),
-                whale_analysis.get('trading_signal', {}).get('confidence', 0.5)
-            ),
-            'analysis_timestamp': datetime.now().isoformat(),
-            'analysis_source': 'enhanced_with_whale_data'
-        }
-        
-        # 4. تطبيق قواعد السلامة بناء على نشاط الحيتان
-        if whale_analysis.get('trading_signal', {}).get('critical_alert'):
-            enhanced_analysis = apply_whale_safety_filters(enhanced_analysis, whale_analysis)
-        
-        print(f"✅ اكتمل التحليل المتقدم لـ {candidate['symbol']}")
-        return enhanced_analysis
-        
-    except Exception as error:
-        print(f"❌ خطأ في التحليل المتقدم لـ {candidate.get('symbol')}: {error}")
-        # العودة للتحليل الأساسي في حالة الخطأ
-        return await llm_service_global.get_trading_decision(candidate)
-
-async def calculate_combined_confidence(llm_confidence, whale_confidence):
-    """حساب الثقة المجمعة مع إعطاء وزن أكبر لبيانات الحيتان"""
-    combined = (llm_confidence * 0.4) + (whale_confidence * 0.6)
-    return min(combined, 0.95)
+        print(f"✅ تم اختيار {len(layer1_candidates)} عملة للطبقة 2")
 
-def apply_whale_safety_filters(analysis, whale_analysis):
-    """تطبيق فلاتر السلامة بناء على نشاط الحيتان الحرج"""
-    
-    whale_signal = whale_analysis.get('trading_signal', {})
-    
-    if whale_signal.get('action') in ['STRONG_SELL', 'SELL']:
-        if analysis.get('action') == 'BUY':
-            analysis.update({
-                'action': 'HOLD',
-                'reasoning': f"{analysis.get('reasoning', '')} | تصحيح بسبب نشاط الحيتان: {whale_signal.get('reason', '')}",
-                'confidence_level': analysis.get('confidence_level', 0.5) * 0.7
-            })
-        elif analysis.get('action') == 'HOLD':
-            analysis['confidence_level'] = analysis.get('confidence_level', 0.5) * 0.9
-    
-    elif whale_signal.get('action') in ['STRONG_BUY', 'BUY']:
-        if analysis.get('action') == 'BUY':
-            analysis['confidence_level'] = min(analysis.get('confidence_level', 0.5) * 1.2, 0.95)
-            analysis['reasoning'] = f"{analysis.get('reasoning', '')} | تعزيز بسبب نشاط الحيتان الإيجابي"
-    
-    return analysis
+        # جلب بيانات OHLCV كاملة للمرشحين
+        layer1_symbols = [candidate['symbol'] for candidate in layer1_candidates]
+        ohlcv_data_list = await data_manager_global.get_ohlcv_data_for_symbols(layer1_symbols)
+        
+        if not ohlcv_data_list:
+            print("❌ فشل جلب بيانات OHLCV للمرشحين")
+            return None
 
-async def find_new_opportunities_async():
-    """البحث عن فرص تداول جديدة مع دمج بيانات الحيتان للمرشحين النهائيين"""
-    try:
-        print("🎯 بدء البحث عن فرص تداول جديدة...")
-        await r2_service_global.save_system_logs_async({"opportunity_scan_started": True})
+        # الطبقة 2: التحليل المتقدم
+        print("\n📈 الطبقة 2: التحليل المتقدم (MLProcessor)...")
         market_context = await data_manager_global.get_market_context_async()
-        if not market_context: 
-            print("❌ فشل جلب سياق السوق")
-            return
-            
-        strategy_decision = await analyze_market_strategy(market_context)
-        print(f"📊 استراتيجية السوق: {strategy_decision['primary_strategy']}")
         
-        high_potential_candidates = await find_strategy_specific_candidates(
-            strategy_decision['primary_strategy'], 
-            strategy_decision.get('optimal_scan_count', 100)
-        )
+        # إنشاء معالج ML
+        ml_processor = MLProcessor(market_context, data_manager_global, learning_engine_global)
         
-        if not high_potential_candidates:
-            print("⚠️ لم يتم العثور على مرشحين متوافقين مع الاستراتيجية، البحث عن مرشحين عامين")
-            high_potential_candidates = await data_manager_global.find_high_potential_candidates(20)
-            if high_potential_candidates:
-                for candidate in high_potential_candidates: 
-                    candidate['target_strategy'] = 'GENERIC'
-            else: 
-                print("❌ لم يتم العثور على أي مرشحين")
-                return
+        # معالجة كل مرشح باستخدام ML
+        layer2_candidates = []
+        for ohlcv_data in ohlcv_data_list:
+            try:
+                # إضافة أسباب الترشيح من الطبقة 1
+                symbol = ohlcv_data['symbol']
+                layer1_candidate = next((c for c in layer1_candidates if c['symbol'] == symbol), None)
+                if layer1_candidate:
+                    ohlcv_data['reasons_for_candidacy'] = layer1_candidate.get('reasons', [])
+                    ohlcv_data['layer1_score'] = layer1_candidate.get('layer1_score', 0)
                 
-        print(f"✅ تم العثور على {len(high_potential_candidates)} مرشح محتمل")
-        
-        all_processed_candidates = []
-        CHUNK_SIZE = 5
+                # التحليل المتقدم باستخدام ML
+                analyzed_data = await ml_processor.process_and_score_symbol_enhanced(ohlcv_data)
+                if analyzed_data and analyzed_data.get('enhanced_final_score', 0) > 0.4:
+                    layer2_candidates.append(analyzed_data)
+                    
+            except Exception as e:
+                print(f"❌ خطأ في تحليل {ohlcv_data.get('symbol')}: {e}")
+                continue
         
-        for index in range(0, len(high_potential_candidates), CHUNK_SIZE):
-            chunk = high_potential_candidates[index:index+CHUNK_SIZE]
-            print(f"🔍 معالجة مجموعة {index//CHUNK_SIZE + 1} من {len(high_potential_candidates)//CHUNK_SIZE + 1}")
-            chunk_data = await data_manager_global.get_fast_pass_data_async(chunk)
-            updated_market_context = await data_manager_global.get_market_context_async()
-            if not updated_market_context: 
-                updated_market_context = market_context
-                
-            feature_processor = FeatureProcessor(updated_market_context, data_manager_global, learning_engine_global)
-            processed_chunk = await asyncio.gather(*[
-                feature_processor.process_and_score_symbol_enhanced(data) for data in chunk_data
-            ])
-            all_processed_candidates.extend([c for c in processed_chunk if c is not None])
-            print(f"✅ تم معالجة {len([c for c in processed_chunk if c is not None])} مرشح في هذه المجموعة")
-            await asyncio.sleep(1)
-            
-        if not all_processed_candidates: 
-            print("❌ فشل معالجة أي مرشح")
-            return
-            
-        print(f"📊 إجمالي المرشحين المعالجين: {len(all_processed_candidates)}")
+        if not layer2_candidates:
+            print("❌ لم يتم العثور على مرشحين في الطبقة 2")
+            return None
         
-        updated_market_context = await data_manager_global.get_market_context_async()
-        if not updated_market_context: 
-            updated_market_context = market_context
-            
-        feature_processor = FeatureProcessor(updated_market_context, data_manager_global, learning_engine_global)
-        OPPORTUNITY_COUNT = 10
-        top_candidates = feature_processor.filter_top_candidates(all_processed_candidates, OPPORTUNITY_COUNT)
+        # ترتيب المرشحين حسب الدرجة المحسنة
+        layer2_candidates.sort(key=lambda x: x.get('enhanced_final_score', 0), reverse=True)
         
-        print(f"🎖️ أفضل {len(top_candidates)} مرشح:")
-        for i, candidate in enumerate(top_candidates):
-            score = candidate.get('enhanced_final_score', 0)
-            print(f"   {i+1}. {candidate['symbol']}: {score:.3f}")
+        # أخذ أفضل 9-20 مرشح للطبقة 3
+        target_count = min(max(9, len(layer2_candidates) // 2), 20)
+        final_layer2_candidates = layer2_candidates[:target_count]
         
-        await r2_service_global.save_candidates_data_async(
-            candidates_data=top_candidates, 
-            reanalysis_data={
-                "strategy_used": strategy_decision, 
-                "market_conditions": market_context
-            }
-        )
+        print(f"✅ تم اختيار {len(final_layer2_candidates)} عملة للطبقة 3")
+
+        # الطبقة 3: التحليل بالنموذج الضخم
+        print("\n🧠 الطبقة 3: التحليل بالنموذج الضخم (LLMService)...")
+        final_opportunities = []
         
-        if not top_candidates: 
-            print("❌ لا توجد مرشحات نهائية")
-            return
-            
-        print("🤖 بدء تحليل النموذج الضخم المحسن للمرشحين...")
-        for candidate in top_candidates:
+        for candidate in final_layer2_candidates:
             try:
-                if not validate_candidate_data_enhanced(candidate): 
-                    print(f"⚠️ تخطي {candidate['symbol']} - بيانات غير صالحة")
-                    continue
-                    
-                print(f"🧠 تحليل متقدم لـ {candidate['symbol']}...")
+                print(f"   🤔 تحليل {candidate['symbol']} بالنموذج الضخم...")
                 
-                # استخدام التحليل المحسن ببيانات الحيتان
-                llm_analysis_data = await enhanced_llm_analysis_with_whale_data(candidate)
-                if not llm_analysis_data: 
-                    print(f"⚠️ فشل التحليل المتقدم لـ {candidate['symbol']}")
-                    continue
-                    
-                if llm_analysis_data.get('action') == "HOLD": 
-                    print(f"⏸️ النموذج يوصي بالانتظار لـ {candidate['symbol']}")
-                    continue
-                    
-                if llm_analysis_data.get('action') in ["BUY", "SELL"]:
-                    final_strategy = llm_analysis_data.get('strategy')
-                    candidate_strategy = candidate.get('target_strategy', 'GENERIC')
-                    if not final_strategy or final_strategy == 'unknown': 
-                        final_strategy = candidate_strategy
-                        llm_analysis_data['strategy'] = final_strategy
-                        
-                    await r2_service_global.save_system_logs_async({
-                        "new_opportunity_found": True, 
-                        "symbol": candidate['symbol'],
-                        "action": llm_analysis_data.get('action'), 
-                        "strategy": final_strategy,
-                        "with_whale_analysis": True,
-                        "combined_confidence": llm_analysis_data.get('combined_confidence', 0.5)
-                    })
-                    
-                    print(f"🎯 فرصة تداول مثبتة: {candidate['symbol']} - {llm_analysis_data.get('action')} - {final_strategy}")
-                    print(f"   📊 الثقة المجمعة: {llm_analysis_data.get('combined_confidence', 0.5):.2f}")
-                    
-                    return {
-                        "symbol": candidate['symbol'],
-                        "decision": llm_analysis_data,
-                        "current_price": candidate['current_price'],
-                        "strategy": final_strategy
+                # إرسال كل عملة للنموذج الضخم على حدة
+                llm_analysis = await llm_service_global.get_trading_decision(candidate)
+                
+                if llm_analysis and llm_analysis.get('action') in ['BUY', 'SELL']:
+                    opportunity = {
+                        'symbol': candidate['symbol'],
+                        'current_price': candidate.get('current_price', 0),
+                        'decision': llm_analysis,
+                        'enhanced_score': candidate.get('enhanced_final_score', 0),
+                        'llm_confidence': llm_analysis.get('confidence_level', 0),
+                        'strategy': llm_analysis.get('strategy', 'GENERIC'),
+                        'analysis_timestamp': datetime.now().isoformat()
                     }
-            except Exception as error: 
-                print(f"❌ خطأ في التحليل المتقدم لـ {candidate.get('symbol', 'unknown')}: {error}")
-                continue
+                    final_opportunities.append(opportunity)
+                    
+                    print(f"   ✅ {candidate['symbol']}: {llm_analysis.get('action')} - ثقة: {llm_analysis.get('confidence_level', 0):.2f}")
                 
-        print("❌ لم يتم العثور على فرص تداول مناسبة")
-        return None
+            except Exception as e:
+                print(f"❌ خطأ في تحليل النموذج الضخم لـ {candidate.get('symbol')}: {e}")
+                continue
+        
+        if not final_opportunities:
+            print("❌ لم يتم العثور على فرص تداول مناسبة")
+            return None
+        
+        # ترتيب الفرص النهائية حسب الثقة والدرجة
+        final_opportunities.sort(key=lambda x: (x['llm_confidence'] + x['enhanced_score']) / 2, reverse=True)
+        
+        print(f"\n🏆 النظام الطبقي اكتمل: {len(final_opportunities)} فرصة تداول")
+        for i, opportunity in enumerate(final_opportunities[:5]):
+            print(f"   {i+1}. {opportunity['symbol']}: {opportunity['decision'].get('action')} - ثقة: {opportunity['llm_confidence']:.2f}")
+        
+        return final_opportunities[0] if final_opportunities else None
+        
     except Exception as error:
-        print(f"❌ Error while scanning for opportunities: {error}")
-        await r2_service_global.save_system_logs_async({
-            "opportunity_scan_error": True, 
-            "error": str(error)
-        })
+        print(f"❌ خطأ في النظام الطبقي: {error}")
+        import traceback
+        traceback.print_exc()
         return None
 
 async def re_analyze_open_trade_async(trade_data):
+    """إعادة تحليل الصفقة المفتوحة"""
     symbol = trade_data.get('symbol')
     try:
         async with state_manager.trade_analysis_lock:
-            entry_time = datetime.fromisoformat(trade_data['entry_timestamp'])
-            current_time = datetime.now()
-            hold_minutes = (current_time - entry_time).total_seconds() / 60
+            # جلب البيانات الحالية
+            market_context = await data_manager_global.get_market_context_async()
+            ohlcv_data_list = await data_manager_global.get_ohlcv_data_for_symbols([symbol])
             
-            original_strategy = trade_data.get('strategy')
-            if not original_strategy or original_strategy == 'unknown': 
-                original_strategy = trade_data.get('decision_data', {}).get('strategy', 'GENERIC')
-                
-            try: 
-                market_context = await data_manager_global.get_market_context_async()
-            except Exception: 
-                market_context = {'btc_sentiment': 'NEUTRAL'}
-                
-            symbol_with_reasons = [{'symbol': symbol, 'reasons': ['re-analysis']}]
-            ohlcv_data_list = await data_manager_global.get_fast_pass_data_async(symbol_with_reasons)
-            if not ohlcv_data_list: 
+            if not ohlcv_data_list:
                 return None
                 
-            raw_data = ohlcv_data_list[0]
-            try:
-                updated_market_context = await data_manager_global.get_market_context_async()
-                if updated_market_context: 
-                    market_context = updated_market_context
-            except Exception: 
-                pass
-                
-            feature_processor = FeatureProcessor(market_context, data_manager_global, learning_engine_global)
-            processed_data = await feature_processor.process_and_score_symbol(raw_data)
-            if not processed_data: 
+            ohlcv_data = ohlcv_data_list[0]
+            ohlcv_data['reasons_for_candidacy'] = ['re-analysis']
+            
+            # استخدام ML للتحليل
+            ml_processor = MLProcessor(market_context, data_manager_global, learning_engine_global)
+            processed_data = await ml_processor.process_and_score_symbol_enhanced(ohlcv_data)
+            
+            if not processed_data:
                 return None
-                
-            await r2_service_global.save_candidates_data_async(
-                candidates_data=None, 
-                reanalysis_data={
-                    'market_context': market_context, 
-                    'processed_data': processed_data
-                }
-            )
             
-            try: 
-                re_analysis_decision = await llm_service_global.re_analyze_trade_async(trade_data, processed_data)
-            except Exception: 
-                re_analysis_decision = local_re_analyze_trade(trade_data, processed_data)
-                
-            final_decision = _apply_patience_logic(re_analysis_decision, hold_minutes, trade_data, processed_data)
-            if not final_decision.get('strategy'): 
-                final_decision['strategy'] = original_strategy
-                
+            # استخدام LLM لإعادة التحليل
+            re_analysis_decision = await llm_service_global.re_analyze_trade_async(trade_data, processed_data)
+            
             await r2_service_global.save_system_logs_async({
                 "trade_reanalyzed": True, 
                 "symbol": symbol, 
-                "action": final_decision.get('action'),
-                "hold_minutes": hold_minutes, 
-                "strategy": final_decision.get('strategy')
+                "action": re_analysis_decision.get('action'),
+                "strategy": re_analysis_decision.get('strategy', 'GENERIC')
             })
             
             return {
                 "symbol": symbol, 
-                "decision": final_decision,
-                "current_price": processed_data.get('current_price'), 
-                "hold_minutes": hold_minutes
+                "decision": re_analysis_decision,
+                "current_price": processed_data.get('current_price')
             }
+            
     except Exception as error:
         print(f"❌ Error during trade re-analysis: {error}")
         await r2_service_global.save_system_logs_async({
@@ -453,6 +264,7 @@ async def re_analyze_open_trade_async(trade_data):
         return None
 
 async def run_bot_cycle_async():
+    """دورة التداول الرئيسية"""
     try:
         if not await state_manager.wait_for_initialization():
             print("❌ الخدمات غير مهيأة بالكامل - تخطي الدورة")
@@ -465,31 +277,20 @@ async def run_bot_cycle_async():
             print("❌ فشل الحصول على القفل - تخطي الدورة")
             return
             
-        open_trades = []
         try:
             open_trades = await trade_manager_global.get_open_trades()
             print(f"📋 الصفقات المفتوحة: {len(open_trades)}")
             
-            trades_fixed = 0
-            for trade in open_trades:
-                if not trade.get('strategy') or trade['strategy'] == 'unknown':
-                    original_strategy = trade.get('decision_data', {}).get('strategy', 'GENERIC')
-                    trade['strategy'] = original_strategy
-                    trades_fixed += 1
-                    
-            if trades_fixed > 0: 
-                await r2_service_global.save_open_trades_async(open_trades)
-                print(f"✅ تم إصلاح {trades_fixed} صفقة")
-                
-            should_look_for_new_trade = not open_trades
-            print(f"🔍 البحث عن صفقات جديدة: {should_look_for_new_trade}")
+            should_look_for_new_trade = len(open_trades) == 0
             
+            # إعادة تحليل الصفقات المفتوحة
             if open_trades:
                 now = datetime.now()
                 trades_to_reanalyze = [
                     trade for trade in open_trades 
                     if now >= datetime.fromisoformat(trade.get('expected_target_time', now.isoformat()))
                 ]
+                
                 if trades_to_reanalyze:
                     print(f"🔄 إعادة تحليل {len(trades_to_reanalyze)} صفقة")
                     for trade in trades_to_reanalyze:
@@ -499,46 +300,36 @@ async def run_bot_cycle_async():
                             should_look_for_new_trade = True
                         elif result and result['decision'].get('action') == "UPDATE_TRADE": 
                             await trade_manager_global.update_trade(trade, result['decision'])
-                            
+            
+            # البحث عن صفقات جديدة إذا لزم الأمر
             if should_look_for_new_trade:
                 portfolio_state = await r2_service_global.get_portfolio_state_async()
                 current_capital = portfolio_state.get("current_capital_usd", 0)
-                print(f"💰 رأس المال المتاح: ${current_capital:.2f}")
                 
-                if current_capital <= 0:
-                    if len(open_trades) == 0:
-                        initial_capital = portfolio_state.get("initial_capital_usd", 10.0)
-                        if initial_capital > 0:
-                            portfolio_state["current_capital_usd"] = initial_capital
-                            portfolio_state["invested_capital_usd"] = 0.0
-                            await r2_service_global.save_portfolio_state_async(portfolio_state)
-                            current_capital = initial_capital
-                            print(f"🔄 إعادة تعيين رأس المال إلى ${initial_capital:.2f}")
-                            
                 if current_capital > 1:
                     print("🎯 البحث عن فرص تداول جديدة...")
-                    new_opportunity = await find_new_opportunities_async()
-                    if new_opportunity:
-                        if not new_opportunity['decision'].get('strategy'): 
-                            new_opportunity['decision']['strategy'] = new_opportunity.get('strategy', 'GENERIC')
-                            
-                        print(f"✅ فتح صفقة جديدة: {new_opportunity['symbol']}")
+                    best_opportunity = await run_3_layer_analysis()
+                    
+                    if best_opportunity:
+                        print(f"✅ فتح صفقة جديدة: {best_opportunity['symbol']}")
                         await trade_manager_global.open_trade(
-                            new_opportunity['symbol'], 
-                            new_opportunity['decision'], 
-                            new_opportunity['current_price']
+                            best_opportunity['symbol'], 
+                            best_opportunity['decision'], 
+                            best_opportunity['current_price']
                         )
                     else:
                         print("❌ لم يتم العثور على فرص تداول مناسبة")
                 else:
                     print("❌ رأس المال غير كافي لفتح صفقات جديدة")
+                    
         finally:
             r2_service_global.release_lock()
             await r2_service_global.save_system_logs_async({
                 "cycle_completed": True, 
-                "open_trades": len(open_trades)
+                "open_trades": len(open_trades) if 'open_trades' in locals() else 0
             })
             print("✅ اكتملت دورة التداول")
+            
     except Exception as error:
         print(f"❌ Unhandled error in main cycle: {error}")
         await r2_service_global.save_system_logs_async({
@@ -550,53 +341,48 @@ async def run_bot_cycle_async():
 
 @asynccontextmanager
 async def lifespan(application: FastAPI):
-    global r2_service_global, data_manager_global, llm_service_global, learning_engine_global, trade_manager_global, sentiment_analyzer_global, symbol_whale_monitor_global
+    """إدارة دورة حياة التطبيق"""
+    global r2_service_global, data_manager_global, llm_service_global, learning_engine_global
+    global trade_manager_global, sentiment_analyzer_global, symbol_whale_monitor_global
     
     initialization_successful = False
     try:
         print("🚀 بدء تهيئة التطبيق...")
         
+        # تهيئة الخدمات
         r2_service_global = R2Service()
         state_manager.set_service_initialized('r2_service')
-        print("✅ R2 Service initialized")
 
         contracts_database = await r2_service_global.load_contracts_db_async()
-        print("✅ Contracts database loaded")
 
         from whale_news_data import EnhancedWhaleMonitor
         symbol_whale_monitor_global = EnhancedWhaleMonitor(contracts_database, r2_service_global)
         state_manager.set_service_initialized('symbol_whale_monitor')
-        print("✅ Symbol Specific Whale Monitor initialized")
 
         data_manager_global = DataManager(contracts_database, symbol_whale_monitor_global)
         await data_manager_global.initialize()
         state_manager.set_service_initialized('data_manager')
-        print("✅ Data Manager initialized")
 
         llm_service_global = LLMService()
         state_manager.set_service_initialized('llm_service')
-        print("✅ LLM Service initialized")
 
         sentiment_analyzer_global = SentimentAnalyzer(data_manager_global)
         state_manager.set_service_initialized('sentiment_analyzer')
-        print("✅ Sentiment Analyzer initialized")
 
         learning_engine_global = LearningEngine(r2_service_global, data_manager_global)
         await learning_engine_global.initialize_enhanced()
-        await learning_engine_global.force_strategy_learning()
         state_manager.set_service_initialized('learning_engine')
-        print("✅ Learning Engine initialized")
 
         trade_manager_global = TradeManager(r2_service_global, learning_engine_global, data_manager_global)
         state_manager.set_service_initialized('trade_manager')
-        print("✅ Trade Manager initialized")
 
+        # بدء المهام الخلفية
         asyncio.create_task(monitor_market_async())
         asyncio.create_task(trade_manager_global.start_trade_monitoring())
         
         await r2_service_global.save_system_logs_async({"application_started": True})
         initialization_successful = True
-        print("🎯 التطبيق جاهز للعمل")
+        print("🎯 التطبيق جاهز للعمل - نظام الطبقات 3 فعال")
         
         yield
         
@@ -615,91 +401,51 @@ application = FastAPI(lifespan=lifespan)
 
 @application.get("/run-cycle")
 async def run_cycle_api():
+    """تشغيل دورة التداول"""
     if not state_manager.initialization_complete:
         raise HTTPException(status_code=503, detail="الخدمات غير مهيأة بالكامل")
     asyncio.create_task(run_bot_cycle_async())
-    return {"message": "Bot cycle initiated"}
+    return {"message": "Bot cycle initiated", "system": "3-Layer Analysis"}
 
 @application.get("/health")
 async def health_check():
-    learning_metrics = {}
-    if learning_engine_global and learning_engine_global.initialized: 
-        learning_metrics = await learning_engine_global.calculate_performance_metrics()
-        
-    api_stats = {}
-    if data_manager_global: 
-        api_stats = data_manager_global.get_performance_stats()
-        
-    return {
+    """فحص صحة النظام"""
+    services_status = {
         "status": "healthy" if state_manager.initialization_complete else "initializing",
         "initialization_complete": state_manager.initialization_complete,
         "services_initialized": state_manager.services_initialized,
-        "timestamp": datetime.now().isoformat(), 
-        "services": {
-            "r2_service": "initialized" if r2_service_global else "uninitialized",
-            "llm_service": "initialized" if llm_service_global else "uninitialized",
-            "data_manager": "initialized" if data_manager_global else "uninitialized",
-            "learning_engine": "active" if learning_engine_global and learning_engine_global.initialized else "inactive",
-            "trade_manager": "active" if trade_manager_global else "inactive",
-            "symbol_whale_monitor": "active" if symbol_whale_monitor_global else "inactive"
-        }, 
-        "market_state_ok": state.MARKET_STATE_OK, 
-        "learning_engine": learning_metrics
-    }
-
-@application.get("/stats")
-async def get_performance_stats():
-    try:
-        if not state_manager.initialization_complete:
-            raise HTTPException(status_code=503, detail="الخدمات غير مهيأة بالكامل")
-
-        market_context = await data_manager_global.get_market_context_async() if data_manager_global else {}
-        learning_stats = {}
-        if learning_engine_global and learning_engine_global.initialized: 
-            learning_stats = await learning_engine_global.calculate_performance_metrics()
-            
-        api_stats = {}
-        if data_manager_global: 
-            api_stats = data_manager_global.get_performance_stats()
-            
-        stats = {
-            "timestamp": datetime.now().isoformat(), 
-            "data_manager": api_stats, 
-            "market_state": {
-                "is_healthy": state.MARKET_STATE_OK, 
-                "context": market_context
-            }, 
-            "trade_monitoring": {
-                "active_trades": len(trade_manager_global.monitoring_tasks) if trade_manager_global else 0,
-                "is_running": trade_manager_global.is_running if trade_manager_global else False
-            }, 
-            "learning_engine": learning_stats,
-            "whale_monitoring": {
-                "symbol_specific_active": symbol_whale_monitor_global is not None,
-                "monitoring_type": "TARGETED_NETWORK_ONLY"
-            }
+        "timestamp": datetime.now().isoformat(),
+        "system_architecture": "3-Layer Analysis System",
+        "layers": {
+            "layer1": "Data Manager - Rapid Screening",
+            "layer2": "ML Processor - Advanced Analysis", 
+            "layer3": "LLM Service - Deep Analysis"
         }
-        return stats
-    except Exception as error: 
-        raise HTTPException(status_code=500, detail=f"Failed to retrieve stats: {str(error)}")
+    }
+    return services_status
 
-@application.get("/logs/status")
-async def get_logs_status():
-    try:
-        open_trades = await r2_service_global.get_open_trades_async()
-        portfolio_state = await r2_service_global.get_portfolio_state_async()
+@application.get("/analyze-market")
+async def analyze_market_api():
+    """تشغيل التحليل الطبقي فقط"""
+    if not state_manager.initialization_complete:
+        raise HTTPException(status_code=503, detail="الخدمات غير مهيأة بالكامل")
+    
+    result = await run_3_layer_analysis()
+    if result:
         return {
-            "logging_system": "active", 
-            "open_trades_count": len(open_trades),
-            "current_capital": portfolio_state.get("current_capital_usd", 0),
-            "total_trades": portfolio_state.get("total_trades", 0),
-            "timestamp": datetime.now().isoformat()
+            "opportunity_found": True,
+            "symbol": result['symbol'],
+            "action": result['decision'].get('action'),
+            "confidence": result['llm_confidence'],
+            "strategy": result['strategy']
         }
-    except Exception as error: 
-        raise HTTPException(status_code=500, detail=f"Failed to get logs status: {str(error)}")
+    else:
+        return {"opportunity_found": False, "message": "No suitable opportunities found"}
 
 async def cleanup_on_shutdown():
-    global r2_service_global, data_manager_global, trade_manager_global, learning_engine_global, symbol_whale_monitor_global
+    """تنظيف الموارد عند الإغلاق"""
+    global r2_service_global, data_manager_global, trade_manager_global, learning_engine_global
+    
     print("🛑 Shutdown signal received. Cleaning up...")
     
     if trade_manager_global: 
@@ -718,10 +464,6 @@ async def cleanup_on_shutdown():
         await data_manager_global.close()
         print("✅ Data manager closed")
         
-    if symbol_whale_monitor_global:
-        await symbol_whale_monitor_global.cleanup()
-        print("✅ Symbol whale monitor cleaned up")
-        
     if r2_service_global:
         try: 
             await r2_service_global.save_system_logs_async({"application_shutdown": True})
@@ -734,6 +476,7 @@ async def cleanup_on_shutdown():
             print("✅ R2 lock released")
 
 def signal_handler(signum, frame):
+    """معالج إشارات الإغلاق"""
     asyncio.create_task(cleanup_on_shutdown())
     sys.exit(0)