Update LLM.py

LLM.py

@@ -6,7 +6,7 @@ from backoff import on_exception, expo
 from openai import OpenAI, RateLimitError, APITimeoutError
 import numpy as np
 from sentiment_news import NewsFetcher
-from helpers import parse_json_from_response, validate_required_fields, format_technical_indicators, format_strategy_scores
+from helpers import parse_json_from_response, validate_required_fields, format_technical_indicators, format_strategy_scores, format_candle_data_for_pattern_analysis, format_whale_analysis_for_llm
 
 NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY")
 PRIMARY_MODEL = "nvidia/llama-3.1-nemotron-ultra-253b-v1"
@@ -16,52 +16,68 @@ class PatternAnalysisEngine:
         self.llm = llm_service
 
     def _format_chart_data_for_llm(self, ohlcv_data):
-        if not ohlcv_data or len(ohlcv_data) < 20: 
+        """تنسيق شامل لبيانات الشموع لتحليل الأنماط"""
+        if not ohlcv_data: 
             return "Insufficient chart data for pattern analysis"
+        
         try:
-            candles_to_analyze = ohlcv_data[-50:] if len(ohlcv_data) > 50 else ohlcv_data
-            chart_description = ["CANDLE DATA FOR PATTERN ANALYSIS:", f"Total candles available: {len(ohlcv_data)}", f"Candles used for analysis: {len(candles_to_analyze)}", ""]
-            
-            if len(candles_to_analyze) >= 10:
-                recent_candles = candles_to_analyze[-10:]
-                chart_description.append("Recent 10 Candles (Latest First):")
-                for i, candle in enumerate(reversed(recent_candles)):
-                    candle_idx = len(candles_to_analyze) - i
-                    desc = f"Candle {candle_idx}: O:{candle[1]:.6f} H:{candle[2]:.6f} L:{candle[3]:.6f} C:{candle[4]:.6f} V:{candle[5]:.0f}"
-                    chart_description.append(f"  {desc}")
-            
-            if len(candles_to_analyze) >= 2:
-                first_close = candles_to_analyze[0][4]
-                last_close = candles_to_analyze[-1][4]
-                price_change = ((last_close - first_close) / first_close) * 100
-                trend = "BULLISH" if price_change > 2 else "BEARISH" if price_change < -2 else "SIDEWAYS"
-                highs = [c[2] for c in candles_to_analyze]
-                lows = [c[3] for c in candles_to_analyze]
-                high_max = max(highs)
-                low_min = min(lows)
-                volatility = ((high_max - low_min) / low_min) * 100
-                chart_description.extend(["", "MARKET STRUCTURE ANALYSIS:", f"Trend Direction: {trend}", f"Price Change: {price_change:+.2f}%", f"Volatility Range: {volatility:.2f}%", f"Highest Price: {high_max:.6f}", f"Lowest Price: {low_min:.6f}"])
+            # استخدام جميع الأطر الزمنية المتاحة
+            all_timeframes = []
+            for timeframe, candles in ohlcv_data.items():
+                if candles and len(candles) >= 20:
+                    candle_summary = format_candle_data_for_pattern_analysis({timeframe: candles}, timeframe)
+                    all_timeframes.append(f"=== {timeframe.upper()} TIMEFRAME ===\n{candle_summary}")
             
-            if len(candles_to_analyze) >= 5:
-                volumes = [c[5] for c in candles_to_analyze]
-                avg_volume = sum(volumes) / len(volumes)
-                current_volume = candles_to_analyze[-1][5]
-                volume_ratio = current_volume / avg_volume if avg_volume > 0 else 1
-                volume_signal = "HIGH" if volume_ratio > 2 else "NORMAL" if volume_ratio > 0.5 else "LOW"
-                chart_description.extend(["", "VOLUME ANALYSIS:", f"Current Volume: {current_volume:,.0f}", f"Volume Ratio: {volume_ratio:.2f}x average", f"Volume Signal: {volume_signal}"])
-            
-            return "\n".join(chart_description)
+            return "\n\n".join(all_timeframes) if all_timeframes else "No sufficient timeframe data available"
         except Exception as e: 
             return f"Error formatting chart data: {str(e)}"
     
     async def analyze_chart_patterns(self, symbol, ohlcv_data):
         try:
