Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py - الإصدار المحدث مع إصلاح مشاكل إغلاق الاتصالات
+# app.py - الإصدار النهائي مع منطق إيقاف تداول معاير وإدارة محسنة للاتصالات
 import os
 import traceback
 import signal
@@ -19,9 +19,7 @@ import state
 import re
 
 # إعدادات النظام
-TOP_N_SYMBOLS = 100
 OPPORTUNITY_COUNT = 10
-CHUNK_SIZE = 5
 
 # المتغيرات العامة للنظام
 r2_service_global = None
@@ -35,16 +33,13 @@ class RealTimeTradeMonitor:
     def __init__(self):
         self.monitoring_tasks = {}
         self.is_running = False
-        
+
     async def start_monitoring(self):
-        """بدء مراقبة جميع الصفقات المفتوحة"""
         self.is_running = True
         print("🔍 Starting real-time trade monitoring...")
-        
         while self.is_running:
             try:
                 open_trades = await r2_service_global.get_open_trades_async()
-                
                 for trade in open_trades:
                     symbol = trade['symbol']
                     if symbol not in self.monitoring_tasks:
@@ -55,19 +50,15 @@ class RealTimeTradeMonitor:
                 for symbol in list(self.monitoring_tasks.keys()):
                     if symbol not in current_symbols:
                         del self.monitoring_tasks[symbol]
-                
                 await asyncio.sleep(10)
-                
             except Exception as error:
                 print(f"❌ Real-time monitor error: {error}")
                 await asyncio.sleep(30)
-    
+
     async def _monitor_single_trade(self, trade):
-        """مراقبة صفقة فردية في الوقت الحقيقي"""
         symbol = trade['symbol']
         strategy = trade.get('strategy', 'GENERIC')
         print(f"📊 Starting real-time monitoring for {symbol} (Strategy: {strategy})")
-        
         while symbol in self.monitoring_tasks and self.is_running:
             try:
                 current_price = await data_manager_global.get_latest_price_async(symbol)
@@ -83,864 +74,297 @@ class RealTimeTradeMonitor:
                 close_reason = ""
                 
                 if stop_loss and current_price <= stop_loss:
-                    should_close = True
-                    close_reason = f"Stop loss hit: {current_price} <= {stop_loss}"
+                    should_close, close_reason = True, f"Stop loss hit: {current_price} <= {stop_loss}"
                 elif take_profit and current_price >= take_profit:
-                    should_close = True
-                    close_reason = f"Take profit hit: {current_price} >= {take_profit}"
-                
-                if not should_close and current_price > entry_price:
-                    dynamic_stop = current_price * 0.98
-                    if dynamic_stop > (stop_loss or 0):
-                        trade['stop_loss'] = dynamic_stop
-                        print(f"🔒 Updated trailing stop for {symbol}: {dynamic_stop:.4f}")
-                
+                    should_close, close_reason = True, f"Take profit hit: {current_price} >= {take_profit}"
+
                 if should_close:
-                    print(f"🚨 IMMEDIATE CLOSE: {symbol} - {close_reason} - Strategy: {strategy}")
-                    
+                    print(f"🚨 IMMEDIATE CLOSE: {symbol} - {close_reason}")
                     if r2_service_global.acquire_lock():
                         try:
                             await r2_service_global.close_trade_async(trade, current_price)
-                            print(f"✅ Trade {symbol} closed immediately at {current_price}. Strategy: {strategy}")
-                            
+                            print(f"✅ Trade {symbol} closed immediately at {current_price}.")
                             if learning_engine_global and learning_engine_global.initialized:
                                 await learning_engine_global.analyze_trade_outcome(trade, 'CLOSED_BY_MONITOR')
-                            
                             asyncio.create_task(run_bot_cycle_async())
-                            
                         finally:
                             r2_service_global.release_lock()
-                    
-                    if symbol in self.monitoring_tasks:
-                        del self.monitoring_tasks[symbol]
+                    if symbol in self.monitoring_tasks: del self.monitoring_tasks[symbol]
                     break
-                
                 await asyncio.sleep(15)
-                
             except Exception as error:
                 print(f"❌ Real-time monitoring error for {symbol}: {error}")
                 await asyncio.sleep(30)
-    
+
     def stop_monitoring(self):
-        """إيقاف جميع مهام المراقبة"""
         self.is_running = False
         self.monitoring_tasks.clear()
-        print("🛑 Real-time trade monitoring stopped")
+        print("🛑 Real-time trade monitoring stopped.")
 
 async def monitor_market_async():
-    """Background task to continuously monitor market health"""
-    global data_manager_global
-    
-    init_attempts = 0
-    while data_manager_global is None and init_attempts < 10:
-        print(f"⏳ Waiting for data manager initialization... (attempt {init_attempts + 1}/10)")
+    """Background task to continuously monitor market health with calibrated logic."""
+    while data_manager_global is None:
         await asyncio.sleep(3)
-        init_attempts += 1
-    
-    if data_manager_global is None:
-        print("❌ Data manager failed to initialize after 10 attempts")
-        return
-    
+
     while True:
         try:
             print("👁️ Monitoring market sentiment...")
-            
-            try:
-                market_context = await data_manager_global.get_market_context_async()
-            except Exception as error:
-                print(f"⚠️ Failed to get market context: {error}")
-                market_context = await get_fallback_market_context()
-            
+            market_context = await data_manager_global.get_market_context_async()
             if not market_context:
-                print("❌ Failed to get market context. Assuming neutral state.")
+                print("⚠️ Could not get market context. Assuming neutral state.")
                 state.MARKET_STATE_OK = True
                 await asyncio.sleep(60)
                 continue
 
             whale_analysis = market_context.get('general_whale_activity', {})
-            whale_sentiment = whale_analysis.get('sentiment', 'NEUTRAL')
             is_critical = whale_analysis.get('critical_alert', False)
-            total_volume = whale_analysis.get('total_volume_usd', 0)
-
-            print(f"🐋 Whale Analysis: {whale_sentiment} | Critical: {is_critical} | Volume: ${total_volume:,.0f}")
-            print(f"📈 Whale Description: {whale_analysis.get('description', 'No data')}")
-
             bitcoin_sentiment = market_context.get('btc_sentiment')
             fear_greed_index = market_context.get('fear_and_greed_index')
             
+            # ✅ ## منطق إيقاف التداول المُعاير والذكي ##
+            # لن يتم الإيقاف إلا إذا اجتمعت عدة إشارات سلبية قوية.
             should_halt_trading = False
             halt_reason = ""
             
-            if is_critical:
-                should_halt_trading = True
-                halt_reason = f"CRITICAL whale activity detected: {whale_analysis.get('description')}"
-            elif bitcoin_sentiment == 'BEARISH' and (fear_greed_index is not None and fear_greed_index < 30):
+            # بناء قائمة الأسباب
+            reasons = []
+            if is_critical: reasons.append("CRITICAL whale activity")
+            if fear_greed_index is not None and fear_greed_index < 30: reasons.append(f"Extreme Fear (F&G: {fear_greed_index})")
+            if bitcoin_sentiment == 'BEARISH': reasons.append("Bearish BTC sentiment")
+
+            # القرار: التوقف فقط إذا كان هناك سببان قويان أو أكثر
+            if len(reasons) >= 2:
                 should_halt_trading = True
-                halt_reason = f"Bearish market conditions (BTC: {bitcoin_sentiment}, F&G: {fear_greed_index})"
+                halt_reason = "High-risk market conditions detected: " + " AND ".join(reasons)
 
             if should_halt_trading:
-                print(f"🚨🚨🚨 MARKET HALT: {halt_reason} 🚨🚨🚨")
+                if state.MARKET_STATE_OK: # فقط اطبع الرسالة مرة واحدة عند التغيير
+                    print(f"🚨🚨🚨 MARKET HALT: {halt_reason} 🚨🚨🚨")
+                    await r2_service_global.save_system_logs_async({"market_halt": True, "reason": halt_reason})
                 state.MARKET_STATE_OK = False
-                
-                try:
-                    await r2_service_global.save_system_logs_async({
-                        "market_halt": True,
-                        "reason": halt_reason,
-                        "whale_sentiment": whale_sentiment,
-                        "is_critical": is_critical
-                    })
-                except Exception as log_error:
-                    print(f"⚠️ Failed to save market halt log: {log_error}")
             else:
                 if not state.MARKET_STATE_OK:
-                    print("🟢 Market conditions improved. Resuming normal operations.")
+                    print("🟢 Market conditions have improved. Resuming normal operations.")
                 state.MARKET_STATE_OK = True
                 
-            await asyncio.sleep(60)
+            await asyncio.sleep(60) # فحص كل دقيقة
         except Exception as error:
-            print(f"❌ An error occurred during COMPREHENSIVE market monitoring: {error}")
+            print(f"❌ An error occurred during market monitoring: {error}")
             traceback.print_exc()
-            state.MARKET_STATE_OK = True
+            state.MARKET_STATE_OK = True # افتراض الحالة الآمنة عند حدوث خطأ
             await asyncio.sleep(60)
 