-            if not ohlcv_data or len(ohlcv_data) < 20:
-                return {"pattern_detected": "insufficient_data", "pattern_confidence": 0.1, "pattern_analysis": "Insufficient candle data for pattern analysis"}
+            if not ohlcv_data:
+                return {"pattern_detected": "insufficient_data", "pattern_confidence": 0.1, "pattern_analysis": "No candle data available"}
             
             chart_text = self._format_chart_data_for_llm(ohlcv_data)
-            prompt = f"Analyze the following candle data for {symbol} and identify patterns.\n\nCANDLE DATA FOR ANALYSIS:\n{chart_text}\n\nOUTPUT FORMAT (JSON):\n{{\"pattern_detected\": \"pattern_name\",\"pattern_confidence\": 0.85,\"pattern_strength\": \"strong/medium/weak\",\"predicted_direction\": \"up/down/sideways\",\"predicted_movement_percent\": 5.50,\"timeframe_expectation\": \"15-25 minutes\",\"entry_suggestion\": 0.1234,\"target_suggestion\": 0.1357,\"stop_suggestion\": 0.1189,\"key_support\": 0.1200,\"key_resistance\": 0.1300,\"pattern_analysis\": \"Detailed explanation\"}}"
             
+            prompt = f"""
+ANALYZE CHART PATTERNS FOR {symbol}
+
+CANDLE DATA FOR TECHNICAL ANALYSIS:
+{chart_text}
+
+PATTERN ANALYSIS INSTRUCTIONS:
+1. Analyze ALL available timeframes (1w, 1d, 4h, 1h, 15m, 5m)
+2. Identify clear chart patterns (Double Top/Bottom, Head & Shoulders, Triangles, Flags, etc.)
+3. Assess trend direction and strength
+4. Identify key support and resistance levels
+5. Evaluate volume patterns
+6. Look for convergence/divergence across timeframes
+7. Consider candlestick patterns and formations
+
+CRITICAL: You MUST analyze at least 3 different timeframes to confirm patterns.
+
+OUTPUT FORMAT (JSON):
+{{
+    "pattern_detected": "pattern_name",
+    "pattern_confidence": 0.85,
+    "pattern_strength": "strong/medium/weak",
+    "predicted_direction": "up/down/sideways",
+    "predicted_movement_percent": 5.50,
+    "timeframe_expectation": "15-25 minutes",
+    "key_support_levels": [0.1200, 0.1180, 0.1150],
+    "key_resistance_levels": [0.1300, 0.1320, 0.1350],
+    "pattern_analysis": "Detailed explanation covering multiple timeframes",
+    "timeframe_confirmations": {{
+        "1h": "pattern_details",
+        "4h": "pattern_details", 
+        "1d": "pattern_details"
+    }},
+    "risk_assessment": "low/medium/high",
+    "recommended_entry": 0.1234,
+    "recommended_targets": [0.1357, 0.1400],
+    "recommended_stop_loss": 0.1189
+}}
+"""
             response = await self.llm._call_llm(prompt)
             return self._parse_pattern_response(response)
         except Exception as e:
@@ -107,21 +123,28 @@ class LLMService:
             symbol = data_payload.get('symbol', 'unknown')
             target_strategy = data_payload.get('target_strategy', 'GENERIC')
             
+            # جلب جميع البيانات المطلوبة
             news_text = await self.news_fetcher.get_news_for_symbol(symbol)
             pattern_analysis = await self._get_pattern_analysis(data_payload)
-            prompt = self._create_enhanced_trading_prompt(data_payload, news_text, pattern_analysis)
+            whale_data = data_payload.get('whale_data', {})
+            
+            # إنشاء الـ prompt الشامل
+            prompt = self._create_comprehensive_trading_prompt(data_payload, news_text, pattern_analysis, whale_data)
             
             # ✅ حفظ الـ Prompt في R2 قبل إرساله للنموذج
             if self.r2_service:
                 analysis_data = {
+                    'symbol': symbol,
                     'current_price': data_payload.get('current_price'),
                     'final_score': data_payload.get('final_score'),
                     'enhanced_final_score': data_payload.get('enhanced_final_score'),
                     'target_strategy': target_strategy,
-                    'pattern_analysis': pattern_analysis
+                    'pattern_analysis': pattern_analysis,
+                    'whale_data_available': whale_data.get('data_available', False),
+                    'timestamp': datetime.now().isoformat()
                 }
                 await self.r2_service.save_llm_prompts_async(
-                    symbol, 'trading_decision', prompt, analysis_data
+                    symbol, 'comprehensive_trading_decision', prompt, analysis_data
                 )
             
             async with self.semaphore: 
@@ -131,26 +154,28 @@ class LLMService:
             if decision_dict:
                 decision_dict['model_source'] = self.model_name
                 decision_dict['pattern_analysis'] = pattern_analysis
+                decision_dict['whale_data_integrated'] = whale_data.get('data_available', False)
                 return decision_dict
             else:
-                # ❌ لا نستخدم أي محاكاة - نرجع None في حالة الفشل
                 print(f"❌ فشل تحليل النموذج الضخم لـ {symbol} - لا توجد قرارات بديلة")
                 return None
                 
         except Exception as e:
             print(f"❌ خطأ في قرار التداول لـ {data_payload.get('symbol', 'unknown')}: {e}")
-            # ❌ لا نستخدم أي محاكاة
+            traceback.print_exc()
             return None
     
     def _parse_llm_response_enhanced(self, response_text: str, fallback_strategy: str, symbol: str) -> dict:
         try:
             json_str = parse_json_from_response(response_text)
             if not json_str: 
+                print(f"❌ فشل استخراج JSON من استجابة النموذج لـ {symbol}")
                 return None
 
             decision_data = json.loads(json_str)
             required_fields = ['action', 'reasoning', 'risk_assessment', 'trade_type', 'stop_loss', 'take_profit', 'expected_target_minutes', 'confidence_level']
             if not validate_required_fields(decision_data, required_fields): 
+                print(f"❌ حقول مطلوبة مفقودة في استجابة النموذج لـ {symbol}")
                 return None
 
             strategy_value = decision_data.get('strategy')
@@ -159,28 +184,23 @@ class LLMService:
 
             return decision_data
         except Exception as e:
-            print(f"Error parsing LLM response for {symbol}: {e}")
+            print(f"❌ خطأ في تحليل استجابة النموذج لـ {symbol}: {e}")
             return None
 
     async def _get_pattern_analysis(self, data_payload):
         try:
             symbol = data_payload['symbol']
-            if 'raw_ohlcv' in data_payload and '1h' in data_payload['raw_ohlcv']:
-                ohlcv_data = data_payload['raw_ohlcv']['1h']
-                if ohlcv_data and len(ohlcv_data) >= 20: 
-                    return await self.pattern_engine.analyze_chart_patterns(symbol, ohlcv_data)
+            ohlcv_data = data_payload.get('ohlcv') or data_payload.get('raw_ohlcv')
             
-            if 'advanced_indicators' in data_payload and '1h' in data_payload['advanced_indicators']:
-                ohlcv_data = data_payload['advanced_indicators']['1h']
-                if ohlcv_data and len(ohlcv_data) >= 20: 
-                    return await self.pattern_engine.analyze_chart_patterns(symbol, ohlcv_data)
+            if ohlcv_data:
+                return await self.pattern_engine.analyze_chart_patterns(symbol, ohlcv_data)
             
             return None
         except Exception as e:
-            print(f"Pattern analysis failed for {data_payload.get('symbol')}: {e}")
+            print(f"❌ فشل تحليل الأنماط لـ {data_payload.get('symbol')}: {e}")
             return None
     