-async def get_fallback_market_context():
-    """Fallback function when main market context fails"""
-    return {
-        'timestamp': datetime.now().isoformat(),
-        'general_whale_activity': {
-            'sentiment': 'NEUTRAL', 
-            'description': 'Fallback mode - system initializing',
-            'critical_alert': False,
-            'transaction_count': 0,
-            'total_volume_usd': 0
-        },
-        'btc_sentiment': 'NEUTRAL',
-        'fear_and_greed_index': 50
-    }
-
-def safe_float_conversion(value, default=0.0):
-    """تحويل آمن للقيم إلى أرقام"""
-    try:
-        if value is None:
-            return default
-        if isinstance(value, (int, float)):
-            return float(value)
-        if isinstance(value, str):
-            cleaned = ''.join(character for character in value if character.isdigit() or character in '.-')
-            return float(cleaned) if cleaned else default
-        return default
-    except (ValueError, TypeError):
-        return default
-
-async def validate_candidate_data_enhanced(candidate):
-    """✨ تحسين التحقق من جودة المرشحين"""
-    try:
-        required_fields = ['symbol', 'current_price', 'final_score', 'enhanced_final_score']
-        
-        for field in required_fields:
-            if field not in candidate:
-                candidate[field] = 0.0 if field.endswith('_score') or field == 'current_price' else 'UNKNOWN'
-        
-        candidate['current_price'] = safe_float_conversion(candidate.get('current_price'), 0.0)
-        candidate['final_score'] = safe_float_conversion(candidate.get('final_score'), 0.5)
-        candidate['enhanced_final_score'] = safe_float_conversion(candidate.get('enhanced_final_score'), candidate['final_score'])
-        
-        if 'reasons_for_candidacy' not in candidate or not candidate['reasons_for_candidacy']:
-            candidate['reasons_for_candidacy'] = ['unknown_reason']
-            
-        if 'sentiment_data' not in candidate or not candidate['sentiment_data']:
-            candidate['sentiment_data'] = {
-                'btc_sentiment': 'NEUTRAL',
-                'fear_and_greed_index': 50,
-                'general_whale_activity': {'sentiment': 'NEUTRAL', 'critical_alert': False}
-            }
-            
-        if 'advanced_indicators' not in candidate:
-            candidate['advanced_indicators'] = {}
-            
-        if 'strategy_scores' not in candidate:
-            candidate['strategy_scores'] = {}
-            
-        if 'recommended_strategy' not in candidate:
-            candidate['recommended_strategy'] = 'unknown'
-        
-        # ✅ الإصلاح: التأكد من وجود استراتيجية مستهدفة صالحة
-        if 'target_strategy' not in candidate or not candidate['target_strategy'] or candidate['target_strategy'] == 'unknown':
-            candidate['target_strategy'] = 'GENERIC'
-            
-        return True
-        
-    except Exception as error:
-        print(f"❌ Failed to validate candidate data for {candidate.get('symbol')}: {error}")
-        return False
-
-async def analyze_market_strategy(market_context):
-    """تحديد الاستراتيجية المثلى بناءً على ظروف السوق"""
-    try:
-        prompt = f"""
-        You are a professional crypto portfolio manager. Analyze the current market conditions and determine the most suitable strategy.
-
-        **Market Data:**
-        - BTC Price: {market_context.get('bitcoin_price_usd')}
-        - BTC Sentiment: {market_context.get('btc_sentiment')}
-        - Fear & Greed Index: {market_context.get('fear_and_greed_index')}
-        - Whale Analysis: {market_context.get('general_whale_activity', {}).get('sentiment')}
-        - Critical Whale Alert: {market_context.get('general_whale_activity', {}).get('critical_alert')}
-
-        **Available Strategies:**
-        1. AGGRESSIVE_GROWTH - For strong bull markets.
-        2. DEFENSIVE_GROWTH - For volatile or uncertain markets.
-        3. CONSERVATIVE - For bearish or high-risk markets.
-        4. HIGH_FREQUENCY - For sideways markets.
-        5. WHALE_FOLLOWING - When whale activity is high and clear.
-        6. GENERIC - Balanced approach for normal conditions.
-
-        **Required:**
-        - Choose one primary strategy.
-        - Explain why in a single sentence.
-        - Set an acceptable risk tolerance (1 to 10).
-        - Determine the optimal number of coins to scan (50 to 200).
-
-        **Output (JSON only):**
-        {{
-            "primary_strategy": "STRATEGY_NAME",
-            "reasoning": "Brief reasoning.",
-            "risk_tolerance": 5,
-            "optimal_scan_count": 100
-        }}
-        """
-        
-        response = await llm_service_global._call_llm(prompt)
-        
-        try:
-            json_match = re.search(r'\{.*\}', response, re.DOTALL)
-            strategy_data = json.loads(json_match.group())
-        except:
-            strategy_data = {
-                "primary_strategy": "GENERIC",
-                "reasoning": "Fallback strategy for market stability",
-                "risk_tolerance": 5,
-                "optimal_scan_count": 100,
-            }
-        
-        return strategy_data
-        
-    except Exception as error:
-        print(f"❌ Failed to analyze market strategy: {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):
-    """✨ نظام فلترة ثلاثي المراحل السريع"""
-    print(f"🎯 Starting 3-stage filtering for {strategy} strategy...")
-    
-    try:
-        # المرحلة الأولى: الفلتر الأولي السريع (2 ثانية)
-        print("🚀 Stage 1: Snapshot Filter (2 seconds)")
-        stage1_start = time.time()
-        initial_candidates = await data_manager_global.fast_snapshot_filter(scan_count * 3)  # جلب مرشحين أكثر للمراحل التالية
-        
-        if not initial_candidates:
-            print("❌ No candidates passed Stage 1 filtering")
-            return []
-            
-        stage1_time = time.time() - stage1_start
-        print(f"✅ Stage 1 completed: {len(initial_candidates)} candidates in {stage1_time:.2f}s")
-        
-        # المرحلة الثانية: فلتر المؤشرات الخفيفة (5-10 ثوان)
-        print("⚡ Stage 2: Lightweight Indicator Filter (5-10 seconds)")
-        stage2_start = time.time()
-        stage2_candidates = await data_manager_global.lightweight_indicator_filter(initial_candidates)
-        
-        if not stage2_candidates:
-            print("❌ No candidates passed Stage 2 filtering")
-            return []
-            
-        stage2_time = time.time() - stage2_start
-        print(f"✅ Stage 2 completed: {len(stage2_candidates)} candidates in {stage2_time:.2f}s")
-        
-        # المرحلة الثالثة: التحليل العميق (للأفضل فقط)
-        print("🔍 Stage 3: Deep Analysis (Top candidates only)")
-        
-        # تحديث market_context قبل المعالجة
-        market_context = await data_manager_global.get_market_context_async()
-        if not market_context:
-            print("❌ Failed to get market context for strategy analysis")
-            return []
-            
-        feature_processor = FeatureProcessor(market_context, data_manager_global, learning_engine_global)
-        
-        processed_candidates = []
-        for candidate in stage2_candidates[:15]:  # معالجة أفضل 15 مرشح فقط
-            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]:
-                    # ✅ تحديث market_context قبل كل معالجة
-                    try:
-                        updated_market_context = await data_manager_global.get_market_context_async()
-                        if updated_market_context:
-                            feature_processor.market_context = updated_market_context
-                    except Exception as e:
-                        print(f"⚠️ Failed to update market context for {candidate['symbol']}: {e}")
-                    
-                    processed = await feature_processor.process_and_score_symbol_enhanced(ohlcv_data[0])
-                    if processed:
-                        processed_candidates.append(processed)
-            except Exception as e:
-                print(f"⚠️ فشل معالجة {candidate.get('symbol')}: {e}")
-        
-        if not processed_candidates:
-            print("⚠️ لم يتم معالجة أي مرشح بنجاح في المرحلة الثالثة")
-            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.3:  # عتبة أعلى قليلاً للجودة
-                    candidate['strategy_match_score'] = strategy_score
-                    strategy_candidates.append(candidate)
-                    print(f"✅ {candidate['symbol']} مناسب لـ {strategy} (درجة: {strategy_score:.3f})")
-            
-            sorted_candidates = sorted(strategy_candidates, 
-                                    key=lambda x: x.get('strategy_match_score', 0), 
-                                    reverse=True)
-            top_candidates = sorted_candidates[:10]  # أفضل 10 فقط
-            
-            print(f"✅ Stage 3 completed: {len(top_candidates)} strategy-specific candidates")
-        else:
-            # للاستراتيجية العامة، استخدم النقاط المحسنة
-            sorted_candidates = sorted(processed_candidates, 
-                                    key=lambda x: x.get('enhanced_final_score', 0), 
-                                    reverse=True)
-            top_candidates = sorted_candidates[:10]
-            print(f"✅ Stage 3 completed: {len(top_candidates)} generic strategy candidates")
-
-        total_time = time.time() - stage1_start
-        print(f"🎯 3-stage filtering completed: {len(top_candidates)} final candidates in {total_time:.2f}s")
-        
-        return top_candidates
-
-    except Exception as error:
-        print(f"❌ فشل في نظام الفلترة ثلاثي المراحل: {error}")
-        traceback.print_exc()
-        return []
-
 async def find_new_opportunities_async():