-    def _create_enhanced_trading_prompt(self, payload: dict, news_text: str, pattern_analysis: dict) -> str:
+    def _create_comprehensive_trading_prompt(self, payload: dict, news_text: str, pattern_analysis: dict, whale_data: dict) -> str:
         symbol = payload.get('symbol', 'N/A')
         current_price = payload.get('current_price', 'N/A')
         reasons = payload.get('reasons_for_candidacy', [])
@@ -191,88 +211,242 @@ class LLMService:
         target_strategy = payload.get('target_strategy', 'GENERIC')
         final_score = payload.get('final_score', 'N/A')
         enhanced_final_score = payload.get('enhanced_final_score', 'N/A')
-        whale_data = payload.get('whale_data', {})
+        ohlcv_data = payload.get('ohlcv') or payload.get('raw_ohlcv', {})
         
-        final_score_display = f"{final_score:.2f}" if isinstance(final_score, (int, float)) else str(final_score)
-        enhanced_score_display = f"{enhanced_final_score:.2f}" if isinstance(enhanced_final_score, (int, float)) else str(enhanced_final_score)
+        final_score_display = f"{final_score:.3f}" if isinstance(final_score, (int, float)) else str(final_score)
+        enhanced_score_display = f"{enhanced_final_score:.3f}" if isinstance(enhanced_final_score, (int, float)) else str(enhanced_final_score)
 
+        # تنسيق جميع البيانات بشكل شامل
         indicators_summary = format_technical_indicators(advanced_indicators)
         strategies_summary = format_strategy_scores(strategy_scores, recommended_strategy)
         pattern_summary = self._format_pattern_analysis(pattern_analysis)
-        whale_analysis_section = self._format_whale_analysis(sentiment_data.get('general_whale_activity', {}), whale_data, symbol)
+        whale_analysis_section = format_whale_analysis_for_llm(whale_data)
+        candle_data_section = self._format_candle_data_comprehensive(ohlcv_data)
+        market_context_section = self._format_market_context(sentiment_data)
 
         prompt = f"""
-        TRADING ANALYSIS FOR {symbol}
-
-        STRATEGY: {target_strategy}
-        Current Price: {current_price}
-        System Score: {final_score_display}
-        Enhanced Score: {enhanced_score_display}
-
-        CHART PATTERN ANALYSIS:
-        {pattern_summary}
-
-        TECHNICAL INDICATORS:
-        {indicators_summary}
-
-        STRATEGY ANALYSIS:
-        {strategies_summary}
-
-        MARKET CONTEXT:
-        - BTC Trend: {sentiment_data.get('btc_sentiment', 'N/A')}
-        - Fear & Greed: {sentiment_data.get('fear_and_greed_index', 'N/A')}
-
-        WHALE ANALYSIS:
-        {whale_analysis_section}
-
-        NEWS:
-        {news_text}
-
-        OUTPUT (JSON):
-        {{
-            "action": "BUY/SELL/HOLD",
-            "reasoning": "Detailed explanation",
-            "risk_assessment": "Risk analysis",
-            "trade_type": "LONG/SHORT",
-            "stop_loss": 0.0000,
-            "take_profit": 0.0000,
-            "expected_target_minutes": 15,
-            "confidence_level": 0.85,
-            "strategy": "{target_strategy}",
-            "pattern_influence": "Pattern influence description"
-        }}
-        """
+COMPREHENSIVE TRADING ANALYSIS FOR {symbol}
+
+🎯 STRATEGY CONTEXT:
+- Target Strategy: {target_strategy}
+- Recommended Strategy: {recommended_strategy}
+- Current Price: ${current_price}
+- System Score: {final_score_display}
+- Enhanced Score: {enhanced_score_display}
+
+📊 TECHNICAL INDICATORS (ALL TIMEFRAMES):
+{indicators_summary}
+
+📈 CANDLE DATA & PATTERN ANALYSIS:
+{candle_data_section}
+
+🔍 PATTERN ANALYSIS RESULTS:
+{pattern_summary}
+
+🎯 STRATEGY ANALYSIS:
+{strategies_summary}
+
+🐋 WHALE ACTIVITY ANALYSIS:
+{whale_analysis_section}
+
+🌍 MARKET CONTEXT:
+{market_context_section}
+
+📰 LATEST NEWS:
+{news_text if news_text else "No significant news found"}
+
+📋 REASONS FOR CANDIDACY:
+{chr(10).join([f"• {reason}" for reason in reasons]) if reasons else "No specific reasons provided"}
+
+🎯 TRADING DECISION INSTRUCTIONS:
+
+1. ANALYZE ALL PROVIDED DATA: technical indicators, whale activity, patterns, market context
+2. CONSIDER STRATEGY ALIGNMENT: {target_strategy}
+3. EVALUATE RISK-REWARD RATIO based on support/resistance levels
+4. INTEGRATE WHALE ACTIVITY signals into your decision
+5. CONSIDER PATTERN STRENGTH and timeframe confirmations
+6. ASSESS MARKET SENTIMENT impact
+
+CRITICAL: You MUST provide specific price levels and time expectations.
+
+OUTPUT FORMAT (JSON):
+{{
+    "action": "BUY/SELL/HOLD",
+    "reasoning": "Detailed explanation integrating ALL data sources (technical, whale, patterns, news)",
+    "risk_assessment": "low/medium/high",
+    "trade_type": "LONG/SHORT",
+    "stop_loss": 0.000000,
+    "take_profit": 0.000000,
+    "expected_target_minutes": 15,
+    "confidence_level": 0.85,
+    "strategy": "{target_strategy}",
+    "whale_influence": "How whale data influenced the decision",
+    "pattern_influence": "How chart patterns influenced the decision",
+    "key_support_level": 0.000000,
+    "key_resistance_level": 0.000000,
+    "risk_reward_ratio": 2.5
+}}
+"""
         return prompt
 
     def _format_pattern_analysis(self, pattern_analysis):
         if not pattern_analysis: 
-            return "No clear patterns detected"
+            return "No clear patterns detected across analyzed timeframes"
+        
         confidence = pattern_analysis.get('pattern_confidence', 0)
         pattern_name = pattern_analysis.get('pattern_detected', 'unknown')
-        analysis_lines = [f"Pattern: {pattern_name}", f"Confidence: {confidence:.1%}", f"Predicted Move: {pattern_analysis.get('predicted_direction', 'N/A')}", f"Analysis: {pattern_analysis.get('pattern_analysis', 'No detailed analysis')}"]
+        predicted_direction = pattern_analysis.get('predicted_direction', 'N/A')
+        movement_percent = pattern_analysis.get('predicted_movement_percent', 'N/A')
+        
+        analysis_lines = [
+            f"🎯 Pattern: {pattern_name}",
+            f"📊 Confidence: {confidence:.1%}",
+            f"📈 Predicted Direction: {predicted_direction}",
+            f"💰 Expected Movement: {movement_percent}%",
+            f"📝 Analysis: {pattern_analysis.get('pattern_analysis', 'No detailed analysis')}"
+        ]
+        
+        # إضافة مستويات الدعم والمقاومة إذا كانت متوفرة
+        support_levels = pattern_analysis.get('key_support_levels', [])
+        resistance_levels = pattern_analysis.get('key_resistance_levels', [])
+        
+        if support_levels:
+            analysis_lines.append(f"🛟 Support Levels: {', '.join([f'{level:.6f}' for level in support_levels[:3]])}")
+        if resistance_levels:
+            analysis_lines.append(f"🚧 Resistance Levels: {', '.join([f'{level:.6f}' for level in resistance_levels[:3]])}")
+        
         return "\n".join(analysis_lines)
 
-    def _format_whale_analysis(self, general_whale_activity, symbol_whale_data, symbol):
-        from sentiment_news import SentimentAnalyzer
-        temp_analyzer = SentimentAnalyzer(None)
-        return temp_analyzer.format_whale_analysis(general_whale_activity, symbol_whale_data, symbol)
+    def _format_candle_data_comprehensive(self, ohlcv_data):
+        """تنسيق شامل لبيانات الشموع"""
+        if not ohlcv_data:
+            return "No candle data available for analysis"
+        
+        try:
+            timeframes_available = []
+            for timeframe, candles in ohlcv_data.items():
+                if candles and len(candles) >= 20:
+                    timeframes_available.append(f"{timeframe.upper()} ({len(candles)} candles)")
+            
+            if not timeframes_available:
+                return "Insufficient candle data across all timeframes"
+            
+            summary = f"📊 Available Timeframes: {', '.join(timeframes_available)}\n\n"
+            
+            # تحليل لكل إطار زمني رئيسي
+            for timeframe in ['1d', '4h', '1h', '15m']:
+                if timeframe in ohlcv_data and ohlcv_data[timeframe]:
+                    candles = ohlcv_data[timeframe]
+                    if len(candles) >= 20:
+                        timeframe_analysis = self._analyze_timeframe_candles(candles, timeframe)
+                        summary += f"⏰ {timeframe.upper()} ANALYSIS:\n{timeframe_analysis}\n\n"
+            
+            return summary
+        except Exception as e:
+            return f"Error formatting candle data: {str(e)}"
+
+    def _analyze_timeframe_candles(self, candles, timeframe):
+        """تحليل الشموع لإطار زمني محدد"""
+        try:
+            if len(candles) < 20:
+                return "Insufficient data"
+            
+            recent_candles = candles[-20:]  # آخر 20 شمعة
+            
+            # حساب المتغيرات الأساسية
+            closes = [c[4] for c in recent_candles]
+            opens = [c[1] for c in recent_candles]
+            highs = [c[2] for c in recent_candles]
+            lows = [c[3] for c in recent_candles]
+            volumes = [c[5] for c in recent_candles]
+            
+            current_price = closes[-1]
+            first_price = closes[0]
+            price_change = ((current_price - first_price) / first_price) * 100
+            
+            # تحليل الاتجاه
+            if price_change > 2:
+                trend = "🟢 UPTREND"
+            elif price_change < -2:
+                trend = "🔴 DOWNTREND"
+            else:
+                trend = "⚪ SIDEWAYS"
+            
+            # تحليل التقلب
+            high_max = max(highs)
+            low_min = min(lows)
+            volatility = ((high_max - low_min) / low_min) * 100
+            
+            # تحليل الحجم
+            avg_volume = sum(volumes) / len(volumes)
+            current_volume = volumes[-1]
+            volume_ratio = current_volume / avg_volume if avg_volume > 0 else 1
+            
+            # تحليل الشموع
+            green_candles = sum(1 for i in range(len(closes)) if closes[i] > opens[i])
+            red_candles = len(closes) - green_candles
+            candle_ratio = green_candles / len(closes)
+            
+            analysis = [
+                f"📈 Trend: {trend} ({price_change:+.2f}%)",
+                f"🌊 Volatility: {volatility:.2f}%",
+                f"📦 Volume: {volume_ratio:.2f}x average",
+                f"🕯️ Candles: {green_candles}🟢/{red_candles}🔴 ({candle_ratio:.1%} green)",
+                f"💰 Range: {low_min:.6f} - {high_max:.6f}",
+                f"🎯 Current: {current_price:.6f}"
+            ]
+            
+            return "\n".join(analysis)
+        except Exception as e:
+            return f"Analysis error: {str(e)}"
+
+    def _format_market_context(self, sentiment_data):
+        """تنسيق سياق السوق"""
+        if not sentiment_data:
+            return "No market context data available"
+        
+        btc_sentiment = sentiment_data.get('btc_sentiment', 'N/A')
+        fear_greed = sentiment_data.get('fear_and_greed_index', 'N/A')
+        market_trend = sentiment_data.get('market_trend', 'N/A')
+        
+        lines = [
+            "🌍 MARKET CONTEXT:",
+            f"• Bitcoin Sentiment: {btc_sentiment}",
+            f"• Fear & Greed Index: {fear_greed}",
+            f"• Market Trend: {market_trend}"
+        ]
+        
+        general_whale = sentiment_data.get('general_whale_activity', {})
+        if general_whale:
+            whale_sentiment = general_whale.get('sentiment', 'N/A')
+            critical_alert = general_whale.get('critical_alert', False)
+            lines.append(f"• General Whale Sentiment: {whale_sentiment}")
+            if critical_alert:
+                lines.append("• ⚠️ CRITICAL WHALE ALERT")
+        
+        return "\n".join(lines)
 
     async def re_analyze_trade_async(self, trade_data: dict, processed_data: dict):
         try:
             symbol = trade_data['symbol']
             original_strategy = trade_data.get('strategy', 'GENERIC')
             
+            # جلب جميع البيانات المحدثة
             news_text = await self.news_fetcher.get_news_for_symbol(symbol)
             pattern_analysis = await self._get_pattern_analysis(processed_data)
-            prompt = self._create_re_analysis_prompt(trade_data, processed_data, news_text, pattern_analysis)
+            whale_data = processed_data.get('whale_data', {})
             
-            # ✅ حفظ الـ Prompt في R2 قبل إرساله للنموذج
+            prompt = self._create_re_analysis_prompt(trade_data, processed_data, news_text, pattern_analysis, whale_data)
+            
+            # ✅ حفظ الـ Prompt في R2
             if self.r2_service:
                 analysis_data = {
+                    'symbol': symbol,
                     'entry_price': trade_data.get('entry_price'),
                     'current_price': processed_data.get('current_price'),
                     'original_strategy': original_strategy,
-                    'pattern_analysis': pattern_analysis
+                    'pattern_analysis': pattern_analysis,
+                    'whale_data_available': whale_data.get('data_available', False)
                 }
                 await self.r2_service.save_llm_prompts_async(
                     symbol, 'trade_reanalysis', prompt, analysis_data
@@ -284,15 +458,15 @@ class LLMService:
             re_analysis_dict = self._parse_re_analysis_response(response, original_strategy, symbol)
             if re_analysis_dict:
                 re_analysis_dict['model_source'] = self.model_name
+                re_analysis_dict['whale_data_integrated'] = whale_data.get('data_available', False)
                 return re_analysis_dict
             else:
-                # ❌ لا نستخدم أي محاكاة - نرجع None في حالة الفشل
-                print(f"❌ فشل إعادة تحليل النموذج الضخم لـ {symbol} - لا توجد قرارات بديلة")
+                print(f"❌ فشل إعادة تحليل النموذج الضخم لـ {symbol}")
                 return None
                 
         except Exception as e:
             print(f"❌ خطأ في إعادة تحليل LLM: {e}")
-            # ❌ لا نستخدم أي محاكاة
+            traceback.print_exc()
             return None
 
     def _parse_re_analysis_response(self, response_text: str, fallback_strategy: str, symbol: str) -> dict:
@@ -311,7 +485,7 @@ class LLMService:
             print(f"Error parsing re-analysis response for {symbol}: {e}")
             return None
 
-    def _create_re_analysis_prompt(self, trade_data: dict, processed_data: dict, news_text: str, pattern_analysis: dict) -> str:
+    def _create_re_analysis_prompt(self, trade_data: dict, processed_data: dict, news_text: str, pattern_analysis: dict, whale_data: dict) -> str:
         symbol = trade_data.get('symbol', 'N/A')
         entry_price = trade_data.get('entry_price', 'N/A')
         current_price = processed_data.get('current_price', 'N/A')
@@ -325,41 +499,56 @@ class LLMService:
             
         indicators_summary = format_technical_indicators(processed_data.get('advanced_indicators', {}))
         pattern_summary = self._format_pattern_analysis(pattern_analysis)
-        whale_analysis_section = self._format_whale_analysis(processed_data.get('sentiment_data', {}).get('general_whale_activity', {}), processed_data.get('whale_data', {}), symbol)
+        whale_analysis_section = format_whale_analysis_for_llm(whale_data)
+        market_context_section = self._format_market_context(processed_data.get('sentiment_data', {}))
 
         prompt = f"""