-    """✨ NEW: المسح المحسن باستراتيجية مسبقة مع نظام الفلترة السريع"""
-    print("🔍 Scanning for new opportunities with 3-stage fast filtering...")
+    """Finds new trading opportunities using the 3-stage filtering system."""
+    print("🔍 Scanning for new opportunities...")
     try:
-        await r2_service_global.save_system_logs_async({
-            "opportunity_scan_started": True, "timestamp": datetime.now().isoformat()
-        })
-
-        print("🧠 Determining trading strategy...")
         market_context = await data_manager_global.get_market_context_async()
         if not market_context:
-            print("❌ Failed to fetch market context. Cannot determine strategy.")
-            return
+            print("❌ Failed to fetch market context. Aborting scan.")
+            return None
 
-        strategy_decision = await analyze_market_strategy(market_context)
-        
-        print(f"🎯 Selected Strategy: {strategy_decision['primary_strategy']}")
-        print(f"📝 Reasoning: {strategy_decision['reasoning']}")
-        print(f"⚡ Risk Tolerance: {strategy_decision.get('risk_tolerance', 5)}/10")
-        print(f"🔍 Optimal Scan Count: {strategy_decision.get('optimal_scan_count', 100)}")
-
-        print(f"🔍 Finding top candidates using 3-stage filtering...")
-        high_potential_candidates = await find_strategy_specific_candidates(
-            strategy_decision['primary_strategy'], 
-            strategy_decision.get('optimal_scan_count', 100)
-        )
+        # استخدام نظام الفلترة السريع والفعال
+        candidates = await data_manager_global.fast_snapshot_filter(150)
+        lightweight_candidates = await data_manager_global.lightweight_indicator_filter(candidates)
         
-        if not high_potential_candidates:
-            print("🔄 لا توجد مرشحين متخصصين، جلب مرشحين عامين...")
-            # ✅ استرجاع مرشحين عامين كبديل باستخدام النظام السريع أيضاً
-            high_potential_candidates = await data_manager_global.fast_snapshot_filter(20)
-            if high_potential_candidates:
-                for candidate in high_potential_candidates:
-                    candidate['target_strategy'] = 'GENERIC'
-                print(f"✅ تم تحميل {len(high_potential_candidates)} مرشح عام")
-            else:
-                print("✅ No new candidates found after 3-stage filtering.")
-                await r2_service_global.save_system_logs_async({
-                    "no_candidates_found": True, "strategy": strategy_decision['primary_strategy'],
-                    "reason": "3-stage filtering did not return any candidates."
-                })
-                return
-
-        # ✅ استخدام السياق المحدث للتصفية النهائية
-        updated_market_context = await data_manager_global.get_market_context_async()
-        if not updated_market_context:
-            updated_market_context = market_context
+        if not lightweight_candidates:
+            print("✅ No promising candidates found after initial filtering.")
+            return None
             
-        feature_processor = FeatureProcessor(updated_market_context, data_manager_global, learning_engine_global)
-        top_candidates = feature_processor.filter_top_candidates(high_potential_candidates, OPPORTUNITY_COUNT)
-        
-        print(f"✅ Identified {len(top_candidates)} top candidates after final scoring.")
-        
-        await r2_service_global.save_candidates_data_async(
-            candidates_data=top_candidates,
-            reanalysis_data={"strategy_used": strategy_decision, "market_conditions": market_context}
-        )
+        print(f"🧠 Deep analyzing top {OPPORTUNITY_COUNT} candidates...")
+        # التحليل العميق لأفضل المرشحين فقط
+        ohlcv_data_list = await data_manager_global.get_fast_pass_data_async(lightweight_candidates[:OPPORTUNITY_COUNT])
+
+        feature_processor = FeatureProcessor(market_context, data_manager_global, learning_engine_global)
+        processed_candidates = []
+        for raw_data in ohlcv_data_list:
+            processed = await feature_processor.process_and_score_symbol_enhanced(raw_data)
+            if processed:
+                processed_candidates.append(processed)
         
+        top_candidates = feature_processor.filter_top_candidates(processed_candidates, OPPORTUNITY_COUNT)
+
         if not top_candidates:
-            print("❌ No strong candidates left after final filtering.")
-            await r2_service_global.save_system_logs_async({
-                "no_strong_candidates": True, "strategy": strategy_decision['primary_strategy'],
-                "initial_candidates_count": len(high_potential_candidates)
-            })
-            return
+            print("✅ No strong candidates left after final scoring.")
+            return None
             
-        print("🧠 Getting LLM analysis for top candidates...")
-        
+        print(f"🧠 Getting LLM analysis for top {len(top_candidates)} candidates...")
         for candidate in top_candidates:
             try:
-                if not await validate_candidate_data_enhanced(candidate):
-                    print(f"⚠️ Skipping {candidate.get('symbol')} due to quality issues")
-                    continue
-                
-                llm_analysis_data = await llm_service_global.get_trading_decision(candidate)
-                
-                if not llm_analysis_data:
-                    print(f"⚠️ LLM analysis failed for {candidate['symbol']}. Moving to next.")
-                    continue
-
-                if llm_analysis_data.get('action') == "HOLD":
-                    print(f"🧠 LLM decided to HOLD on {candidate['symbol']}. Moving to next.")
-                    continue
-                
-                if llm_analysis_data.get('action') in ["BUY", "SELL"]:
-                    # ✅ التحقق النهائي من الاستراتيجية
-                    final_strategy = llm_analysis_data.get('strategy')
-                    candidate_strategy = candidate.get('target_strategy', 'GENERIC')
-                    
-                    # إذا كانت استراتيجية LLM غير صالحة، استخدم استراتيجية المرشح
-                    if not final_strategy or final_strategy == 'unknown' or final_strategy == 'GENERIC':
-                        final_strategy = candidate_strategy
-                        llm_analysis_data['strategy'] = final_strategy
-                        print(f"🔧 تصحيح استراتيجية LLM لـ {candidate['symbol']}: {final_strategy}")
-                    
-                    print(f"🎯 الاستراتيجية النهائية: {final_strategy}")
-                    
+                llm_analysis = await llm_service_global.get_trading_decision(candidate)
+                if llm_analysis and llm_analysis.get('action') == "BUY":
                     print("\n========================================================")
                     print(f"💎💎💎 New Trading Opportunity Identified! 💎💎💎")
                     print(f"   Symbol: {candidate['symbol']}")
-                    print(f"   Action: {llm_analysis_data.get('action')}")
-                    print(f"   Strategy: {final_strategy}")
-                    print(f"   Reasoning: {llm_analysis_data.get('reasoning')}")
-                    print(f"   Confidence: {llm_analysis_data.get('confidence_level')}")
+                    print(f"   Strategy: {llm_analysis.get('strategy', 'N/A')}")
+                    print(f"   Reasoning: {llm_analysis.get('reasoning')}")
                     print("========================================================\n")
-                    
-                    await r2_service_global.save_system_logs_async({
-                        "new_opportunity_found": True, "symbol": candidate['symbol'],
-                        "action": llm_analysis_data.get('action'), "strategy": final_strategy,
-                        "confidence": llm_analysis_data.get('confidence_level', 0)
-                    })
-                    
-                    return {
-                        "symbol": candidate['symbol'],
-                        "decision": llm_analysis_data,
-                        "current_price": candidate['current_price'],
-                        "strategy": final_strategy
-                    }
-                    
-            except Exception as error:
-                print(f"❌ LLM/Fallback error for {candidate.get('symbol', 'unknown')}: {error}")
-                traceback.print_exc()
+                    await r2_service_global.save_system_logs_async({"new_opportunity_found": True, "symbol": candidate['symbol'], "strategy": llm_analysis.get('strategy')})
+                    return {"symbol": candidate['symbol'], "decision": llm_analysis, "current_price": candidate['current_price']}
+                else:
+                    print(f"🧠 LLM decided to HOLD on {candidate.get('symbol', 'unknown')}.")
+            except Exception as e:
+                print(f"❌ LLM analysis failed for {candidate.get('symbol', 'unknown')}: {e}")
         
-        print("✅ Cycle finished. No actionable BUY/SELL opportunities found by LLM.")
+        print("✅ Cycle finished. No actionable BUY opportunities found by LLM.")
         return None
-        
     except Exception as error:
         print(f"❌ An error occurred while scanning for opportunities: {error}")
         traceback.print_exc()
-        await r2_service_global.save_system_logs_async({"opportunity_scan_error": True, "error": str(error)})
         return None
 
 async def re_analyze_open_trade_async(trade_data):
-    """Re-analyzes an open trade with enhanced strategy preservation"""
+    """Re-analyzes an open trade."""
     symbol = trade_data.get('symbol')
-    
+    print(f"⏳ Re-analyzing trade: {symbol}")
     try:
-        entry_time = datetime.fromisoformat(trade_data['entry_timestamp'])
-        current_time = datetime.now()
-        hold_minutes = (current_time - entry_time).total_seconds() / 60
-        
-        print(f"⏳ Re-analyzing trade: {symbol} (held for {hold_minutes:.1f} minutes)")
-        
-        # ✅ الإصلاح المحسن: الحفاظ على الاستراتيجية الأصلية مع التحقق الشامل
-        original_strategy = trade_data.get('strategy')
-        if not original_strategy or original_strategy == 'unknown':
-            original_strategy = trade_data.get('decision_data', {}).get('strategy', 'GENERIC')
-            print(f"🔧 Fixed original strategy for {symbol}: {original_strategy}")
-        
-        reanalysis_context = {
-            'trade_data': {
-                'symbol': trade_data.get('symbol'),
-                'entry_price': trade_data.get('entry_price'),
-                'entry_time': trade_data.get('entry_timestamp'),
-                'hold_minutes': hold_minutes,
-                'strategy': original_strategy
-            }
-        }
-        
-        try:
-            market_context = await data_manager_global.get_market_context_async()
-        except Exception as error:
-            print(f"⚠️ Failed to get market context: {error}. Using basic market data...")
-            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:
-            print(f"❌ Failed to fetch latest data for {symbol}.")
+        market_context = await data_manager_global.get_market_context_async()
+        symbol_data = await data_manager_global.get_fast_pass_data_async([{'symbol': symbol, 'reasons': ['re-analysis']}])
+        if not symbol_data:
+            print(f"❌ Failed to fetch latest data for {symbol} re-analysis.")
             return None