-        TRADE RE-ANALYSIS FOR {symbol}
-
-        TRADE CONTEXT:
-        - Strategy: {strategy}
-        - Entry Price: {entry_price}
-        - Current Price: {current_price}
-        - Performance: {price_change_display}
-
-        UPDATED PATTERN ANALYSIS:
-        {pattern_summary}
-
-        UPDATED TECHNICALS:
-        {indicators_summary}
-
-        UPDATED WHALE DATA:
-        {whale_analysis_section}
-
-        LATEST NEWS:
-        {news_text}
-
-        OUTPUT (JSON):
-        {{
-            "action": "HOLD/CLOSE_TRADE/UPDATE_TRADE",
-            "reasoning": "Justification",
-            "new_stop_loss": 0.0000,
-            "new_take_profit": 0.0000,
-            "new_expected_minutes": 15,
-            "confidence_level": 0.85,
-            "strategy": "{strategy}",
-            "pattern_influence_reanalysis": "Pattern influence description"
-        }}
-        """
+TRADE RE-ANALYSIS FOR {symbol}
+
+📊 TRADE CONTEXT:
+- Strategy: {strategy}
+- Entry Price: {entry_price}
+- Current Price: {current_price}
+- Performance: {price_change_display}
+- Trade Age: {trade_data.get('hold_duration_minutes', 'N/A')} minutes
+
+🔄 UPDATED TECHNICAL ANALYSIS:
+{indicators_summary}
+
+📈 UPDATED PATTERN ANALYSIS:
+{pattern_summary}
+
+🐋 UPDATED WHALE ACTIVITY:
+{whale_analysis_section}
+
+🌍 UPDATED MARKET CONTEXT:
+{market_context_section}
+
+📰 LATEST NEWS:
+{news_text if news_text else "No significant news found"}
+
+🎯 RE-ANALYSIS INSTRUCTIONS:
+
+1. Evaluate if the original thesis still holds
+2. Consider new whale activity and patterns
+3. Assess current risk-reward ratio
+4. Decide whether to hold, close, or adjust the trade
+5. Provide specific updated levels if adjusting
+
+OUTPUT FORMAT (JSON):
+{{
+    "action": "HOLD/CLOSE_TRADE/UPDATE_TRADE",
+    "reasoning": "Comprehensive justification based on updated analysis",
+    "new_stop_loss": 0.000000,
+    "new_take_profit": 0.000000,
+    "new_expected_minutes": 15,
+    "confidence_level": 0.85,
+    "strategy": "{strategy}",
+    "whale_influence_reanalysis": "How updated whale data influenced decision",
+    "pattern_influence_reanalysis": "How updated patterns influenced decision",
+    "risk_adjustment": "low/medium/high"
+}}
+"""
         return prompt
 
     @_rate_limit_nvidia_api
@@ -369,12 +558,15 @@ class LLMService:
                 model=self.model_name,
                 messages=[{"role": "user", "content": prompt}],
                 temperature=self.temperature,
-                seed=42
+                seed=42,
+                max_tokens=4000
             )
             return response.choices[0].message.content
         except (RateLimitError, APITimeoutError) as e:
-            print(f"LLM API Error: {e}. Retrying...")
+            print(f"❌ LLM API Error: {e}. Retrying...")
             raise
         except Exception as e:
-            print(f"Unexpected LLM API error: {e}")
-            raise
+            print(f"❌ Unexpected LLM API error: {e}")
+            raise
+
+print("✅ LLM Service loaded - Comprehensive Analysis with Whale Data & Pattern Integration")