-        
-        raw_data = ohlcv_data_list[0]
-        # ✅ تحديث market_context قبل المعالجة
-        try:
-            updated_market_context = await data_manager_global.get_market_context_async()
-            if updated_market_context:
-                market_context = updated_market_context
-        except Exception as e:
-            print(f"⚠️ Failed to update market context for re-analysis: {e}")
-            
+
         feature_processor = FeatureProcessor(market_context, data_manager_global, learning_engine_global)
-        processed_data = await feature_processor.process_and_score_symbol(raw_data)
-        
+        processed_data = await feature_processor.process_and_score_symbol(symbol_data[0])
         if not processed_data:
-            print(f"❌ Failed to process latest data for {symbol}.")
+            print(f"❌ Failed to process latest data for {symbol} re-analysis.")
             return None
 
-        await r2_service_global.save_candidates_data_async(
-            candidates_data=None,
-            reanalysis_data={'market_context': market_context, 'processed_data': processed_data}
-        )
-
-        print(f"🧠 Getting LLM re-analysis for {symbol}...")
-        try:
-            re_analysis_decision = await llm_service_global.re_analyze_trade_async(trade_data, processed_data)
-            source = re_analysis_decision.get('model_source', 'LLM')
-        except Exception as error:
-            print(f"❌ LLM re-analysis error: {error}. Falling back to local.")
-            re_analysis_decision = local_re_analyze_trade(trade_data, processed_data)
-            source = 'local_fallback'
-        
-        final_decision = _apply_patience_logic(re_analysis_decision, hold_minutes, trade_data, processed_data)
-        
-        # ✅ الإصلاح النهائي: التأكد من وجود الاستراتيجية في القرار النهائي
-        if not final_decision.get('strategy') or final_decision['strategy'] == 'unknown':
-            final_decision['strategy'] = original_strategy
-            print(f"🔧 Final re-analysis strategy fix for {symbol}: {original_strategy}")
-        
-        print(f"✅ Re-analysis decision for {symbol}: {final_decision.get('action')}. Strategy: {final_decision.get('strategy')}. Source: {source}")
-        
-        await r2_service_global.save_system_logs_async({
-            "trade_reanalyzed": True, "symbol": symbol, "action": final_decision.get('action'),
-            "hold_minutes": hold_minutes, "source": source, "strategy": final_decision.get('strategy')
-        })
-        
-        return {
-            "symbol": symbol, "decision": final_decision,
-            "current_price": processed_data.get('current_price'), "hold_minutes": hold_minutes
-        }
-        
+        re_analysis = await llm_service_global.re_analyze_trade_async(trade_data, processed_data)
+        print(f"✅ Re-analysis for {symbol} suggests: {re_analysis.get('action')}")
+        return {"symbol": symbol, "decision": re_analysis, "current_price": processed_data.get('current_price')}
     except Exception as error:
-        print(f"❌ An error occurred during trade re-analysis: {error}")
+        print(f"❌ An error occurred during trade re-analysis for {symbol}: {error}")
         traceback.print_exc()
-        await r2_service_global.save_system_logs_async({"reanalysis_error": True, "symbol": symbol, "error": str(error)})
         return None
 
-def _apply_patience_logic(decision, hold_minutes, trade_data, processed_data):
-    """Apply patience logic to prevent premature selling decisions"""
-    action = decision.get('action')
-    
-    if action == "CLOSE_TRADE" and hold_minutes < 20:
-        current_price = processed_data.get('current_price', 0)
-        entry_price = trade_data.get('entry_price', 0)
-        
-        try:
-            profit_loss_percent = ((current_price - entry_price) / entry_price) * 100
-        except (TypeError, ZeroDivisionError):
-            profit_loss_percent = 0
-        
-        if profit_loss_percent < 2:
-            print(f"🛑 Blocked premature selling! Only {hold_minutes:.1f} minutes held, PnL: {profit_loss_percent:.2f}%")
-            decision['action'] = "HOLD"
-            decision['reasoning'] = f"Patience Filter: Blocked premature sell. Held for {hold_minutes:.1f}m. Giving trade more time."
-            return decision
-    
-    return decision
-        
 async def run_bot_cycle_async():
-    """The main asynchronous bot cycle with enhanced strategy validation"""
-    print(f"\n{'='*70}")
-    print(f"⏳ New cycle initiated at: {datetime.now().isoformat()}")
-    print(f"{'='*70}")
+    """The main asynchronous bot cycle."""
+    print(f"\n{'='*50}\n⏳ New cycle initiated at: {datetime.now().isoformat()}\n{'='*50}")
     
-    try:
-        await r2_service_global.save_system_logs_async({"cycle_started": True})
-
-        if not r2_service_global.acquire_lock():
-            print("❌ Failed to acquire lock. Skipping cycle.")
-            return
+    if not state.MARKET_STATE_OK:
+        print("Market is currently halted. Skipping trading cycle.")
+        return
 
-        open_trades = []
-        try:
-            open_trades = await r2_service_global.get_open_trades_async()
-            print(f"✅ Found {len(open_trades)} open trade(s).")
-            
-            # ✅ الإصلاح المحسن: فحص وإصلاح الاستراتيجيات الفارغة في الصفقات المفتوحة
-            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
-                    print(f"🔧 Fixed missing strategy for {trade['symbol']}: {trade['strategy']}")
-            
-            if trades_fixed > 0:
-                print(f"✅ Fixed strategies for {trades_fixed} trades.")
-                await r2_service_global.save_open_trades_async(open_trades)
-            
-            should_look_for_new_trade = not open_trades
-
-            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"🔍 Re-analyzing {len(trades_to_reanalyze)} trade(s)...")
-                    for trade in trades_to_reanalyze:
-                        result = await re_analyze_open_trade_async(trade)
-                        if result and result['decision'].get('action') == "CLOSE_TRADE":
-                            await r2_service_global.close_trade_async(trade, result['current_price'])
-                            print(f"✅ Trade for {trade['symbol']} CLOSED. Strategy: {trade.get('strategy', 'unknown')}")
-                            if learning_engine_global and learning_engine_global.initialized:
-                                trade_with_strategy = trade.copy()
-                                strategy = result['decision'].get('strategy', trade.get('strategy', 'GENERIC'))
-                                trade_with_strategy['strategy'] = strategy
-                                await learning_engine_global.analyze_trade_outcome(trade_with_strategy, 'CLOSED_BY_REANALYSIS')
-                            should_look_for_new_trade = True
-                        elif result and result['decision'].get('action') == "UPDATE_TRADE":
-                            await r2_service_global.update_trade_async(trade, result['decision'])
-                            print(f"✅ Trade for {trade['symbol']} UPDATED. Strategy: {trade.get('strategy', 'unknown')}")
-                        else:
-                            print(f"✅ Trade for {trade['symbol']} is on HOLD. Strategy: {trade.get('strategy', 'unknown')}")
-                else:
-                    print("✅ No trades due for re-analysis yet.")
-
-            if should_look_for_new_trade:
-                portfolio_state = await r2_service_global.get_portfolio_state_async()
-                if portfolio_state.get("current_capital_usd", 0) > 1:
-                    print(f"✅ Capital available (${portfolio_state['current_capital_usd']:.2f}). Scanning...")
-                    new_opportunity = await find_new_opportunities_async()
-                    if new_opportunity:
-                        print(f"✅ Opportunity for {new_opportunity['symbol']} confirmed! Saving trade. Strategy: {new_opportunity.get('strategy')}")
-                        
-                        # ✅ التحقق النهائي قبل الحفظ
-                        if not new_opportunity['decision'].get('strategy'):
-                            new_opportunity['decision']['strategy'] = new_opportunity.get('strategy', 'GENERIC')
-                            print(f"🔧 Final pre-save strategy fix: {new_opportunity['decision']['strategy']}")
-                        
-                        await r2_service_global.save_new_trade_async(
-                            new_opportunity['symbol'], 
-                            new_opportunity['decision'], 
-                            new_opportunity['current_price']
-                        )
-                        newly_opened_trades = await r2_service_global.get_open_trades_async()
-                        for trade in newly_opened_trades:
-                            if trade['symbol'] == new_opportunity['symbol']:
-                                asyncio.create_task(realtime_monitor._monitor_single_trade(trade))
-                                break
-                    else:
-                        print("✅ Scan complete. No actionable opportunities identified.")
-                else:
-                    print("😴 No available capital. Waiting for current trade to close.")
-            
-        finally:
-            print("✅ Cycle finished. Releasing lock.")
-            r2_service_global.release_lock()
-            await r2_service_global.save_system_logs_async({"cycle_completed": True, "open_trades": len(open_trades)})
+    if not r2_service_global.acquire_lock():
+        print("❌ Failed to acquire lock. Another cycle is already running. Skipping.")
+        return
 
+    try:
+        await r2_service_global.save_system_logs_async({"cycle_started": True})
+        open_trades = await r2_service_global.get_open_trades_async()
+        should_look_for_new_trade = not open_trades
+
+        if open_trades:
+            trade = open_trades[0] # Assuming one trade at a time for now
+            result = await re_analyze_open_trade_async(trade)
+            if result and result['decision'].get('action') == "CLOSE_TRADE":
+                await r2_service_global.close_trade_async(trade, result['current_price'])
+                print(f"✅ Trade for {trade['symbol']} CLOSED based on re-analysis.")
+                if learning_engine_global:
+                    await learning_engine_global.analyze_trade_outcome(trade, 'CLOSED_BY_REANALYSIS')
+                should_look_for_new_trade = True
+            else:
+                print(f"✅ Trade for {trade['symbol']} remains on HOLD.")
+
+        if should_look_for_new_trade:
+            portfolio_state = await r2_service_global.get_portfolio_state_async()
+            if portfolio_state.get("current_capital_usd", 0) > 1:
+                new_opportunity = await find_new_opportunities_async()
+                if new_opportunity:
+                    await r2_service_global.save_new_trade_async(
+                        new_opportunity['symbol'], new_opportunity['decision'], new_opportunity['current_price']
+                    )
+            else:
+                print("😴 No available capital. Waiting for current trade to close.")
+    
     except Exception as error:
         print(f"❌ Unhandled error in main cycle: {error}")
         traceback.print_exc()
-        await r2_service_global.save_system_logs_async({"cycle_error": True, "error": str(error)})
-        if r2_service_global.lock_acquired:
-            r2_service_global.release_lock()
+    finally:
+        print("✅ Cycle finished. Releasing lock.")
+        r2_service_global.release_lock()
 
 @asynccontextmanager
 async def lifespan(application: FastAPI):
     global r2_service_global, data_manager_global, llm_service_global, learning_engine_global, realtime_monitor
     print("===== Application Startup =====")
-    
     try:
         r2_service_global = R2Service()
         llm_service_global = LLMService()
         contracts_database = await r2_service_global.load_contracts_db_async()
         
+        # ✅ تهيئة مدير البيانات الذي يدير الآن الاتصالات بشكل مركزي
         data_manager_global = DataManager(contracts_database)
         await data_manager_global.initialize()
 
-        # ✅ تهيئة نظام التعلم مع تمرير data_manager
         learning_engine_global = LearningEngine(r2_service_global, data_manager_global)
-        await learning_engine_global.initialize_enhanced()  # ✅ استخدام التهيئة المحسنة
-        
-        # ✅ إجبار تحديث الاستراتيجيات من البيانات الحالية
+        await learning_engine_global.initialize_enhanced()
         await learning_engine_global.force_strategy_learning()
         
-        # ✅ التحقق من أن الأوزان يتم تحميلها
-        if learning_engine_global.initialized:
-            weights = await learning_engine_global.get_optimized_strategy_weights("bull_market")
-            print(f"🎯 الأوزان المحملة: {weights}")
-        
         realtime_monitor = RealTimeTradeMonitor()
         
+        # بدء المهام الخلفية
         asyncio.create_task(monitor_market_async())
         asyncio.create_task(realtime_monitor.start_monitoring())
         
         await r2_service_global.save_system_logs_async({"application_started": True})
-        
         print("\n✅ All services initialized. Application is ready.\n")
         yield
         
     except Exception as error:
         print(f"❌ Application startup failed: {error}")
         traceback.print_exc()
-        if r2_service_global:
-            await r2_service_global.save_system_logs_async({"application_startup_failed": True, "error": str(error)})
-        raise
     finally:
+        # 🔒 إغلاق آمن للموارد عند إيقاف التشغيل
         await cleanup_on_shutdown()
 
 application = FastAPI(lifespan=lifespan)
 
+# ... (API endpoints like /run-cycle, /health, etc., remain unchanged) ...
+
 @application.get("/run-cycle")
 async def run_cycle_api():
-    """API endpoint to trigger the bot cycle."""
     asyncio.create_task(run_bot_cycle_async())
     return {"message": "Bot cycle initiated in the background."}
 
 @application.get("/health")
 async def health_check():
-    """Detailed health check."""
-    learning_metrics = {}
-    if learning_engine_global and learning_engine_global.initialized:
-        learning_metrics = await learning_engine_global.calculate_performance_metrics()
-    
     return {
-        "status": "healthy",
-        "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",
-            "realtime_monitor": "running" if realtime_monitor and realtime_monitor.is_running else "stopped"
-        },
+        "status": "healthy", "timestamp": datetime.now().isoformat(),
         "market_state_ok": state.MARKET_STATE_OK,
-        "learning_engine": learning_metrics
+        "lock_acquired": r2_service_global.lock_acquired if r2_service_global else False
     }
 
-@application.get("/stats")
-async def get_performance_stats():
-    """Get performance statistics for all services."""
-    try:
-        market_context = await data_manager_global.get_market_context_async() if data_manager_global else {}
-        
-        learning_stats = {}
-        improvement_suggestions = []
-        if learning_engine_global and learning_engine_global.initialized:
-            learning_stats = await learning_engine_global.calculate_performance_metrics()
-            improvement_suggestions = await learning_engine_global.suggest_improvements()
-        
-        stats = {
-            "timestamp": datetime.now().isoformat(),
-            "data_manager": data_manager_global.get_performance_stats() if data_manager_global else {},
-            "market_state": {
-                "is_healthy": state.MARKET_STATE_OK,
-                "description": "Market is healthy for trading" if state.MARKET_STATE_OK else "Market conditions are unfavorable",
-                "context": market_context
-            },
-            "realtime_monitoring": {
-                "active_trades": len(realtime_monitor.monitoring_tasks) if realtime_monitor else 0,
-                "is_running": realtime_monitor.is_running if realtime_monitor else False
-            },
-            "learning_engine": learning_stats,
-            "improvement_suggestions": improvement_suggestions
-        }
-        return stats
-    except Exception as error:
-        raise HTTPException(status_code=500, detail=f"Failed to retrieve stats: {str(error)}")
-
-@application.get("/logs/status")
-async def get_logs_status():
-    """Get status of logging system."""
-    try:
-        open_trades = await r2_service_global.get_open_trades_async()
-        portfolio_state = await r2_service_global.get_portfolio_state_async()
-        
-        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()
-        }
-    except Exception as error:
-        raise HTTPException(status_code=500, detail=f"Failed to get logs status: {str(error)}")
-
 async def cleanup_on_shutdown():
     """Cleanup function for graceful shutdown."""
-    global r2_service_global, data_manager_global, realtime_monitor, learning_engine_global
     print("\n🛑 Shutdown signal received. Cleaning up...")
     
-    if r2_service_global:
-        try:
-            await r2_service_global.save_system_logs_async({"application_shutdown": True})
-        except Exception as log_error:
-            print(f"⚠️ Failed to save shutdown log: {log_error}")
-    
-    if learning_engine_global and learning_engine_global.initialized:
-        try:
-            await learning_engine_global.save_weights_to_r2()
-            await learning_engine_global.save_performance_history()
-            print("✅ Learning engine data saved.")
-        except Exception as e:
-            print(f"⚠️ Failed to save learning engine data: {e}")
-    
-    if realtime_monitor:
-        realtime_monitor.stop_monitoring()
+    if realtime_monitor: realtime_monitor.stop_monitoring()
     
-    if data_manager_global:
-        await data_manager_global.close()
-        print("✅ Data manager connections closed.")
+    # ✅ إغلاق مدير البيانات سيقوم بإغلاق جميع الاتصالات المدارة مركزيًا
+    if data_manager_global: await data_manager_global.close()
     
-    if r2_service_global and r2_service_global.lock_acquired:
-        r2_service_global.release_lock()
-        print("✅ Lock released.")
+    if learning_engine_global:
+        await learning_engine_global.save_weights_to_r2()
+        await learning_engine_global.save_performance_history()
+        print("✅ Learning engine data saved.")
+
+    if r2_service_global:
+        await r2_service_global.save_system_logs_async({"application_shutdown": True})
+        if r2_service_global.lock_acquired:
+            r2_service_global.release_lock()
+            print("✅ Lock released.")
     
     print("✅ Cleanup completed.")
 
 def signal_handler(signum, frame):
     """Handle shutdown signals."""
-    print(f"\n⚠️ Received signal {signum}")
+    print(f"\n⚠️ Received signal {signum}, initiating graceful shutdown.")
+    # Use a task to ensure cleanup can complete
     asyncio.create_task(cleanup_on_shutdown())
+    # Give it a moment to start before exiting
+    time.sleep(2)
     sys.exit(0)
 
 signal.signal(signal.SIGINT, signal_handler)