mql5/Experts/Examples/PullbackTradingEA.mq5

//+------------------------------------------------------------------+
//|                                                         PullbackTradingEA.mq5 |
//|                        Copyright 2023, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

//--- Include necessary libraries
#include <Trade/Trade.mqh>

//--- EA Input Parameters
input bool   EnableEA = true;          // Enable/Disable the EA

//--- Timeframe validation
input bool   AllowOnlyM15 = true;      // Restrict to M15 timeframe only

//--- Trend Indicators
input int    EMA50_Period = 50;        // EMA50 Period
input int    EMA200_Period = 200;      // EMA200 Period
input double Min_EMA_Distance_Pct = 0.03;   // Minimum EMA distance percentage (reduced for more signals)
input bool Allow_Counter_Trend_With_Confirmation = false; // Allow counter-trend trades with strong confirmation
input bool Allow_Trading_In_Sideways_Market = true; // Allow trading even in sideways market

//--- UT Bot Parameters
input int    UT_ATR_Period = 14;       // ATR period for UT Bot
input double UT_ATR_Multiplier = 0.8;  // ATR multiplier for UT Bot (reduced for more signals)
input int    UT_Sensitivity = 1;       // UT Bot sensitivity
input bool   DebugMode = true;         // Enable detailed logging for debugging

//--- MACD Parameters
input int    MACD_Fast = 12;           // MACD Fast period
input int    MACD_Slow = 26;           // MACD Slow period
input int    MACD_Signal = 9;          // MACD Signal period

//--- Volume Parameters
input int    Volume_MA_Period = 20;    // Volume SMA period
input double Volume_Min_Ratio = 0.9;   // Minimum volume ratio (reduced for more signals)

//--- ATR Parameters
input int    ATR_Period = 14;          // ATR period
input double ATR_Min = 3.0;            // Minimum ATR value (reduced for more signals)

//--- News Filter Parameters
input bool   UseNewsFilter = true;     // Enable/Disable news filter
input string NewsTimes = "";           // News times in format "yyyy.MM.dd HH:MI;..."
input int    MinutesBefore = 30;       // Minutes before news to block trading
input int    MinutesAfter = 60;        // Minutes after news to block trading

//--- Pullback Parameters
input bool   Enable_EMA50_Pullback = true;     // Enable EMA50 pullback
input bool   Enable_Midpoint_Pullback = true;  // Enable midpoint pullback
input bool   Enable_MACD_Pullback = true;      // Enable MACD pullback
input double EMA50_Pullback_Tolerance = 3.0;   // EMA50 pullback tolerance (USD) - increased for more signals
input double Midpoint_Pullback_Tolerance = 3.0; // Midpoint pullback tolerance (USD) - increased for more signals

//--- Risk Management
input double SL_Multiplier = 1.5;      // SL multiplier for ATR
input double RiskRewardRatio = 2.0;    // Risk/Reward ratio for TP
input double Risk_Per_Trade_Percent = 1.0;    // Maximum risk per trade (%)
input int       SL_Type               = 0;              // SL Type (0=Fixed ATR, 1=Dynamic ATR, 2=Swing Low/High)
input int       TP_Type               = 0;              // TP Type (0=Fixed RR, 1=Multi-Target, 2=Support/Resistance)
input bool      Enable_Partial_TP     = true;           // Enable partial take profit
input double    TP1_Close_Percent     = 40.0;           // Percent to close at first target
input double    TP2_Close_Percent     = 30.0;           // Percent to close at second target
input double    TP3_Close_Percent     = 30.0;           // Percent to close at third target
input double    TP1_RR_Ratio          = 1.2;            // Risk-Reward ratio for TP1
input double    TP2_RR_Ratio          = 2.0;            // Risk-Reward ratio for TP2
input double    TP3_RR_Ratio          = 3.0;            // Risk-Reward ratio for TP3
input bool      Enable_Trend_Exit     = true;           // Enable trend reversal exit

//--- Signal Strength & Risk Adjustment
input double    Strong_Signal_Threshold = 0.8;          // Signal strength threshold for increasing risk
input double    Weak_Signal_Threshold   = 0.5;          // Signal strength threshold for decreasing risk
input double    Strong_Signal_Risk_Boost = 0.1;         // Additional risk percentage for strong signals (0.1 = 10% more)
input double    Weak_Signal_Risk_Reduction = 0.2;       // Risk reduction percentage for weak signals (0.2 = 20% less)
input double    High_Volatility_Threshold = 1.8;        // ATR ratio threshold for high volatility risk reduction
input double    Extreme_Volatility_Threshold = 2.5;     // ATR ratio threshold for extreme volatility risk reduction
input double    High_Volatility_Risk_Multiplier = 0.7;  // Risk multiplier during high volatility
input double    Extreme_Volatility_Risk_Multiplier = 0.5; // Risk multiplier during extreme volatility
input double    Drawdown_Protection_Threshold = 0.7;    // Drawdown percentage (of max drawdown) to trigger protection
input double    Drawdown_Protection_Multiplier = 0.7;   // Risk multiplier during drawdown protection
input double    Leverage_Warning_Threshold = 0.75;      // Leverage usage percentage to trigger risk reduction
input double    Min_Lot_Size          = 0.01;           // Minimum lot size
input double    Max_Lot_Size          = 10.0;           // Maximum lot size
input double    Max_Daily_Risk_Percent = 3.0;            // Maximum risk per day (%)
input double    Max_Drawdown_Percent  = 10.0;           // Maximum allowed drawdown (%)

//--- Position Management
input bool      Enable_Position_Age_Limit = true;        // Enable position age limit
input int       Max_Losing_Position_Minutes = 60;        // Maximum time to hold losing position (minutes)
input int       Max_Winning_Position_Minutes = 240;      // Maximum time to hold winning position (minutes)
input int       Min_Hold_Minutes = 15;                   // Minimum hold time to prevent excessive trading (minutes)
input int       Max_Open_Trades = 2;                     // Maximum number of open trades allowed
input double    ATR_Profit_Multiplier = 2.5;            // ATR multiplier for dynamic profit target
input bool      Enable_Reversal_Exit = true;             // Enable exit on reversal signals
input double    Max_Allowed_Loss_Percent = 2.0;          // Maximum allowed loss percentage per trade
input bool      Close_On_High_Volatility = true;         // Close positions on high volatility
input double    Volatility_Threshold_Multiplier = 2.5;   // ATR multiplier for high volatility threshold

//--- Trailing Stop
input bool   UseTrailingStop = true;   // Enable trailing stop
input int    TrailingStopType = 2;     // 0=Fixed pips, 1=ATR based, 2=Dynamic (推荐)
input double TrailingStopPips = 10.0;  // Trailing stop distance (pips)
input double TrailingATRMultiplier = 2.0; // ATR multiplier for trailing stop
input double TrailingDynamicFactor = 0.2; // Dynamic factor (0.1-1.0) for volatility adjustment
input bool   UsePartialTakeProfit = true; // Enable partial take profit (using multi-target strategy)
input bool   UseAdaptiveTrailingTightening = true; // Enable adaptive tightening of trailing stop when profit is high
input bool   UseGlobalProfitTargets = true;          // Use global profit targets for partial take profit

//--- Function Prototypes (Forward Declarations)
enum TrendDirection {TREND_NONE, TREND_UP, TREND_DOWN};
TrendDirection GetTrendDirection();
bool IsSidewaysMarket();
bool IsMACDConfirmed(const bool is_buy_signal);
bool IsVolumeSufficient();
bool IsATRVolatilitySufficient();
bool IsNewsEventNearby();
bool IsPullbackConditionMet(const bool is_buy_signal);
bool IsEMA50Pullback(const bool is_buy_signal);
bool IsMidpointPullback(const bool is_buy_signal);
bool IsMACDPullback(const bool is_buy_signal);
bool ApplyPreEntryFilters(const bool is_buy_signal);
double GetEMA50(const int shift = 0);
double GetEMA200(const int shift = 0);
bool GetMACDValues(double &main[], double &signal[], double &histogram[], const int shift = 0);
double GetVolumeMA(const int shift = 0);
double GetATR(const int shift = 0);
long GetCurrentVolume(const int shift = 0);

//--- Global Variables
CTrade trade;                          // Trade object

//--- Trailing stop variables
double last_trailing_level_buy = 0.0;  // Last trailing level for buy positions
double last_trailing_level_sell = 0.0; // Last trailing level for sell positions

//--- Multi-target TP tracking variables
double global_tp1_price = 0.0;
double global_tp2_price = 0.0;
double global_tp3_price = 0.0;

//--- Indicator Handles
int handle_ema50;                      // EMA50 handle
int handle_ema200;                     // EMA200 handle
int handle_macd;                       // MACD handle
int handle_volume_ma;                  // Volume SMA handle
int handle_atr;                        // ATR handle

//--- UT Bot variables
double prev_ut_buy_signal = 0;
double prev_ut_sell_signal = 0;

//--- Pullback tracking
double ut_signal_candle_high = 0;
double ut_signal_candle_low = 0;
double ut_signal_candle_midpoint = 0;
bool waiting_for_pullback = false;

//--- Risk management variables
double account_balance = 0.0;
double account_equity = 0.0;
double daily_risk_used = 0.0;
int last_reset_day = 0;
int last_reset_day_year = 0;

//--- Signal tracking variables
bool is_ut_bot_signal = false;
int signal_direction = 0; // 1=Buy, -1=Sell, 0=None
datetime signal_candle_time = 0;
double signal_candle_open = 0.0;
double signal_candle_high = 0.0;
double signal_candle_low = 0.0;
double signal_candle_close = 0.0;

//--- Position management variables
int active_trades_buy = 0;             // Number of active BUY trades
int active_trades_sell = 0;            // Number of active SELL trades
int total_open_trades = 0;             // Total number of open trades
double position_profit = 0.0;          // Current position profit
int position_age_minutes = 0;          // Age of position in minutes
double atr_value = 0.0;                // Current ATR value
double avg_atr_20 = 0.0;               // 20-period average ATR (for volatility comparison)
bool trend_reversal_detected = false;  // Flag for trend reversal detection
double volatility_threshold = 0.0;     // Calculated volatility threshold for position closure
bool position_close_requested = false; // Flag to request position closure

//--- Pullback strategy performance tracking variables
double g_ema50_strategy_performance = 0.5;  // Performance score (0-1) for EMA50 strategy
double g_midpoint_strategy_performance = 0.5; // Performance score (0-1) for Midpoint strategy
double g_macd_strategy_performance = 0.5;     // Performance score (0-1) for MACD strategy
int g_ema50_trades_count = 0;                 // Number of trades taken with EMA50 confirmation
int g_midpoint_trades_count = 0;              // Number of trades taken with Midpoint confirmation
int g_macd_trades_count = 0;                  // Number of trades taken with MACD confirmation
int g_ema50_winning_trades = 0;               // Number of winning trades for EMA50 strategy
int g_midpoint_winning_trades = 0;            // Number of winning trades for Midpoint strategy
int g_macd_winning_trades = 0;                // Number of winning trades for MACD strategy

//--- Trade tracking variables
bool g_last_ema50_pullback = false;           // Last EMA50 pullback confirmation
bool g_last_midpoint_pullback = false;        // Last Midpoint pullback confirmation
bool g_last_macd_pullback = false;            // Last MACD pullback confirmation
double g_last_entry_price = 0.0;              // Last trade entry price
int g_last_trade_type = 0;                    // Last trade type (0=none, 1=buy, 2=sell)

//--- Constants
const int EA_Magic_Number = 20231114;  // EA Magic Number
const int SignalTimeout = 24;          // Signal timeout in hours
enum PullbackDirection {NONE, BUY, SELL};
PullbackDirection current_pullback_direction = NONE;

//--- Variables already declared above

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   // Initialize daily risk tracking
   datetime now = TimeCurrent();
   last_reset_day = TimeDayOfYear(now);
   last_reset_day_year = TimeYear(now);
   daily_risk_used = 0.0;
   

  }

//+------------------------------------------------------------------+
//| Calculate signal strength based on multiple indicators          |
//+------------------------------------------------------------------+
double CalculateSignalStrength(bool is_buy_signal)
  {
   double strength = 0.5; // Start with neutral strength
   
   // Get trend information
   TrendDirection trend = GetTrendDirection();
   double trend_strength = GetTrendStrength();
   
   // Get MACD values
   MACDValues macd = GetMACDValues();
   
   // Get volume information
   double current_volume = GetCurrentVolume();
   double volume_ma = GetVolumeMA();
   
   // Get price action information
   double ema50 = GetEMA50();
   double ema200 = GetEMA200();
   
   // Factor 1: Trend alignment (+0.2 points)
   if((trend == TREND_UP && is_buy_signal) || (trend == TREND_DOWN && !is_buy_signal))
     strength += 0.2;
   else if((trend == TREND_UP && !is_buy_signal) || (trend == TREND_DOWN && is_buy_signal))
     strength -= 0.1; // Slight penalty for counter-trend trades
   
   // Factor 2: Trend strength (+0 to 0.2 points)
   strength += trend_strength * 0.2;
   
   // Factor 3: MACD confirmation (+0 to 0.2 points)
   if((is_buy_signal && macd.histogram > 0) || (!is_buy_signal && macd.histogram < 0))
     {
      // Scale histogram contribution based on its absolute value
      double histo_strength = MathMin(MathAbs(macd.histogram) * 10000, 1.0);
      strength += histo_strength * 0.2;
      
      // Additional bonus for MACD line crossover
      if((is_buy_signal && macd.macd > macd.signal) || (!is_buy_signal && macd.macd < macd.signal))
        strength += 0.1;
     }
   
   // Factor 4: Volume confirmation (+0 to 0.15 points)
   if(volume_ma > 0 && current_volume > volume_ma)
     {
      double volume_ratio = MathMin(current_volume / volume_ma, 2.0);
      strength += (volume_ratio - 1.0) * 0.15;
     }
   
   // Factor 5: EMA position confirmation (+0 to 0.15 points)
   if(is_buy_signal && ema50 > ema200) // Golden cross alignment
     strength += 0.15;
   else if(!is_buy_signal && ema50 < ema200) // Death cross alignment
     strength += 0.15;
   
   // Clamp strength to 0-1 range
   strength = MathMax(0.0, MathMin(1.0, strength));
   
   return strength;
  }

//+------------------------------------------------------------------+
//|    // Initialize max equity tracking
   GetMaxAccountEquity(); // This will set the initial max equity value
//--- Check if the timeframe is M15 when restriction is enabled
   if(AllowOnlyM15 && Period() != PERIOD_M15)
     {
      Alert("Error: EA must run on M15 timeframe only!");
      return(INIT_FAILED);
     }

//--- Initialize indicators
   handle_ema50 = iMA(_Symbol, PERIOD_M15, EMA50_Period, 0, MODE_EMA, PRICE_CLOSE);
   handle_ema200 = iMA(_Symbol, PERIOD_M15, EMA200_Period, 0, MODE_EMA, PRICE_CLOSE);
   handle_macd = iMACD(_Symbol, PERIOD_M15, MACD_Fast, MACD_Slow, MACD_Signal, PRICE_CLOSE);
   handle_volume_ma = iMA(_Symbol, PERIOD_M15, Volume_MA_Period, 0, MODE_SMA, VOLUME_TICK);
   handle_atr = iATR(_Symbol, PERIOD_M15, ATR_Period);

//--- Check if indicators were created successfully
   if(handle_ema50 == INVALID_HANDLE || handle_ema200 == INVALID_HANDLE || 
      handle_macd == INVALID_HANDLE || handle_volume_ma == INVALID_HANDLE || 
      handle_atr == INVALID_HANDLE)
     {
      Alert("Error: Failed to initialize indicators!");
      return(INIT_FAILED);
     }

//--- Set trade parameters
   trade.SetExpertMagicNumber(20231114);
   trade.SetTypeFilling(ORDER_FILLING_FOK);

//---
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Destroy indicator handles
   if(handle_ema50 != INVALID_HANDLE) IndicatorRelease(handle_ema50);
   if(handle_ema200 != INVALID_HANDLE) IndicatorRelease(handle_ema200);
   if(handle_macd != INVALID_HANDLE) IndicatorRelease(handle_macd);
   if(handle_volume_ma != INVALID_HANDLE) IndicatorRelease(handle_volume_ma);
   if(handle_atr != INVALID_HANDLE) IndicatorRelease(handle_atr);
  }

//+------------------------------------------------------------------+
//| Check trend direction using EMA50 and EMA200                      |
//+------------------------------------------------------------------+
TrendDirection GetTrendDirection()
  {
   // Use current bar's EMAs instead of previous bar
   double ema50 = GetEMA50(0);
   double ema200 = GetEMA200(0);
   
   if(ema50 == 0 || ema200 == 0)
     {
      Print("Warning: Invalid EMA values (ema50=", ema50, ", ema200=", ema200, ")");
      return(TREND_NONE);
     }
   
   // Always determine trend direction regardless of distance
   if(ema50 > ema200)
      return(TREND_UP);
   else
      return(TREND_DOWN);
  }

//+------------------------------------------------------------------+
//| Check if market is sideways based on EMA distance                 |
//+------------------------------------------------------------------+
bool IsSidewaysMarket()
  {
   double ema50 = GetEMA50(0);
   double ema200 = GetEMA200(0);
   
   if(ema50 == 0 || ema200 == 0)
      return(false);
   
   double ema_distance = MathAbs(ema50 - ema200);
   double price_base = (ema50 + ema200) / 2.0; // Use average of EMAs as price base
   double ema_distance_pct = (ema_distance / price_base) * 100.0; // Convert to percentage
   
   Print("EMA distance: ", ema_distance_pct, "%, Min threshold: ", Min_EMA_Distance_Pct, "%");
   
   return(ema_distance_pct < Min_EMA_Distance_Pct);
  }

//+------------------------------------------------------------------+
//| Check MACD momentum confirmation                                 |
//+------------------------------------------------------------------+
bool IsMACDConfirmed(const bool is_buy_signal)
  {
   double main[1], signal[1], histogram[1];
   double main_prev[1], signal_prev[1], histogram_prev[1];
   
   if(!GetMACDValues(main, signal, histogram, 0) || !GetMACDValues(main_prev, signal_prev, histogram_prev, 1))
     {
      Print("Failed to get MACD values");
      return(false);
     }
   
   // Log MACD values for debugging
   Print("MACD values - Main: ", main[0], ", Signal: ", signal[0], ", Histogram: ", histogram[0]);
   
   if(is_buy_signal)
     {
      // For Buy signal confirmation - simplified conditions
      bool main_above_signal = main[0] > signal[0];
      bool positive_histogram = histogram[0] >= 0;
      bool improving = histogram[0] >= histogram_prev[0];
      
      Print("MACD buy confirmation - Main above signal: ", main_above_signal, 
            ", Positive histogram: ", positive_histogram, ", Improving: ", improving);
      
      return(main_above_signal && (positive_histogram || improving));
     }
   else
     {
      // For Sell signal confirmation - simplified conditions
      bool main_below_signal = main[0] < signal[0];
      bool negative_histogram = histogram[0] <= 0;
      bool improving = histogram[0] <= histogram_prev[0];
      
      Print("MACD sell confirmation - Main below signal: ", main_below_signal, 
            ", Negative histogram: ", negative_histogram, ", Improving: ", improving);
      
      return(main_below_signal && (negative_histogram || improving));
     }
  }

//+------------------------------------------------------------------+
//| Check volume filter                                              |
//+------------------------------------------------------------------+
bool IsVolumeSufficient()
  {
   long current_volume = GetCurrentVolume(0); // Use current bar instead of previous
   double volume_ma = GetVolumeMA(0);
   
   // Log volume information
   Print("Volume check - Current: ", current_volume, ", MA: ", volume_ma, ", Min ratio: ", Volume_Min_Ratio);
   
   if(current_volume == 0 || volume_ma == 0)
     {
      Print("Invalid volume values");
      return(false);
     }
   
   bool sufficient = current_volume >= (volume_ma * Volume_Min_Ratio);
   Print("Volume sufficient: ", sufficient);
   return(sufficient);
  }

//+------------------------------------------------------------------+
//| Check ATR volatility filter                                      |
//+------------------------------------------------------------------+
bool IsATRVolatilitySufficient()
  {
   double atr_value = GetATR(0); // Use current bar instead of previous
   
   // Log ATR information
   Print("ATR volatility check - Value: ", atr_value, ", Min required: ", ATR_Min);
   
   if(atr_value == 0)
     {
      Print("Invalid ATR value");
      return(false);
     }
   
   bool sufficient = atr_value >= ATR_Min;
   Print("ATR volatility sufficient: ", sufficient);
   return(sufficient);
  }

//+------------------------------------------------------------------+
//| Check if current time is during news event                       |
//+------------------------------------------------------------------+
bool IsDuringNewsEvent()
  {
   if(!UseNewsFilter || NewsTimes == "")
      return(false);
   
   datetime current_time = TimeCurrent();
   string separator = ";";
   int pos = 0;
   string news_time_str;
   
   // Parse semicolon-separated news times
   string news_times_copy = NewsTimes; // Create a copy to modify
   while((pos = StringFind(news_times_copy, separator, pos)) >= 0)
     {
      news_time_str = StringSubstr(news_times_copy, 0, pos);
      news_times_copy = StringSubstr(news_times_copy, pos + 1);
      pos = 0;
      
      // Convert string to datetime
      datetime news_time = StringToTime(news_time_str);
      if(news_time != 0)
        {
         // Check if current time is within the news window
         datetime start_time = news_time - (MinutesBefore * 60);
         datetime end_time = news_time + (MinutesAfter * 60);
         
         if(current_time >= start_time && current_time <= end_time)
            return(true);
        }
     }
   
   // Check the last news time
   if(NewsTimes != "")
     {
      datetime news_time = StringToTime(NewsTimes);
      if(news_time != 0)
        {
         datetime start_time = news_time - (MinutesBefore * 60);
         datetime end_time = news_time + (MinutesAfter * 60);
         
         if(current_time >= start_time && current_time <= end_time)
            return(true);
        }
     }
   
   return(false);
  }

//+------------------------------------------------------------------+
//| Check for EMA50 pullback                                         |
//+------------------------------------------------------------------+
bool IsEMA50Pullback(const bool is_buy_signal)
  {
   if(!Enable_EMA50_Pullback)
      return(false);
   
   // Get essential values
   double ema50 = GetEMA50(0);
   if(ema50 == 0)
      return(false);
   
   double ema50_prev = GetEMA50(1);
   double current_close = iClose(_Symbol, PERIOD_M15, 0);
   double prev_close = iClose(_Symbol, PERIOD_M15, 1);
   double current_high = iHigh(_Symbol, PERIOD_M15, 0);
   double current_low = iLow(_Symbol, PERIOD_M15, 0);
   double prev_high = iHigh(_Symbol, PERIOD_M15, 1);
   double prev_low = iLow(_Symbol, PERIOD_M15, 1);
   
   // Get volatility metrics
   double atr = GetATR(0);
   double atr_avg_20 = iATR(_Symbol, PERIOD_M15, 20, 0);
   double volatility_ratio = atr > 0 ? atr / atr_avg_20 : 1.0;
   
   // Dynamic tolerance based on volatility and trend
   double base_tolerance = MathMax(atr * 0.7, EMA50_Pullback_Tolerance);
   double dynamic_tolerance = base_tolerance * (1.0 + (volatility_ratio - 1.0) * 0.5); // Adjust by 50% of volatility deviation
   
   // Get trend strength
   double trend_strength = GetTrendStrength();
   
   // Adjust tolerance based on trend strength
   if(trend_strength > 0.7) dynamic_tolerance *= 0.8; // Tighter tolerance in strong trends
   else if(trend_strength < 0.4) dynamic_tolerance *= 1.2; // Wider tolerance in weak trends
   
   if(is_buy_signal)
     {
      // Check for pullback to EMA50 in uptrend
      bool price_near_ema50 = current_close >= ema50 - dynamic_tolerance * 1.5 && current_close <= ema50 + dynamic_tolerance * 0.5;
      bool low_tested_ema50 = current_low <= ema50 + dynamic_tolerance * 0.5;
      bool prev_low_tested_ema50 = prev_low <= ema50 + dynamic_tolerance * 0.5;
      
      // Price action confirmation
      bool bullish_candlestick = current_close > current_open;
      bool bullish_close = current_close > prev_close;
      bool price_rejection = low_tested_ema50 && current_close > current_low + (current_high - current_low) * 0.6;
      
      // Trend alignment
      bool ema50_sloping_up = ema50 > ema50_prev;
      
      // Combine conditions with weighted importance
      bool touched_ema50_zone = price_near_ema50 || low_tested_ema50 || prev_low_tested_ema50;
      bool bullish_confirmation = bullish_candlestick || bullish_close || price_rejection;
      
      // Final decision with trend consideration
      bool result = touched_ema50_zone && (bullish_confirmation || (trend_strength > 0.6 && ema50_sloping_up));
      
      // Enhanced logging
      if(DebugMode)
        {
         Print("EMA50 Buy Check - Price near EMA50: ", price_near_ema50, ", Low tested: ", low_tested_ema50, ", Prev low tested: ", prev_low_tested_ema50);
         Print("EMA50 Buy Check - Bullish candle: ", bullish_candlestick, ", Bullish close: ", bullish_close, ", Price rejection: ", price_rejection);
         Print("EMA50 Buy Check - EMA50 sloping up: ", ema50_sloping_up, ", Trend strength: ", trend_strength);
         Print("EMA50 Buy Check - Result: ", result, ", Dynamic tolerance: ", dynamic_tolerance, ", Volatility ratio: ", volatility_ratio);
        }
      
      return(result);
     }
   else
     {
      // Check for pullback to EMA50 in downtrend
      bool price_near_ema50 = current_close >= ema50 - dynamic_tolerance * 0.5 && current_close <= ema50 + dynamic_tolerance * 1.5;
      bool high_tested_ema50 = current_high >= ema50 - dynamic_tolerance * 0.5;
      bool prev_high_tested_ema50 = prev_high >= ema50 - dynamic_tolerance * 0.5;
      
      // Price action confirmation
      bool bearish_candlestick = current_close < current_open;
      bool bearish_close = current_close < prev_close;
      bool price_rejection = high_tested_ema50 && current_close < current_high - (current_high - current_low) * 0.6;
      
      // Trend alignment
      bool ema50_sloping_down = ema50 < ema50_prev;
      
      // Combine conditions with weighted importance
      bool touched_ema50_zone = price_near_ema50 || high_tested_ema50 || prev_high_tested_ema50;
      bool bearish_confirmation = bearish_candlestick || bearish_close || price_rejection;
      
      // Final decision with trend consideration
      bool result = touched_ema50_zone && (bearish_confirmation || (trend_strength > 0.6 && ema50_sloping_down));
      
      // Enhanced logging
      if(DebugMode)
        {
         Print("EMA50 Sell Check - Price near EMA50: ", price_near_ema50, ", High tested: ", high_tested_ema50, ", Prev high tested: ", prev_high_tested_ema50);
         Print("EMA50 Sell Check - Bearish candle: ", bearish_candlestick, ", Bearish close: ", bearish_close, ", Price rejection: ", price_rejection);
         Print("EMA50 Sell Check - EMA50 sloping down: ", ema50_sloping_down, ", Trend strength: ", trend_strength);
         Print("EMA50 Sell Check - Result: ", result, ", Dynamic tolerance: ", dynamic_tolerance, ", Volatility ratio: ", volatility_ratio);
        }
      
      return(result);
     }
  }

//+------------------------------------------------------------------+
//| Check for midpoint pullback                                      |
//+------------------------------------------------------------------+
bool IsMidpointPullback(const bool is_buy_signal)
  {
   if(!Enable_Midpoint_Pullback || ut_signal_candle_midpoint == 0)
      return(false);
   
   // Get essential price data
   double current_price = iClose(_Symbol, PERIOD_M15, 0);
   double prev_price = iClose(_Symbol, PERIOD_M15, 1);
   double current_high = iHigh(_Symbol, PERIOD_M15, 0);
   double current_low = iLow(_Symbol, PERIOD_M15, 0);
   double current_open = iOpen(_Symbol, PERIOD_M15, 0);
   
   // Get volatility metrics
   double atr = GetATR(0);
   double atr_avg_20 = iATR(_Symbol, PERIOD_M15, 20, 0);
   double volatility_ratio = atr > 0 ? atr / atr_avg_20 : 1.0;
   
   // Get trend strength
   double trend_strength = GetTrendStrength();
   
   // Dynamic tolerance based on volatility and market conditions
   double base_tolerance = MathMax(atr * 0.4, Midpoint_Pullback_Tolerance);
   double dynamic_tolerance = base_tolerance * (1.0 + (volatility_ratio - 1.0) * 0.5);
   
   // Adjust tolerance based on trend strength
   if(trend_strength > 0.7) dynamic_tolerance *= 0.8; // Tighter in strong trends
   else if(trend_strength < 0.4) dynamic_tolerance *= 1.2; // Wider in weak trends
   
   // Calculate price distances to midpoint
   double distance_current = MathAbs(current_price - ut_signal_candle_midpoint);
   double distance_prev = MathAbs(prev_price - ut_signal_candle_midpoint);
   
   // Multi-level midpoint proximity checks
   bool very_close_to_midpoint = distance_current <= dynamic_tolerance * 0.6;
   bool close_to_midpoint = distance_current <= dynamic_tolerance * 0.8;
   bool near_midpoint = distance_current <= dynamic_tolerance * 1.2;
   bool prev_near_midpoint = distance_prev <= dynamic_tolerance * 1.2;
   
   // Price movement toward midpoint with acceleration check
   bool moving_toward_midpoint = distance_current < distance_prev * 0.95;
   bool strongly_moving_toward = distance_current < distance_prev * 0.85;
   
   // Price action confirmation
   bool candlestick_direction = (is_buy_signal ? current_close > current_open : current_close < current_open);
   bool price_reversal = is_buy_signal ? 
                        (current_low <= ut_signal_candle_midpoint - atr * 0.3 && current_close > current_low + (current_high - current_low) * 0.6) :
                        (current_high >= ut_signal_candle_midpoint + atr * 0.3 && current_close < current_high - (current_high - current_low) * 0.6);
   
   // Primary midpoint conditions with weighted importance
   bool midpoint_condition = very_close_to_midpoint || 
                           (near_midpoint && candlestick_direction) || 
                           (strongly_moving_toward && close_to_midpoint) ||
                           (price_reversal && near_midpoint);
   
   // Trend-based override conditions
   if(trend_strength > 0.75)
      midpoint_condition = near_midpoint || (moving_toward_midpoint && prev_near_midpoint);
   
   // Volatility-based adjustments
   if(volatility_ratio > 1.8)
      midpoint_condition = midpoint_condition || (moving_toward_midpoint && prev_near_midpoint);
   
   // Enhanced logging with dynamic values
   if(DebugMode)
     {
      Print("Midpoint Check - Midpoint: ", ut_signal_candle_midpoint, ", Current Price: ", current_price);
      Print("Midpoint Check - Dynamic tolerance: ", dynamic_tolerance, ", Volatility ratio: ", volatility_ratio);
      Print("Midpoint Check - Near midpoint: ", near_midpoint, ", Moving toward: ", moving_toward_midpoint);
      Print("Midpoint Check - Price reversal: ", price_reversal, ", Candlestick direction: ", candlestick_direction);
      Print("Midpoint Check - Trend strength: ", trend_strength, ", Result: ", midpoint_condition);
     }
   
   return(midpoint_condition);
  }

//+------------------------------------------------------------------+
//| Check for MACD pullback and re-expansion with volatility and trend adaptation |
//+------------------------------------------------------------------+
bool IsMACDPullback(const bool is_buy_signal)
  {
   if(!Enable_MACD_Pullback)
      return(false);
   
   // Get volatility metrics
   double atr = iATR(Symbol(), 0, ATR_Period, 0);
   double atr_avg_20 = CalculateATR_SMA(20);
   double volatility_ratio = (atr_avg_20 > 0) ? atr / atr_avg_20 : 1.0;
   
   // Get trend strength and direction
   double trend_strength = CalculateTrendStrength();
   int trend_direction = GetTrendDirection();
   
   double main[1], signal[1], histogram[1];
   double main_prev[1], signal_prev[1], histogram_prev[1];
   double main_prev_2[1], signal_prev_2[1], histogram_prev_2[1];
   
   // Get more bars of MACD data for better trend analysis
   if(!GetMACDValues(main, signal, histogram, 0) || 
      !GetMACDValues(main_prev, signal_prev, histogram_prev, 1) ||
      !GetMACDValues(main_prev_2, signal_prev_2, histogram_prev_2, 2))
      return(false);
   
   // Get price data for confirmation
   double current_price = Close[0];
   double prev_price = Close[1];
   
   // Calculate histogram slope and divergence
   double histogram_slope = histogram[0] - histogram_prev[0];
   bool histogram_divergence = false;
   if(is_buy_signal)
      histogram_divergence = histogram[0] > 0 && prev_price < current_price;
   else
      histogram_divergence = histogram[0] < 0 && prev_price > current_price;
   
   // Dynamic threshold based on volatility and trend
   int required_conditions = 3; // Default required conditions
   if(volatility_ratio > 1.8) // Higher volatility requires more confirmation
      required_conditions = 4;
   if(trend_strength > 0.7) // Strong trend can have slightly lower requirements
      required_conditions = MathMax(2, required_conditions - 1);
   
   if(is_buy_signal)
     {
      // Enhanced buy conditions with trend and volatility adaptation
      bool main_above_signal = main[0] > signal[0];
      bool histogram_positive = histogram[0] > 0;
      bool improving_histogram = histogram[0] > histogram_prev[0];
      bool main_line_improving = main[0] > main_prev[0];
      bool histogram_building = histogram[0] > histogram_prev[0] && histogram_prev[0] > histogram_prev_2[0];
      
      // Price action confirmation - ensure MACD signals align with price movements
      bool price_confirmation = prev_price < current_price && current_price > Open[0];
      
      // Trend alignment - ensure MACD signals align with overall trend
      bool trend_alignment = (trend_direction >= 0) ? true : (histogram_building && main_above_signal);
      
      // Debug logging with dynamic values
      if(DebugMode)
        {
         Print("MACD Buy Check - Main: ", main[0], ", Signal: ", signal[0], ", Histogram: ", histogram[0]);
         Print("MACD Buy Check - Volatility ratio: ", volatility_ratio, ", Trend strength: ", trend_strength);
         Print("MACD Buy Check - Main above signal: ", main_above_signal, ", Positive histogram: ", histogram_positive);
         Print("MACD Buy Check - Improving histogram: ", improving_histogram, ", Histogram slope: ", histogram_slope);
         Print("MACD Buy Check - Price confirmation: ", price_confirmation, ", Trend alignment: ", trend_alignment);
        }
      
      // Return true if required conditions are met
      int condition_count = 0;
      if(main_above_signal) condition_count += 2; // Weight main signal line position higher
      if(histogram_positive) condition_count++;
      if(improving_histogram) condition_count++;
      if(main_line_improving) condition_count++;
      if(histogram_building) condition_count++;
      if(price_confirmation) condition_count++;
      if(histogram_divergence) condition_count++;
      
      // Main above signal is a critical condition that must be met in most cases
      bool critical_condition = main_above_signal || (histogram_building && trend_strength > 0.6);
      
      // Adjust requirements based on trend strength
      if(trend_strength > 0.8 && main_above_signal && histogram_building)
        {
         // Strong trend with clear MACD confirmation
         if(DebugMode) Print("MACD Buy Check - Strong trend override activated");
         return(true);
        }
      
      // Calculate weighted score instead of simple count
      double weighted_score = (main_above_signal ? 0.4 : 0) +
                            (histogram_building ? 0.3 : 0) +
                            (price_confirmation ? 0.15 : 0) +
                            (histogram_positive ? 0.15 : 0);
      
      bool result = false;
      if(trend_strength > 0.5)
         result = (critical_condition && condition_count >= MathMax(2, required_conditions - 1)) || weighted_score >= 0.65;
      else
         result = (critical_condition && condition_count >= required_conditions) || weighted_score >= 0.75;
      
      if(DebugMode)
        {
         Print("MACD Buy Pullback - Condition count: ", condition_count, ", Weighted score: ", weighted_score);
         Print("MACD Buy Pullback - Required conditions: ", required_conditions, ", Result: ", result);
        }
      return(result);
     }
   else
     {
      // Enhanced sell conditions with trend and volatility adaptation
      bool main_below_signal = main[0] < signal[0];
      bool histogram_negative = histogram[0] < 0;
      bool improving_histogram = histogram[0] < histogram_prev[0];
      bool main_line_improving = main[0] < main_prev[0];
      bool histogram_building = histogram[0] < histogram_prev[0] && histogram_prev[0] < histogram_prev_2[0];
      
      // Price action confirmation - ensure MACD signals align with price movements
      bool price_confirmation = prev_price > current_price && current_price < Open[0];
      
      // Trend alignment - ensure MACD signals align with overall trend
      bool trend_alignment = (trend_direction <= 0) ? true : (histogram_building && main_below_signal);
      
      // Debug logging with dynamic values
      if(DebugMode)
        {
         Print("MACD Sell Check - Main: ", main[0], ", Signal: ", signal[0], ", Histogram: ", histogram[0]);
         Print("MACD Sell Check - Volatility ratio: ", volatility_ratio, ", Trend strength: ", trend_strength);
         Print("MACD Sell Check - Main below signal: ", main_below_signal, ", Negative histogram: ", histogram_negative);
         Print("MACD Sell Check - Improving histogram: ", improving_histogram, ", Histogram slope: ", histogram_slope);
         Print("MACD Sell Check - Price confirmation: ", price_confirmation, ", Trend alignment: ", trend_alignment);
        }
      
      // Return true if required conditions are met
      int condition_count = 0;
      if(main_below_signal) condition_count += 2; // Weight main signal line position higher
      if(histogram_negative) condition_count++;
      if(improving_histogram) condition_count++;
      if(main_line_improving) condition_count++;
      if(histogram_building) condition_count++;
      if(price_confirmation) condition_count++;
      if(histogram_divergence) condition_count++;
      
      // Main below signal is a critical condition that must be met in most cases
      bool critical_condition = main_below_signal || (histogram_building && trend_strength > 0.6);
      
      // Adjust requirements based on trend strength
      if(trend_strength > 0.8 && main_below_signal && histogram_building)
        {
         // Strong trend with clear MACD confirmation
         if(DebugMode) Print("MACD Sell Check - Strong trend override activated");
         return(true);
        }
      
      // Calculate weighted score instead of simple count
      double weighted_score = (main_below_signal ? 0.4 : 0) +
                            (histogram_building ? 0.3 : 0) +
                            (price_confirmation ? 0.15 : 0) +
                            (histogram_negative ? 0.15 : 0);
      
      bool result = false;
      if(trend_strength > 0.5)
         result = (critical_condition && condition_count >= MathMax(2, required_conditions - 1)) || weighted_score >= 0.65;
      else
         result = (critical_condition && condition_count >= required_conditions) || weighted_score >= 0.75;
      
      if(DebugMode)
        {
         Print("MACD Sell Pullback - Condition count: ", condition_count, ", Weighted score: ", weighted_score);
         Print("MACD Sell Pullback - Required conditions: ", required_conditions, ", Result: ", result);
        }
      return(result);
     }
  }

//+------------------------------------------------------------------+
//| Global variables for pullback strategy performance tracking      |
//+------------------------------------------------------------------+
double g_ema50_strategy_performance = 0.5;  // Performance score (0-1) for EMA50 strategy
double g_midpoint_strategy_performance = 0.5; // Performance score (0-1) for Midpoint strategy
double g_macd_strategy_performance = 0.5;     // Performance score (0-1) for MACD strategy
int g_ema50_trades_count = 0;                 // Number of trades taken with EMA50 confirmation
int g_midpoint_trades_count = 0;              // Number of trades taken with Midpoint confirmation
int g_macd_trades_count = 0;                  // Number of trades taken with MACD confirmation
int g_ema50_winning_trades = 0;               // Number of winning trades for EMA50 strategy
int g_midpoint_winning_trades = 0;            // Number of winning trades for Midpoint strategy
int g_macd_winning_trades = 0;                // Number of winning trades for MACD strategy

//+------------------------------------------------------------------+
//| Update pullback strategy performance metrics                     |
//+------------------------------------------------------------------+
void UpdatePullbackStrategyPerformance(const bool ema50_confirmed, const bool midpoint_confirmed, 
                                       const bool macd_confirmed, const bool is_winning_trade)
  {
   // Update counters and performance for each strategy that confirmed the trade
   if(ema50_confirmed)
     {
      g_ema50_trades_count++;
      if(is_winning_trade) g_ema50_winning_trades++;
      g_ema50_strategy_performance = (double)g_ema50_winning_trades / (double)g_ema50_trades_count;
      Print("EMA50 Strategy Performance Updated: ", g_ema50_strategy_performance, 
            " (Wins: ", g_ema50_winning_trades, ", Total: ", g_ema50_trades_count, ")");
     }
   
   if(midpoint_confirmed)
     {
      g_midpoint_trades_count++;
      if(is_winning_trade) g_midpoint_winning_trades++;
      g_midpoint_strategy_performance = (double)g_midpoint_winning_trades / (double)g_midpoint_trades_count;
      Print("Midpoint Strategy Performance Updated: ", g_midpoint_strategy_performance, 
            " (Wins: ", g_midpoint_winning_trades, ", Total: ", g_midpoint_trades_count, ")");
     }
   
   if(macd_confirmed)
     {
      g_macd_trades_count++;
      if(is_winning_trade) g_macd_winning_trades++;
      g_macd_strategy_performance = (double)g_macd_winning_trades / (double)g_macd_trades_count;
      Print("MACD Strategy Performance Updated: ", g_macd_strategy_performance, 
            " (Wins: ", g_macd_winning_trades, ", Total: ", g_macd_trades_count, ")");
     }
  }

//+------------------------------------------------------------------+
//| Update pullback strategy performance metrics                     |
//+------------------------------------------------------------------+
void UpdatePullbackStrategyPerformance(const bool ema50_confirmed, const bool midpoint_confirmed, 
                                       const bool macd_confirmed, const bool is_winning_trade)
  {
   // Update counters and performance for each strategy that confirmed the trade
   if(ema50_confirmed)
     {
      g_ema50_trades_count++;
      if(is_winning_trade) g_ema50_winning_trades++;
      g_ema50_strategy_performance = (double)g_ema50_winning_trades / (double)g_ema50_trades_count;
      Print("EMA50 Strategy Performance Updated: ", g_ema50_strategy_performance, 
            " (Wins: ", g_ema50_winning_trades, ", Total: ", g_ema50_trades_count, ")");
     }
   
   if(midpoint_confirmed)
     {
      g_midpoint_trades_count++;
      if(is_winning_trade) g_midpoint_winning_trades++;
      g_midpoint_strategy_performance = (double)g_midpoint_winning_trades / (double)g_midpoint_trades_count;
      Print("Midpoint Strategy Performance Updated: ", g_midpoint_strategy_performance, 
            " (Wins: ", g_midpoint_winning_trades, ", Total: ", g_midpoint_trades_count, ")");
     }
   
   if(macd_confirmed)
     {
      g_macd_trades_count++;
      if(is_winning_trade) g_macd_winning_trades++;
      g_macd_strategy_performance = (double)g_macd_winning_trades / (double)g_macd_trades_count;
      Print("MACD Strategy Performance Updated: ", g_macd_strategy_performance, 
            " (Wins: ", g_macd_winning_trades, ", Total: ", g_macd_trades_count, ")");
     }
  }

//+------------------------------------------------------------------+
//| Track trade results and update strategy performance              |
//+------------------------------------------------------------------+
void TrackTradeResult(const int trade_type, const double entry_price, const double exit_price)
  {
   // Determine if the trade was profitable
   bool is_winning_trade = false;
   
   if(trade_type == 1) // Buy trade
     {
      is_winning_trade = exit_price > entry_price;
     }
   else if(trade_type == 2) // Sell trade
     {
      is_winning_trade = exit_price < entry_price;
     }
   
   // Log trade result
   Print("Trade result - Type: ", (trade_type == 1 ? "Buy" : "Sell"), 
         ", Entry: ", entry_price, ", Exit: ", exit_price, 
         ", Result: ", (is_winning_trade ? "Win" : "Loss"));
   
   // Update pullback strategy performance based on which strategies confirmed this trade
   UpdatePullbackStrategyPerformance(g_last_ema50_pullback, g_last_midpoint_pullback, 
                                    g_last_macd_pullback, is_winning_trade);
   
   // Reset tracking variables
   g_last_ema50_pullback = false;
   g_last_midpoint_pullback = false;
   g_last_macd_pullback = false;
   g_last_entry_price = 0.0;
   g_last_trade_type = 0;
  }

//+------------------------------------------------------------------+
//| Check if any pullback condition is met                           |
//+------------------------------------------------------------------+
bool IsPullbackConditionMet(const bool is_buy_signal)
  {
   // At least one pullback method must be enabled
   if(!Enable_EMA50_Pullback && !Enable_Midpoint_Pullback && !Enable_MACD_Pullback)
     {
      Print("Warning: All pullback methods are disabled. No entries will be made.");
      return(false);
     }
     
   // Log which pullback methods are enabled and their current performance
   Print("Pullback methods enabled - EMA50: ", Enable_EMA50_Pullback, 
         "(Perf: ", StringFormat("%.2f", g_ema50_strategy_performance), "), Midpoint: ", 
         Enable_Midpoint_Pullback, "(Perf: ", StringFormat("%.2f", g_midpoint_strategy_performance), "), 
         MACD: ", Enable_MACD_Pullback, "(Perf: ", StringFormat("%.2f", g_macd_strategy_performance), ")");
   
   // Check each enabled pullback method
   bool ema50_pullback = IsEMA50Pullback(is_buy_signal);
   bool midpoint_pullback = IsMidpointPullback(is_buy_signal);
   bool macd_pullback = IsMACDPullback(is_buy_signal);
   
   // Count how many pullback methods are satisfied
   int satisfied_pullback_methods = 0;
   if(Enable_EMA50_Pullback && ema50_pullback) satisfied_pullback_methods++;
   if(Enable_Midpoint_Pullback && midpoint_pullback) satisfied_pullback_methods++;
   if(Enable_MACD_Pullback && macd_pullback) satisfied_pullback_methods++;
   
   // Get trend direction and strength to apply dynamic conditions
   TrendDirection trend = GetTrendDirection();
   double trend_strength = GetTrendStrength();
   
   // Enhanced logging
   if(ema50_pullback) Print("EMA50 pullback condition met");
   if(midpoint_pullback) Print("Midpoint pullback condition met");
   if(macd_pullback) Print("MACD pullback condition met");
   Print("Current trend: ", trend, ", Trend strength: ", StringFormat("%.2f", trend_strength));
   
   // Calculate weighted score based on strategy performance
   double weighted_score = 0.0;
   double total_weight = 0.0;
   
   // Assign weights based on performance and minimum confidence (0.3)
   double ema50_weight = MathMax(0.3, g_ema50_strategy_performance);
   double midpoint_weight = MathMax(0.3, g_midpoint_strategy_performance);
   double macd_weight = MathMax(0.3, g_macd_strategy_performance);
   
   // Calculate weighted score
   if(Enable_EMA50_Pullback && ema50_pullback) 
     {
      weighted_score += ema50_weight;
      total_weight += ema50_weight;
     }
   if(Enable_Midpoint_Pullback && midpoint_pullback)
     {
      weighted_score += midpoint_weight;
      total_weight += midpoint_weight;
     }
   if(Enable_MACD_Pullback && macd_pullback)
     {
      weighted_score += macd_weight;
      total_weight += macd_weight;
     }
   
   // Calculate final confidence score (0-1)
   double confidence_score = total_weight > 0 ? weighted_score / total_weight : 0;
   Print("Pullback confidence score: ", StringFormat("%.2f", confidence_score));
   
   // Apply dynamic conditions based on market environment and strategy performance
   bool result = false;
   
   if(IsSidewaysMarket() || trend == TREND_NONE)
     {
      // In sideways or no trend environments, require higher confidence
      Print("Sideways/No trend environment detected");
      
      // Option 1: Multiple confirmations
      bool multiple_confirmations = satisfied_pullback_methods >= 2;
      
      // Option 2: High confidence from a single strategy
      bool high_confidence_single = confidence_score >= 0.7 && satisfied_pullback_methods >= 1;
      
      result = multiple_confirmations || high_confidence_single;
      Print("Sideways market result - Multiple confirmations: ", multiple_confirmations, 
            ", High confidence: ", high_confidence_single);
     }
   else if(trend == TREND_UP || trend == TREND_DOWN)
     {
      // For clear trends, adjust requirements based on trend strength
      Print("Trending market detected with strength: ", StringFormat("%.2f", trend_strength));
      
      if(trend_strength > 0.7) // Strong trend
        {
          // In strong trends, we can be more flexible with pullback requirements
          // But still need at least one pullback method or high confidence
          result = satisfied_pullback_methods >= 1 || confidence_score >= 0.6;
          Print("Strong trend - Using relaxed pullback requirements");
        }
      else if(trend_strength > 0.4) // Moderate trend
        {
          // Need at least one pullback confirmation
          result = satisfied_pullback_methods >= 1;
          Print("Moderate trend - Requiring at least one pullback confirmation");
        }
      else // Weak trend
        {
          // For weak trends, require multiple confirmations
          result = satisfied_pullback_methods >= 2;
          Print("Weak trend - Requiring multiple pullback confirmations");
        }
     }
   
   // Additional check: If we have only one confirmation but it's from a high-performing strategy
   if(!result && satisfied_pullback_methods == 1)
     {
      if((Enable_EMA50_Pullback && ema50_pullback && g_ema50_strategy_performance > 0.7) ||
         (Enable_Midpoint_Pullback && midpoint_pullback && g_midpoint_strategy_performance > 0.7) ||
         (Enable_MACD_Pullback && macd_pullback && g_macd_strategy_performance > 0.7))
        {
          result = true;
          Print("Overriding result: Single high-performing strategy confirmation");
        }
     }
   
   // Additional check: If all enabled strategies confirm, always allow entry
   bool all_strategies_confirm = true;
   if(Enable_EMA50_Pullback && !ema50_pullback) all_strategies_confirm = false;
   if(Enable_Midpoint_Pullback && !midpoint_pullback) all_strategies_confirm = false;
   if(Enable_MACD_Pullback && !macd_pullback) all_strategies_confirm = false;
   
   if(all_strategies_confirm)
     {
      result = true;
      Print("All enabled pullback strategies confirm - Strong signal");
     }
   
   Print("Pullback conditions result: ", result, " (", satisfied_pullback_methods, 
         " methods satisfied, ", StringFormat("%.2f", confidence_score), " confidence score)");
   
   // Store the current pullback confirmations for later performance tracking
   // These will be used in the trade result handler to update strategy performance
   g_last_ema50_pullback = ema50_pullback;
   g_last_midpoint_pullback = midpoint_pullback;
   g_last_macd_pullback = macd_pullback;
   
   return(result);
  }

//+------------------------------------------------------------------+
//| Apply all 6 pre-entry filters                                    |
//+------------------------------------------------------------------+
bool ApplyPreEntryFilters(const bool is_buy_signal)
  {
   // Initialize filter pass count
   int filter_pass_count = 0;
   const int total_filters = 6;
   
   // Step 1: Trend filter - strict trend alignment with enhanced conditions
   TrendDirection trend = GetTrendDirection();
   bool trend_filter_passed = false;
   
   // Check if market is sideways - now enforced as a filter
   bool is_sideways = IsSidewaysMarket();
   Print("Filter 1/6 - Trend: ", trend == TREND_UP ? "UP" : (trend == TREND_DOWN ? "DOWN" : "NONE"), 
         ", Sideways: ", is_sideways ? "YES" : "NO");
   
   if(is_sideways && !Allow_Trading_In_Sideways_Market)
     {
      Print("Filter 1/6 FAILED: Market is sideways and trading in sideways market is disabled");
      return(false);
     }
   
   // Strict trend direction check
   bool trend_match = (is_buy_signal && trend == TREND_UP) || (!is_buy_signal && trend == TREND_DOWN);
   
   if(!trend_match)
     {
      if(Allow_Counter_Trend_With_Confirmation)
        {
         // Require strong confirmation for counter-trend trades
         Print("Filter 1/6 - Checking counter-trend confirmation");
         // For counter-trend trades, require stronger MACD confirmation
         double main[1], signal[1], histogram[1];
         if(!GetMACDValues(main, signal, histogram, 0))
           {
            Print("Filter 1/6 FAILED: Could not get MACD values for counter-trend confirmation");
            return(false);
           }
         
         // Stronger counter-trend confirmation requirements
         bool strong_macd_confirmation = false;
         if(is_buy_signal) // Counter-trend buy in downtrend
           strong_macd_confirmation = histogram[0] > histogram[1] * 1.5 && main[0] > signal[0];
         else // Counter-trend sell in uptrend
           strong_macd_confirmation = histogram[0] < histogram[1] * 1.5 && main[0] < signal[0];
         
         if(!strong_macd_confirmation)
           {
            Print("Filter 1/6 FAILED: Counter-trend signal lacks strong confirmation");
            return(false);
           }
         else
           {
            Print("Filter 1/6 PASSED: Strong counter-trend confirmation detected");
            trend_filter_passed = true;
            filter_pass_count++;
           }
        }
      else
        {
         Print("Filter 1/6 FAILED: Signal direction doesn't match trend and counter-trend trading is disabled");
         return(false);
        }
     }
   else
     {
      Print("Filter 1/6 PASSED: Signal direction matches trend direction");
      trend_filter_passed = true;
      filter_pass_count++;
     }
   
   // Step 2: UT Bot signal confirmation - ensure signal strength is sufficient
   Print("Filter 2/6 - UT Bot signal validation");
   // Since this is called after signal detection, ensure the signal strength is sufficient
   // Get ATR value for signal strength validation
   double atr = GetATR(0);
   if(atr <= 0)
     {
      Print("Filter 2/6 FAILED: Invalid ATR value for signal strength validation");
      return(false);
     }
   
   // Calculate minimum required price movement based on ATR
   double min_movement_required = atr * UT_ATR_Multiplier * 0.8; // 80% of regular requirement as a confirmation
   
   // Ensure the signal has meaningful price movement
   if(signal_candle_high - signal_candle_low < min_movement_required)
     {
      Print("Filter 2/6 FAILED: UT Bot signal has insufficient price movement");
      return(false);
     }
   
   Print("Filter 2/6 PASSED: UT Bot signal has sufficient strength");
   filter_pass_count++;
   
   // Step 3: MACD momentum confirmation - now strictly enforced with additional checks
   Print("Filter 3/6 - MACD confirmation");
   if(!IsMACDConfirmed(is_buy_signal))
     {
      Print("Filter 3/6 FAILED: MACD confirmation not met");
      return(false);
     }
   
   // Additional MACD strength check
   double macd_main[1], macd_signal[1], macd_hist[1];
   if(GetMACDValues(macd_main, macd_signal, macd_hist, 0))
     {
      // Check MACD histogram strength
      double hist_strength = MathAbs(macd_hist[0]);
      Print("MACD histogram strength: ", hist_strength);
      
      // If trend is strong, require less MACD strength; if trend is weak, require more MACD strength
      double min_hist_strength = 0.00002; // Default minimum strength
      if(is_sideways || trend == TREND_NONE)
        min_hist_strength *= 1.5; // Require stronger MACD in sideways markets
      
      if(hist_strength < min_hist_strength && is_sideways)
        {
         Print("Filter 3/6 FAILED: MACD histogram too weak for sideways market");
         return(false);
        }
     }
   
   Print("Filter 3/6 PASSED: MACD confirmation and strength check passed");
   filter_pass_count++;
   
   // Step 4: Volume filter - now strictly enforced with volatility consideration
   Print("Filter 4/6 - Volume confirmation");
   if(!IsVolumeSufficient())
     {
      Print("Filter 4/6 FAILED: Volume is insufficient");
      return(false);
     }
   
   // Additional volume check against current volatility
   double volume_ma = GetVolumeMA(0);
   long current_volume = GetCurrentVolume(0);
   if(current_volume > 0 && volume_ma > 0)
     {
      double volume_ratio = (double)current_volume / volume_ma;
      Print("Current volume ratio: ", volume_ratio);
      
      // Adjust volume requirements based on market conditions
      if(is_sideways && volume_ratio < 1.2) // Need higher volume confirmation in sideways
        {
         Print("Filter 4/6 FAILED: Volume insufficient for sideways market");
         return(false);
        }
     }
   
   Print("Filter 4/6 PASSED: Volume confirmation passed");
   filter_pass_count++;
   
   // Step 5: ATR volatility filter - now strictly enforced with enhanced checks
   Print("Filter 5/6 - ATR volatility confirmation");
   if(!IsATRVolatilitySufficient())
     {
      Print("Filter 5/6 FAILED: ATR volatility is too low");
      return(false);
     }
   
   // Additional volatility check against recent average
   double current_atr = GetATR(0);
   
   // Calculate average ATR over 20 periods for comparison
   double sum_atr = 0;
   int valid_atr_count = 0;
   for(int i = 0; i < 20; i++)
     {
      double atr_value = GetATR(i);
      if(atr_value > 0)
        {
         sum_atr += atr_value;
         valid_atr_count++;
        }
     }
   
   if(valid_atr_count > 0)
     {
      avg_atr_20 = sum_atr / valid_atr_count;
      double atr_ratio = current_atr / avg_atr_20;
      Print("Current ATR/20MA ATR ratio: ", atr_ratio);
      
      // Ensure volatility is not excessively high
      if(atr_ratio > Volatility_Threshold_Multiplier)
        {
         Print("Filter 5/6 FAILED: ATR volatility excessively high (potential market stress)");
         return(false);
        }
     }
   
   Print("Filter 5/6 PASSED: ATR volatility confirmation passed");
   filter_pass_count++;
   
   // Step 6: News filter - use the correct function name
   Print("Filter 6/6 - News event check");
   if(IsNewsEventNearby())
     {
      Print("Filter 6/6 FAILED: News event is nearby");
      return(false);
     }
   
   Print("Filter 6/6 PASSED: No news events nearby");
   filter_pass_count++;
   
   // Final validation: Ensure all filters passed
   if(filter_pass_count != total_filters)
     {
      Print("ERROR: Only ", filter_pass_count, " of ", total_filters, " filters passed");
      return(false);
     }
   
   Print("SUCCESS: All 6 pre-entry filters passed - Strong signal confirmed");
   return(true);
  }

//+------------------------------------------------------------------+
//| Update account information and daily risk reset                  |
//+------------------------------------------------------------------+
void UpdateAccountInfo()
  {
   // Update account balance and equity
   account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
   account_equity = AccountInfoDouble(ACCOUNT_EQUITY);
   
   // Check if we need to reset daily risk (new day)
   MqlDateTime time_struct;
   TimeCurrent(time_struct);
   int current_day = time_struct.day;
   
   if(current_day != last_reset_day)
     {
      daily_risk_used = 0.0;
      last_reset_day = current_day;
      Print("Daily risk reset:", DoubleToString(daily_risk_used, 2), "% of account");
     }
  }

//+------------------------------------------------------------------+
//| Check if account drawdown is acceptable                          |
//+------------------------------------------------------------------+
bool CheckAccountDrawdown()
  {
   // Calculate drawdown percentage
   double drawdown = 0.0;
   if(account_balance > 0)
      drawdown = ((account_balance - account_equity) / account_balance) * 100.0;
   
   // Check if drawdown exceeds maximum allowed
   if(drawdown >= Max_Drawdown_Percent)
     {
      Print("WARNING: Account drawdown of ", DoubleToString(drawdown, 2), "% exceeds maximum allowed of ", 
            DoubleToString(Max_Drawdown_Percent, 2) + "%. Trading suspended.");
      return(false);
     }
   
   return(true);
  }

//+------------------------------------------------------------------+
//| Check if we can take another trade based on daily risk limit      |
//+------------------------------------------------------------------+
bool CanTakeNewTrade(double risk_percent)
  {
   // Check if adding this trade would exceed daily risk limit
   if((daily_risk_used + risk_percent) > Max_Daily_Risk_Percent)
     {
      Print("WARNING: Cannot open new trade. Daily risk limit of ", DoubleToString(Max_Daily_Risk_Percent, 2), "% would be exceeded (current: ", DoubleToString(daily_risk_used, 2), "%, additional: ", DoubleToString(risk_percent, 2), "%)");
      return(false);
     }
   
   return(true);
  }

//+------------------------------------------------------------------+
//| Calculate position size based on risk and account size           |
//+------------------------------------------------------------------+
double CalculatePositionSize(double sl_pips, bool is_buy_signal = false)
  {
   // Ensure SL is positive
   if(sl_pips <= 0)
     {
      Print("Error: SL pips must be positive");
      return(0.0);
     }
   
   // Get account information
   account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
   account_equity = AccountInfoDouble(ACCOUNT_EQUITY);
   double account_free_margin = AccountInfoDouble(ACCOUNT_FREEMARGIN);
   
   if(account_balance <= 0 || account_equity <= 0)
     {
      Print("Error: Invalid account balance or equity");
      return(0.0);
     }
   
   // Calculate current drawdown
   double max_equity = GetMaxAccountEquity();
   double drawdown_percent = (max_equity > 0) ? ((max_equity - account_equity) / max_equity) * 100.0 : 0.0;
   
   // Adjust risk based on drawdown - reduce risk when drawdown is high
   double adjusted_risk_percent = Risk_Per_Trade_Percent;
   if(drawdown_percent > 0.5 * Max_Drawdown_Percent)
     {
      // Reduce risk when drawdown reaches half of maximum allowed
      double reduction_factor = 1.0 - ((drawdown_percent - 0.5 * Max_Drawdown_Percent) / (0.5 * Max_Drawdown_Percent)) * 0.5;
      adjusted_risk_percent *= reduction_factor;
      adjusted_risk_percent = MathMax(adjusted_risk_percent, Risk_Per_Trade_Percent * 0.3); // Minimum 30% of original risk
     }
   
   // Enhanced drawdown protection - additional reduction at higher drawdowns
   if(drawdown_percent > 0.7 * Max_Drawdown_Percent)
     {
      adjusted_risk_percent *= 0.7; // Further reduce risk at 70% of max drawdown
      Print("WARNING: High drawdown detected (" + DoubleToString(drawdown_percent, 2) + "%), risk further reduced");
     }
   
   // Get current market volatility
   double current_atr = GetATR(0);
   double avg_atr_20 = GetAverageATR(20);
   double volatility_ratio = (avg_atr_20 > 0) ? current_atr / avg_atr_20 : 1.0;
   
   // Enhanced volatility adjustment
   if(volatility_ratio > 1.8)
     {
      double volatility_factor = MathMin(1.0 / volatility_ratio, 0.8); // Cap reduction at 20%
      adjusted_risk_percent *= volatility_factor;
      
      // Extreme volatility protection
      if(volatility_ratio > 2.5)
        {
         volatility_factor = MathMin(1.0 / volatility_ratio, 0.5); // Cap reduction at 50% for extreme volatility
         adjusted_risk_percent *= volatility_factor;
         Print("WARNING: Extreme market volatility detected, risk significantly reduced");
        }
     }
   
   // Add signal strength based adjustment
   double signal_strength = CalculateSignalStrength(is_buy_signal);
   if(signal_strength > 0.8) // Strong signals can use slightly more risk
     {
      adjusted_risk_percent *= 1.1; // Increase risk by up to 10% for strong signals
      Print("Strong signal detected (" + DoubleToString(signal_strength, 2) + "), risk increased by 10%");
     }
   else if(signal_strength < 0.5) // Reduce risk for weak signals
     {
      adjusted_risk_percent *= 0.8; // Decrease risk by 20% for weak signals
      Print("Weak signal detected (" + DoubleToString(signal_strength, 2) + "), risk decreased by 20%");
     }
   
   // Check daily risk limit before calculating position size
   UpdateDailyRiskTracking(); // Update daily risk tracking
   if(!CanTakeNewTrade(adjusted_risk_percent, sl_pips))
     {
      Print("Cannot take new trade: Daily risk limit reached or exceeded");
      return(0.0);
     }
   
   // Calculate risk in currency using equity (more accurate than balance)
   double risk_in_currency = account_equity * (adjusted_risk_percent / 100.0);
   
   // Calculate position size: risk / (sl_pips * pip_value)
   double pip_value = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE) / SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   
   if(pip_value <= 0)
     {
      Print("Error: Invalid pip value");
      return(0.0);
     }
   
   double lot_size = risk_in_currency / (sl_pips * pip_value);
   
   // Apply margin check - ensure we have enough margin
   double required_margin = CalculateRequiredMargin(lot_size);
   if(required_margin > account_free_margin * 0.8) // Use max 80% of free margin
     {
      double safe_lot_size = (account_free_margin * 0.8) / required_margin * lot_size;
      lot_size = MathMin(lot_size, safe_lot_size);
      Print("Adjusted lot size due to margin constraints from ", DoubleToString(lot_size, 2), 
            " to ", DoubleToString(safe_lot_size, 2));
     }
   
   // Additional account leverage check
   double account_margin_used = AccountInfoDouble(ACCOUNT_MARGIN);
   double margin_usage_percent = (account_equity > 0) ? (account_margin_used / account_equity) * 100.0 : 0.0;
   
   if(margin_usage_percent > 75.0) // If already using more than 75% margin
     {
      lot_size *= 0.5; // Reduce lot size by 50%
      Print("Adjusted lot size due to high account leverage usage (" + DoubleToString(margin_usage_percent, 2) + "%), reduced by 50%");
     }
   
   // Apply minimum and maximum lot size restrictions
   lot_size = MathMax(lot_size, Min_Lot_Size);
   lot_size = MathMin(lot_size, Max_Lot_Size);
   lot_size = MathMin(lot_size, SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX)); // Respect symbol max volume
   
   // Round to symbol's lot step
   double lot_step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   lot_size = NormalizeDouble(MathRound(lot_size / lot_step) * lot_step, 2);
   
   // Log position size calculation with detailed information
   if(DebugMode)
     {
      Print("Position size calculation details:");
      Print("- Original risk: ", DoubleToString(Risk_Per_Trade_Percent, 2), "%");
      Print("- Adjusted risk: ", DoubleToString(adjusted_risk_percent, 2), "%");
      Print("- Account equity: ", DoubleToString(account_equity, 2));
      Print("- Risk in currency: ", DoubleToString(risk_in_currency, 2));
      Print("- SL pips: ", DoubleToString(sl_pips, 1));
      Print("- Pip value: ", DoubleToString(pip_value, 4));
      Print("- Volatility ratio: ", DoubleToString(volatility_ratio, 2));
      Print("- Signal strength: ", DoubleToString(signal_strength, 2));
      Print("- Drawdown: ", DoubleToString(drawdown_percent, 2), "%");
      Print("- Margin usage: ", DoubleToString(margin_usage_percent, 2), "%");
      Print("- Final lot size: ", DoubleToString(lot_size, 2), " lots");
     }
   
   return(lot_size);
  }

//+------------------------------------------------------------------+
//| Calculate required margin for a position                         |
//+------------------------------------------------------------------+
double CalculateRequiredMargin(double lot_size)
  {
   double margin_rate = SymbolInfoDouble(_Symbol, SYMBOL_MARGIN_RATE);
   double contract_size = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_CONTRACT_SIZE);
   double current_price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   
   // Standard margin calculation: (lot_size * contract_size * price) * margin_rate
   double required_margin = (lot_size * contract_size * current_price) * margin_rate;
   
   return required_margin;
  }

//+------------------------------------------------------------------+
//| Get maximum account equity (for drawdown calculation)            |
//+------------------------------------------------------------------+
double GetMaxAccountEquity()
  {
   static double max_equity = 0.0;
   double current_equity = AccountInfoDouble(ACCOUNT_EQUITY);
   
   if(current_equity > max_equity)
     {
      max_equity = current_equity;
     }
   
   return max_equity;
  }

//+------------------------------------------------------------------+
//| Get average ATR over specified period                            |
//+------------------------------------------------------------------+
double GetAverageATR(int period)
  {
   double sum_atr = 0.0;
   int valid_values = 0;
   
   for(int i = 0; i < period; i++)
     {
      double atr_value = GetATR(i);
      if(atr_value > 0)
        {
         sum_atr += atr_value;
         valid_values++;
        }
     }
   
   return (valid_values > 0) ? sum_atr / valid_values : GetATR(0);
  }

//+------------------------------------------------------------------+
//| Update daily risk tracking                                       |
//+------------------------------------------------------------------+
void UpdateDailyRiskTracking()
  {
   datetime now = TimeCurrent();
   int current_day = TimeDayOfYear(now);
   int current_year = TimeYear(now);
   
   // Reset daily risk if it's a new day
   if(current_day != last_reset_day || TimeYear(now) != last_reset_day_year)
     {
      daily_risk_used = 0.0;
      last_reset_day = current_day;
      last_reset_day_year = current_year;
      if(DebugMode)
        {
         Print("Daily risk tracking reset for new day");
        }
     }
   
   // Update account information
   account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
   account_equity = AccountInfoDouble(ACCOUNT_EQUITY);
  }

//+------------------------------------------------------------------+
//| Check if new trade can be taken based on daily risk limits       |
//+------------------------------------------------------------------+
bool CanTakeNewTrade(double risk_percent, double sl_pips)
  {
   // Calculate potential risk for this trade
   double potential_risk = account_equity * (risk_percent / 100.0);
   double max_daily_risk = account_equity * (Max_Daily_Risk_Percent / 100.0);
   
   // Check if adding this trade would exceed daily risk limit
   if(daily_risk_used + potential_risk > max_daily_risk)
     {
      if(DebugMode)
        {
         Print("Daily risk limit check failed:");
         Print("- Daily risk used: ", DoubleToString(daily_risk_used, 2));
         Print("- Potential risk: ", DoubleToString(potential_risk, 2));
         Print("- Max daily risk: ", DoubleToString(max_daily_risk, 2));
        }
      return false;
     }
   
   // Check if account drawdown is too high
   double max_equity = GetMaxAccountEquity();
   double drawdown_percent = (max_equity > 0) ? ((max_equity - account_equity) / max_equity) * 100.0 : 0.0;
   if(drawdown_percent >= Max_Drawdown_Percent)
     {
      if(DebugMode)
        {
         Print("Account drawdown too high: ", DoubleToString(drawdown_percent, 2), 
               "% (Max allowed: ", DoubleToString(Max_Drawdown_Percent, 2), "%)");
        }
      return false;
     }
   
   return true;
  }

//+------------------------------------------------------------------+
//| Update daily risk when trade is closed                           |
//+------------------------------------------------------------------+
void UpdateDailyRiskOnTradeClose(double trade_profit_loss)
  {
   // Update daily risk tracking
   UpdateDailyRiskTracking();
   
   // Only add losses to daily risk tracking
   if(trade_profit_loss < 0)
     {
      daily_risk_used += MathAbs(trade_profit_loss);
      if(DebugMode)
        {
          Print("Updated daily risk used: ", DoubleToString(daily_risk_used, 2), 
                " after trade loss of ", DoubleToString(trade_profit_loss, 2));
        }
     }
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Add diagnostic logging
   static int log_counter = 0;
   log_counter++;
   if(log_counter % 100 == 0) // Log every 100 ticks to avoid flooding
     {
      Print("EA Status: EnableEA=", EnableEA, 
            ", Timeframe=", EnumToString(Period()), 
            ", Bars=", Bars(_Symbol, PERIOD_M15),
            ", waiting_for_pullback=", waiting_for_pullback,
            ", daily_risk_used=", daily_risk_used);
     }

//--- Check if EA is enabled
   if(!EnableEA)
     {
      if(log_counter % 500 == 0)
         Print("EA is disabled (EnableEA=false)");
      return;
     }

//--- Check if the timeframe is M15 (runtime check)
   if(AllowOnlyM15 && Period() != PERIOD_M15)
     {
      if(log_counter % 500 == 0)
         Print("Wrong timeframe. EA requires M15 but running on ", EnumToString(Period()));
      return;
     }

//--- Check if there are enough bars for indicators
   if(Bars(_Symbol, PERIOD_M15) < 200)
     {
      if(log_counter % 500 == 0)
         Print("Not enough bars. Need at least 200 bars, current: ", Bars(_Symbol, PERIOD_M15));
      return;
     }

//--- Update account information and check drawdown
   UpdateAccountInfo();
   if(!CheckAccountDrawdown())
      return;

//--- Check for UT Bot signals
   CheckUTBotSignals();

//--- If we're waiting for pullback, check if any pullback condition is met
   if(waiting_for_pullback)
     {
      bool is_buy = (current_pullback_direction == BUY);
      
      Print("Applying pre-entry filters for ", is_buy ? "BUY" : "SELL");
      if(ApplyPreEntryFilters(is_buy))
        {
         Print("Checking pullback conditions");
         if(IsPullbackConditionMet(is_buy))
           {
            Print("All conditions met, executing trade");
            ExecuteTrade(is_buy);
            
            // Reset pullback tracking
            waiting_for_pullback = false;
            current_pullback_direction = NONE;
            prev_ut_buy_signal = 0;
            prev_ut_sell_signal = 0;
           }
         else
           {
            Print("No pullback condition met");
           }
        }
      else
        {
         Print("Pre-entry filters not met");
        }
     }

//--- Manage open positions (SL/TP/trailing)
   ManageOpenPositions();
   
   // Apply trailing stops to open positions
   if(UseTrailingStop)
      ApplyTrailingStop();
  }

//+------------------------------------------------------------------+
//| 计算ATR移动平均值 - 用于衡量波动率水平                           |
//+------------------------------------------------------------------+
double CalculateATR_MovingAverage(const int periods)
  {
   double atr_sum = 0.0;
   int valid_count = 0;
   
   for(int i = 1; i <= periods; i++) // 从1开始，避免使用当前未完成的K线
     {
      double atr_value = GetATR(i);
      if(atr_value > 0)
        {
         atr_sum += atr_value;
         valid_count++;
        }
     }
   
   return (valid_count > 0) ? (atr_sum / valid_count) : GetATR(1);
  }

//+------------------------------------------------------------------+
//| 计算趋势强度 (0-1) - 用于调整止损策略                             |
//+------------------------------------------------------------------+
double CalculateTrendStrength()
  {
   double trend_strength = 0.5; // 默认中等强度
   
   // 1. EMA50和EMA200的关系作为趋势方向指标
   double ema50 = GetEMA50(1);
   double ema200 = GetEMA200(1);
   
   if(ema50 == 0 || ema200 == 0)
      return trend_strength;
   
   // 2. EMA50的斜率作为短期趋势强度指标
   double ema50_prev = GetEMA50(3); // 使用3根K线前的值计算斜率
   double ema50_slope = (ema50 - ema50_prev) / MathMax(ema50_prev, 1.0); // 百分比变化
   
   // 3. 计算EMA50和EMA200之间的距离比例
   double ema_distance_ratio = MathAbs(ema50 - ema200) / ema200;
   
   // 4. 使用ADX计算趋势强度（如果可用）
   double adx = 0.0;
   if(handle_adx > 0)
     {
      double adx_buffer[1];
      if(CopyBuffer(handle_adx, 0, 1, 1, adx_buffer) > 0)
         adx = adx_buffer[0];
     }
   
   // 综合计算趋势强度 (0-1)
   if(adx > 0) // 如果有ADX值，给予较高权重
     {
      // ADX通常在0-100之间，30以上表示强趋势
      double adx_strength = MathMin(1.0, adx / 50.0);
      trend_strength = adx_strength * 0.6 + MathMin(1.0, ema_distance_ratio * 100.0) * 0.3 + 
                      MathMin(1.0, MathAbs(ema50_slope) * 1000.0) * 0.1;
     }
   else // 使用EMA关系和斜率
     {
      // 计算EMA距离强度 (0-1)
      double distance_strength = MathMin(1.0, ema_distance_ratio * 200.0);
      
      // 计算EMA斜率强度 (0-1)
      double slope_strength = MathMin(1.0, MathAbs(ema50_slope) * 2000.0);
      
      trend_strength = (distance_strength + slope_strength) / 2.0;
     }
   
   return MathMax(0.0, MathMin(1.0, trend_strength)); // 确保在0-1范围内
  }

//+------------------------------------------------------------------+
//| Calculate ATR-based stop loss price                              |
//+------------------------------------------------------------------+
double CalculateStopLossPrice(const bool is_buy, const double entry_price)
  {
   double atr_value = GetATR(1);
   if(atr_value == 0)
      return(0);
   
   double sl_price = 0;
   double sl_size_usd = 0;
   
   // 获取交易平台最小止损距离要求
   int stoplevel = (int)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
   double min_stop_distance = stoplevel * _Point;
   
   // 计算更全面的波动率指标
   double atr_avg_5 = CalculateATR_MovingAverage(5);
   double atr_avg_20 = CalculateATR_MovingAverage(20);
   double atr_avg_50 = CalculateATR_MovingAverage(50);
   
   // 多级波动率比率
   double volatility_ratio_short = atr_value / atr_avg_5;     // 短期波动率变化
   double volatility_ratio_medium = atr_value / atr_avg_20;  // 中期波动率变化
   double volatility_ratio_long = atr_avg_20 / atr_avg_50;   // 长期波动率变化趋势
   
   // 获取当前市场趋势强度
   double trend_strength = CalculateTrendStrength();
   
   // 基础ATR乘数，根据交易策略优化
   double base_multiplier = SL_Multiplier;
   
   // 1. 基于趋势强度的自适应调整
   // 强趋势市场中，价格回撤通常较小
   if(trend_strength > 0.75) // 极强趋势
      base_multiplier *= 0.85;
   else if(trend_strength > 0.6) // 强趋势
      base_multiplier *= 0.9;
   // 弱趋势或震荡市场需要更大的止损空间
   else if(trend_strength < 0.25) // 极弱趋势/震荡
      base_multiplier *= 1.3;
   else if(trend_strength < 0.4) // 弱趋势
      base_multiplier *= 1.15;
   
   // 2. 基于波动率分层的自适应调整
   // 短期波动率突增时需要更大的止损空间
   if(volatility_ratio_short > 1.8)
      base_multiplier *= 1.2;
   else if(volatility_ratio_short > 1.4)
      base_multiplier *= 1.1;
   else if(volatility_ratio_short < 0.6)
      base_multiplier *= 0.9;
   
   // 中期波动率环境调整
   if(volatility_ratio_medium > 1.6)
      base_multiplier *= 1.15;
   else if(volatility_ratio_medium > 1.3)
      base_multiplier *= 1.05;
   else if(volatility_ratio_medium < 0.8)
      base_multiplier *= 0.95;
   
   switch(SL_Type)
     {
      case 0: // Fixed ATR with Enhanced Volatility Adaptation
        {
         // 使用多级波动率比率替代单一volatility_ratio
         if(volatility_ratio_medium > 1.5) // 高波动期
             base_multiplier *= 1.1;
         else if(volatility_ratio_medium < 0.7) // 低波动期
             base_multiplier *= 0.9;
              
         sl_size_usd = atr_value * base_multiplier;
         break;
        }
      case 1: // Dynamic ATR with Market Regime Detection
        {
         // 市场状态检测：趋势vs震荡
         bool is_trending_market = trend_strength > 0.5;
         
         // 动态止损调整策略
         double dynamic_factor = 1.0;
         
         if(is_trending_market)
           {
            // 趋势市场：基于趋势强度和波动率变化调整
            dynamic_factor = 0.9 + (0.2 * trend_strength);
            if(volatility_ratio_short > 1.2)
               dynamic_factor *= 1.1;
           }
         else
           {
            // 震荡市场：需要更大的止损空间
            dynamic_factor = 1.2 + (0.3 * (1 - trend_strength));
            if(volatility_ratio_medium > 1.3)
               dynamic_factor *= 1.15;
           }
         
         sl_size_usd = base_multiplier * dynamic_factor * atr_value;
         
         // 应用最大止损限制
         double max_sl_size = 4.0 * atr_avg_20; // 最大不超过20周期平均ATR的4倍
         if(sl_size_usd > max_sl_size)
            sl_size_usd = max_sl_size;
            
         break;
        }
      case 2: // Enhanced Swing Low/High with Validation
        {
         // 改进的摆动点检测，使用更高低点确认
         int swing_lookback = 20; // 回看20个K线
         double swing_point = 0;
         
         if(is_buy)
           {
            // 为买入找到最近的显著低点，并确保有足够的确认
            double lowest_low = iLow(_Symbol, PERIOD_M15, 0);
            int lowest_low_index = 0;
            
            for(int i = 1; i < swing_lookback; i++)
              {
               double current_low = iLow(_Symbol, PERIOD_M15, i);
               if(current_low < lowest_low)
                 {
                  lowest_low = current_low;
                  lowest_low_index = i;
                 }
              }
            
            // 验证低点是否有效（两边至少有1根K线确认）
            if(lowest_low_index > 0 && lowest_low_index < swing_lookback - 1)
              {
               bool valid_low = true;
               for(int i = 1; i <= 2 && valid_low; i++)
                 {
                  if(iLow(_Symbol, PERIOD_M15, lowest_low_index - i) < lowest_low || 
                     iLow(_Symbol, PERIOD_M15, lowest_low_index + i) < lowest_low)
                     valid_low = false;
                 }
                  
               if(valid_low)
                  swing_point = lowest_low;
               else
                  swing_point = lowest_low - (atr_value * 0.2); // 如果没有有效低点，稍微扩大范围
              }
            else
               swing_point = lowest_low;
            
            // 计算基于摆动低点的止损，添加ATR缓冲并考虑波动率
            double buffer_multiplier = (volatility_ratio_medium > 1.3) ? 0.6 : 0.4;
            sl_size_usd = MathMax((entry_price - swing_point) + (atr_value * buffer_multiplier), 
                                 atr_value * base_multiplier);
           }
         else
           {
            // 为卖出找到最近的显著高点，并确保有足够的确认
            double highest_high = iHigh(_Symbol, PERIOD_M15, 0);
            int highest_high_index = 0;
            
            for(int i = 1; i < swing_lookback; i++)
              {
               double current_high = iHigh(_Symbol, PERIOD_M15, i);
               if(current_high > highest_high)
                 {
                  highest_high = current_high;
                  highest_high_index = i;
                 }
              }
            
            // 验证高点是否有效
            if(highest_high_index > 0 && highest_high_index < swing_lookback - 1)
              {
               bool valid_high = true;
               for(int i = 1; i <= 2 && valid_high; i++)
                 {
                  if(iHigh(_Symbol, PERIOD_M15, highest_high_index - i) > highest_high || 
                     iHigh(_Symbol, PERIOD_M15, highest_high_index + i) > highest_high)
                     valid_high = false;
                 }
                
               if(valid_high)
                  swing_point = highest_high;
               else
                  swing_point = highest_high + (atr_value * 0.2); // 如果没有有效高点，稍微扩大范围
              }
            else
               swing_point = highest_high;
            
            // 计算基于摆动高点的止损，添加ATR缓冲并考虑波动率
            double buffer_multiplier = (volatility_ratio_medium > 1.3) ? 0.6 : 0.4;
            sl_size_usd = MathMax((swing_point - entry_price) + (atr_value * buffer_multiplier), 
                                 atr_value * base_multiplier);
           }
         
         // 摆动交易止损额外验证：确保足够的风险回报比
         double potential_tp = CalculateTakeProfitPrice(is_buy, entry_price);
         double potential_rr = (is_buy ? (potential_tp - entry_price) : (entry_price - potential_tp)) / sl_size_usd;
         
         // 如果风险回报比低于1.0，适当调整止损以确保最小风险回报比
         if(potential_rr < 1.0)
            sl_size_usd *= 0.8; // 减小止损以提高风险回报比
            
         break;
        }
      default:
        {
         sl_size_usd = atr_value * base_multiplier;
         break;
        }
     }
   
   // 确保止损满足交易平台的最小止损距离要求
   if(sl_size_usd < min_stop_distance)
      sl_size_usd = min_stop_distance;
      
   // 确保止损至少为1个点
   if(sl_size_usd < _Point)
      sl_size_usd = _Point;
   
   // 基于波动率设置最大止损限制
   double max_stop_limit = atr_avg_20 * 3.0; // 不超过20周期平均ATR的3倍
   if(sl_size_usd > max_stop_limit)
      sl_size_usd = max_stop_limit;
   
   // 计算最终止损价格
   if(is_buy)
      sl_price = entry_price - sl_size_usd;
   else
      sl_price = entry_price + sl_size_usd;
   
   // 四舍五入到交易品种的位数
   sl_price = NormalizeDouble(sl_price, _Digits);
   
   // Log the SL calculation
   string sl_type_desc = "";
   switch(SL_Type)
     {
      case 0: sl_type_desc = "Fixed ATR";
         break;
      case 1: sl_type_desc = "Dynamic ATR";
         break;
      case 2: sl_type_desc = "Swing Low/High";
         break;
     }
   Print("Stop Loss calculated using ", sl_type_desc, ": ", DoubleToString(sl_price, _Digits),
  " (", DoubleToString(sl_size_usd / _Point, 1), " pips)");
   
   return(sl_price);
  }

//+------------------------------------------------------------------+
//| Find significant support/resistance levels                       |
//+------------------------------------------------------------------+
double FindNearestSupportResistance(const bool is_buy, const double current_price, const double trend_strength = 0.5)
  {
   // Adjust lookback period based on trend strength
   // Stronger trend = larger lookback period
   int base_lookback = 50;
   int lookback = (int)(base_lookback * (1.0 + trend_strength * 0.5)); // 50-75 bars
   
   // Track multiple levels for better selection
   double best_level = 0;
   double best_distance = 1000000.0; // Very large initial value
   double second_best_level = 0;
   double second_best_distance = 1000000.0;
   
   // ATR-based volatility adjustment
   double atr_value = GetATR(1);
   double volatility_factor = 1.0;
   
   // Check multiple levels (highs, lows, opens, closes) for better support/resistance
   double levels[4]; // Store high, low, open, close
   
   if(is_buy)
     {
      // Find nearest resistance above current price
      for(int i = 1; i < lookback; i++)
        {
         levels[0] = iHigh(_Symbol, PERIOD_M15, i);
         levels[1] = iLow(_Symbol, PERIOD_M15, i);
         levels[2] = iOpen(_Symbol, PERIOD_M15, i);
         levels[3] = iClose(_Symbol, PERIOD_M15, i);
         
         for(int j = 0; j < 4; j++)
           {
            double level = levels[j];
            if(level > current_price && ValidateSupportResistanceLevel(level, i, is_buy, trend_strength))
              {
               double distance = level - current_price;
               
               // Prioritize levels based on price action and trend strength
               double priority_factor = 1.0;
               if(j == 0 || j == 1) priority_factor = 1.2; // Prioritize highs/lows
               
               // Adjust for trend alignment
               if(trend_strength > 0.7) priority_factor *= 1.1; // Strengthened trend = more reliable levels
               
               double weighted_distance = distance * priority_factor;
               
               if(weighted_distance < best_distance * priority_factor)
                 {
                  second_best_level = best_level;
                  second_best_distance = best_distance;
                  best_distance = distance;
                  best_level = level;
                 }
               else if(weighted_distance < second_best_distance * priority_factor)
                 {
                  second_best_distance = distance;
                  second_best_level = level;
                 }
               }
           }
        }
     }
   else
     {
      // Find nearest support below current price
      for(int i = 1; i < lookback; i++)
        {
         levels[0] = iHigh(_Symbol, PERIOD_M15, i);
         levels[1] = iLow(_Symbol, PERIOD_M15, i);
         levels[2] = iOpen(_Symbol, PERIOD_M15, i);
         levels[3] = iClose(_Symbol, PERIOD_M15, i);
         
         for(int j = 0; j < 4; j++)
           {
            double level = levels[j];
            if(level < current_price && ValidateSupportResistanceLevel(level, i, is_buy, trend_strength))
              {
               double distance = current_price - level;
               
               // Prioritize levels based on price action and trend strength
               double priority_factor = 1.0;
               if(j == 0 || j == 1) priority_factor = 1.2; // Prioritize highs/lows
               
               // Adjust for trend alignment
               if(trend_strength > 0.7) priority_factor *= 1.1; // Strengthened trend = more reliable levels
               
               double weighted_distance = distance * priority_factor;
               
               if(weighted_distance < best_distance * priority_factor)
                 {
                  second_best_level = best_level;
                  second_best_distance = best_distance;
                  best_distance = distance;
                  best_level = level;
                 }
               else if(weighted_distance < second_best_distance * priority_factor)
                 {
                  second_best_distance = distance;
                  second_best_level = level;
                 }
               }
           }
        }
     }
   
   // Apply trend strength adjustment to the selected level
   if(best_level > 0)
     {
      // In strong trends, aim for slightly further targets
      double trend_adjustment = 0.0;
      if(trend_strength > 0.7)
         trend_adjustment = atr_value * 0.3 * trend_strength; // Additional 0-0.3 ATR in strong trends
      
      if(is_buy)
         best_level += trend_adjustment;
      else
         best_level -= trend_adjustment;
     }
   
   // If no level found, return dynamic target based on trend and volatility
   if(best_level == 0)
     {
      double atr_multiplier = 2.0 + (trend_strength * 1.0); // 2.0-3.0 based on trend
      if(is_buy)
         best_level = current_price + (atr_value * atr_multiplier);
      else
         best_level = current_price - (atr_value * atr_multiplier);
     }
   
   return(best_level);
  }

//+------------------------------------------------------------------+
//| Validate a support/resistance level                              |
//+------------------------------------------------------------------+
bool ValidateSupportResistanceLevel(const double level, const int bar_index, const bool is_buy, const double trend_strength)
  {
   // Minimum price touch requirement (based on trend strength)
   int min_touches = 1;
   if(trend_strength < 0.5) min_touches = 2; // More confirmation needed in weak trends
   
   // ATR-based tolerance for considering a touch
   double atr_value = GetATR(1);
   double tolerance = atr_value * 0.15; // 15% of ATR
   
   // Count touches in recent history (more significant if touched multiple times)
   int touches = 0;
   int confirmation_lookback = MathMin(100, bar_index + 50); // Look back up to 100 bars
   
   for(int i = 0; i < confirmation_lookback; i++)
     {
      // Check if price has touched this level in the past
      double high = iHigh(_Symbol, PERIOD_M15, i);
      double low = iLow(_Symbol, PERIOD_M15, i);
      
      if(is_buy && level <= high && level >= low) // Resistance level touched
         touches++;
      else if(!is_buy && level <= high && level >= low) // Support level touched
         touches++;
      
      // Early exit if we have enough confirmation
      if(touches >= min_touches + 1) break;
     }
   
   // Check for clear price rejection
   bool has_rejection = false;
   if(bar_index > 0)
     {
      double bar_high = iHigh(_Symbol, PERIOD_M15, bar_index);
      double bar_low = iLow(_Symbol, PERIOD_M15, bar_index);
      double bar_close = iClose(_Symbol, PERIOD_M15, bar_index);
      double bar_open = iOpen(_Symbol, PERIOD_M15, bar_index);
      
      if(is_buy && bar_high >= level && bar_high - bar_low > atr_value * 0.8)
        {
         // Bullish rejection from resistance (indicating stronger level)
         if(bar_close < bar_open && bar_close > level * 0.999) // Price closed below resistance
            has_rejection = true;
        }
      else if(!is_buy && bar_low <= level && bar_high - bar_low > atr_value * 0.8)
        {
         // Bearish rejection from support (indicating stronger level)
         if(bar_close > bar_open && bar_close < level * 1.001) // Price closed above support
            has_rejection = true;
        }
     }
   
   // Time-based validation - more recent levels are more relevant
   double recency_factor = 1.0 - MathMin(1.0, (double)bar_index / 100.0); // 100 bars = old enough
   
   // Volume validation - check if volume was higher at this level
   long level_volume = iVolume(_Symbol, PERIOD_M15, bar_index);
   double avg_volume = 0.0;
   int volume_lookback = MathMin(20, bar_index);
   for(int i = 0; i < volume_lookback; i++)
      avg_volume += iVolume(_Symbol, PERIOD_M15, bar_index + i);
   avg_volume /= volume_lookback;
   
   bool high_volume = (level_volume > avg_volume * 1.2); // 20% above average volume
   
   // Final validation logic
   bool valid = false;
   
   if(touches >= min_touches)
      valid = true;
   else if(has_rejection) // Strong rejection is sufficient even with fewer touches
      valid = true;
   else if(high_volume && bar_index < 20) // Recent high volume levels are significant
      valid = true;
   
   // In very strong trends, be more lenient with validation
   if(trend_strength > 0.85 && touches >= 1)
      valid = true;
   
   return valid;
  }

//+------------------------------------------------------------------+
//| Check for trend reversal signals                                 |
//+------------------------------------------------------------------+
bool IsTrendReversal(const bool is_buy)
  {
   // Check for trend reversal based on EMAs
   double ema50 = GetEMA50(0);
   double ema200 = GetEMA200(0);
   double ema50_prev = GetEMA50(1);
   double ema200_prev = GetEMA200(1);
   
   if(ema50 == 0 || ema200 == 0 || ema50_prev == 0 || ema200_prev == 0)
      return(false);
   
   // Check for EMA crossover in opposite direction
   bool ema_cross_reversal = false;
   if(is_buy)
     {
      // For buy, check if EMA50 is crossing below EMA200
      ema_cross_reversal = (ema50_prev > ema200_prev && ema50 <= ema200);
     }
   else
     {
      // For sell, check if EMA50 is crossing above EMA200
      ema_cross_reversal = (ema50_prev < ema200_prev && ema50 >= ema200);
     }
   
   // Check MACD reversal
   double macd_main[1], macd_signal[1], macd_histogram[1];
   double macd_main_prev[1], macd_signal_prev[1], macd_histogram_prev[1];
   
   if(GetMACDValues(macd_main, macd_signal, macd_histogram, 0) && 
      GetMACDValues(macd_main_prev, macd_signal_prev, macd_histogram_prev, 1))
     {
      bool macd_reversal = false;
      if(is_buy)
        {
         // For buy, check if MACD histogram is decreasing after peak
         if(macd_histogram_prev[0] > 0 && macd_histogram[0] < macd_histogram_prev[0])
            macd_reversal = true;
        }
      else
        {
         // For sell, check if MACD histogram is increasing after trough
         if(macd_histogram_prev[0] < 0 && macd_histogram[0] > macd_histogram_prev[0])
            macd_reversal = true;
        }
      
      return(ema_cross_reversal || macd_reversal);
     }
   
   return(ema_cross_reversal);
  }

//+------------------------------------------------------------------+
//| Enhanced Calculate take profit price with multiple strategies     |
//+------------------------------------------------------------------+
double CalculateTakeProfitPrice(const bool is_buy, const double entry_price, const double sl_size_usd)
  {
   double tp_price = 0;
   double atr_value = GetATR(0);
   double trend_strength = CalculateTrendStrength();
   double volatility_ratio = 0.0;
   
   // Calculate volatility ratio for dynamic adjustment
   if(avg_atr_20 > 0)
      volatility_ratio = atr_value / avg_atr_20;
   else
      volatility_ratio = 1.0;
   
   // Advanced Dynamic risk reward ratio based on market conditions
   double dynamic_rr = RiskRewardRatio;
   
   // 1. Adjust RR based on trend strength with more granular levels
   if(trend_strength > 0.85) // Very strong trend
      dynamic_rr *= 1.4; // Significantly increase target
   else if(trend_strength > 0.7) // Strong trend
      dynamic_rr *= 1.2; // Increase target
   else if(trend_strength > 0.5) // Moderate trend
      dynamic_rr *= 1.0; // Neutral
   else if(trend_strength > 0.3) // Weak trend
      dynamic_rr *= 0.9; // Slightly decrease target
   else // Very weak trend
      dynamic_rr *= 0.7; // Significantly decrease target
   
   // 2. Adjust RR based on volatility with adaptive scaling
   if(volatility_ratio > 2.0) // Extremely high volatility
      dynamic_rr *= 0.7; // Reduce target more aggressively
   else if(volatility_ratio > 1.5) // High volatility
      dynamic_rr *= 0.85; // Reduce target
   else if(volatility_ratio < 0.5) // Very low volatility
      dynamic_rr *= 1.2; // Increase target more aggressively
   else if(volatility_ratio < 0.7) // Low volatility
      dynamic_rr *= 1.1; // Increase target
   
   // 3. Adjust RR based on account drawdown (risk management)
   double current_drawdown = CalculateDrawdown();
   if(current_drawdown > Max_Drawdown_Percent * 0.8) // Near max drawdown
      dynamic_rr *= 0.9; // Be more conservative
   
   // 4. Adjust RR based on daily risk usage
   if(daily_risk_used > Max_Daily_Risk_Percent * 0.7) // Used significant daily risk
      dynamic_rr *= 0.95; // Slightly more conservative
   
   switch(TP_Type)
     {
      case 0: // Fixed Risk/Reward with enhanced dynamic adjustment
        {
         double tp_size_usd = sl_size_usd * dynamic_rr;
         
         if(is_buy)
            tp_price = entry_price + tp_size_usd;
         else
            tp_price = entry_price - tp_size_usd;
         
         if(DebugMode)
            Print("[DEBUG] Take Profit calculated (Enhanced Dynamic RR): ", DoubleToString(tp_price, _Digits),
  " (", DoubleToString(tp_size_usd / _Point, 1), " pips, Base R:R ", DoubleToString(RiskRewardRatio, 2), ":1, ",
  "Dynamic R:R ", DoubleToString(dynamic_rr, 2), ":1, Trend Strength ", DoubleToString(trend_strength, 2),
  ", Volatility Ratio ", DoubleToString(volatility_ratio, 2), ", Drawdown ", DoubleToString(current_drawdown, 2), "%");
         break;
        }
      case 1: // Advanced Multi-Target with enhanced partial profit taking
        {
         // Calculate dynamic targets based on market conditions
         double tp1_rr = 1.0 + (trend_strength * 0.5); // 1.0-1.5:1 based on trend
         double tp2_rr = tp1_rr * TP2_RR_Multiplier;
         double tp3_rr = dynamic_rr;
         
         // TP1: 40% profit at adjusted 1.0-1.5:1 RR
         double tp1_size_usd = sl_size_usd * tp1_rr;
         double tp1_price = is_buy ? (entry_price + tp1_size_usd) : (entry_price - tp1_size_usd);
         
         // TP2: 30% profit at adjusted 1.5-2.25:1 RR
         double tp2_size_usd = sl_size_usd * tp2_rr;
         double tp2_price = is_buy ? (entry_price + tp2_size_usd) : (entry_price - tp2_size_usd);
         
         // TP3: 30% profit at fully dynamic RR
         double tp3_size_usd = sl_size_usd * tp3_rr;
         double tp3_price = is_buy ? (entry_price + tp3_size_usd) : (entry_price - tp3_size_usd);
         
         // Store targets in global variables for partial close tracking
         global_tp1_price = tp1_price;
         global_tp2_price = tp2_price;
         global_tp3_price = tp3_price;
         
         // Return TP1 as the initial take profit
         tp_price = tp1_price;
         
         if(DebugMode)
         {
            Print("[DEBUG] Advanced Multi-Target Strategy - TP1 (", DoubleToString(tp1_price, _Digits), ", ", DoubleToString(tp1_rr, 2), ":1 RR, 40% of position)");
            Print("[DEBUG] Advanced Multi-Target Strategy - TP2 (", DoubleToString(tp2_price, _Digits), ", ", DoubleToString(tp2_rr, 2), ":1 RR, 30% of position)");
            Print("[DEBUG] Advanced Multi-Target Strategy - TP3 (", DoubleToString(tp3_price, _Digits), ", ", DoubleToString(tp3_rr, 2), ":1 RR, 30% of position)");
         }
         break;
        }
      case 2: // Enhanced Support/Resistance with trend alignment and validation
        {
         // Use enhanced support/resistance detection with trend alignment
         tp_price = FindNearestSupportResistance(is_buy, entry_price, trend_strength);
         
         // Validate support/resistance level with additional checks
         bool level_valid = ValidateSupportResistanceLevel(tp_price, is_buy, trend_strength);
         
         // Check if the found level is valid, too close or too far
         double distance = MathAbs(tp_price - entry_price);
         double min_distance = sl_size_usd * 0.8; // At least 80% of SL distance
         double max_distance = sl_size_usd * 6.0; // Maximum 6x SL distance
         
         if(!level_valid || distance < min_distance || distance > max_distance)
           {
            if(DebugMode)
               Print("[DEBUG] Support/Resistance level invalid or extreme, using Dynamic ATR-based fallback");
            
            // Advanced fallback to volatility-adapted ATR target
            double atr_multiplier = ATR_Profit_Multiplier * (0.8 + trend_strength * 0.4);
            double atr_based_tp = is_buy ? 
              (entry_price + atr_value * atr_multiplier) : 
              (entry_price - atr_value * atr_multiplier);
            tp_price = atr_based_tp;
           }
         
         // Calculate distance in pips and implied RR
         distance = is_buy ? (tp_price - entry_price) : (entry_price - tp_price);
         double implied_rr = distance / sl_size_usd;
         
         // Ensure implied RR is within reasonable bounds
         if(implied_rr < 1.0 && TP_Type == 2)
         {
            if(DebugMode)
               Print("[DEBUG] Implied RR too low, adjusting to minimum 1.0:1");
            
            double min_tp_size_usd = sl_size_usd * 1.0;
            tp_price = is_buy ? (entry_price + min_tp_size_usd) : (entry_price - min_tp_size_usd);
            implied_rr = 1.0;
         }
         
         if(DebugMode)
            Print("[DEBUG] Take Profit calculated (Enhanced S/R): ", DoubleToString(tp_price, _Digits),
  " (", DoubleToString(distance / _Point, 1), " pips, Implied R:R ", DoubleToString(implied_rr, 2), ":1)");
         break;
        }
      case 3: // Advanced ATR-based with market regime adaptation
        {
         // Calculate market regime factor (combines trend and volatility)
         double market_regime_factor = CalculateMarketRegimeFactor(trend_strength, volatility_ratio);
         
         // Base ATR multiplier with comprehensive adaptation
         double atr_multiplier = ATR_Profit_Multiplier;
         
         // Adjust multiplier based on market regime
         atr_multiplier *= market_regime_factor;
         
         // Fine-tune based on current volatility
         if(volatility_ratio > 1.8) // Very high volatility
            atr_multiplier *= 0.8;
         else if(volatility_ratio < 0.6) // Very low volatility
            atr_multiplier *= 1.25;
         
         // Ensure multiplier stays within reasonable bounds
         atr_multiplier = MathMax(0.5, MathMin(4.0, atr_multiplier));
         
         double tp_distance = atr_value * atr_multiplier;
         tp_price = is_buy ? (entry_price + tp_distance) : (entry_price - tp_distance);
         
         double implied_rr = tp_distance / sl_size_usd;
         
         if(DebugMode)
            Print("[DEBUG] Take Profit calculated (Market Regime-Adapted ATR): ", DoubleToString(tp_price, _Digits),
  " (", DoubleToString(tp_distance / _Point, 1), " pips, ATR Multiplier ", DoubleToString(atr_multiplier, 2), ", ",
  "Market Regime Factor ", DoubleToString(market_regime_factor, 2), ", Implied R:R ", DoubleToString(implied_rr, 2), ":1)");
         break;
        }
      case 4: // Dynamic Volatility-Adjusted with Profit Maximization
        {
         // Base target is standard RR
         double base_tp_size_usd = sl_size_usd * dynamic_rr;
         
         // Calculate profit maximization factor based on trend persistence
         double trend_persistence = CalculateTrendPersistence();
         double profit_max_factor = 1.0 + (trend_persistence * 0.5);
         
         // Final target with profit maximization
         double final_tp_size_usd = base_tp_size_usd * profit_max_factor;
         
         tp_price = is_buy ? (entry_price + final_tp_size_usd) : (entry_price - final_tp_size_usd);
         
         double implied_rr = final_tp_size_usd / sl_size_usd;
         
         if(DebugMode)
            Print("[DEBUG] Take Profit calculated (Profit Maximization): ", DoubleToString(tp_price, _Digits),
  " (", DoubleToString(final_tp_size_usd / _Point, 1), " pips, Base R:R ", DoubleToString(dynamic_rr, 2), ":1, ",
  "Profit Max Factor ", DoubleToString(profit_max_factor, 2), ", Final R:R ", DoubleToString(implied_rr, 2), ":1)");
         break;
        }
      default: // Default to Enhanced Fixed RR
        {
         double tp_size_usd = sl_size_usd * dynamic_rr;
         
         if(is_buy)
            tp_price = entry_price + tp_size_usd;
         else
            tp_price = entry_price - tp_size_usd;
        }
     }
   
   // Ensure TP is at least minimum distance from entry (enforce minimum RR)
   double min_tp_distance = sl_size_usd * 0.8; // Increased to 0.8:1 minimum RR
   double calculated_distance = MathAbs(tp_price - entry_price);
   
   if(calculated_distance < min_tp_distance)
     {
      if(DebugMode)
         Print("[DEBUG] Adjusting TP: Too close to entry, using minimum RR of 0.8:1");
         
      if(is_buy)
         tp_price = entry_price + min_tp_distance;
      else
         tp_price = entry_price - min_tp_distance;
     }
   
   // Round TP price to symbol's digits
   tp_price = NormalizeDouble(tp_price, _Digits);
   
   return(tp_price);
  }

//+------------------------------------------------------------------+
//| 计算市场状态因子 - 用于止盈策略调整                                |
//+------------------------------------------------------------------+
double CalculateMarketRegimeFactor(const double trend_strength, const double volatility_ratio)
  {
   // Base factor starts at 1.0
   double factor = 1.0;
   
   // Adjust based on trend-volatility combination (market regime)
   if(trend_strength > 0.7 && volatility_ratio < 1.2) // Trending with normal volatility
      factor = 1.3; // Strong trend environment - extend targets
   else if(trend_strength > 0.7 && volatility_ratio > 1.5) // Trending with high volatility
      factor = 1.1; // High volatility trend - moderately extend
   else if(trend_strength < 0.4 && volatility_ratio < 0.8) // Low trend, low volatility
      factor = 0.9; // Ranging market - reduce targets
   else if(trend_strength < 0.4 && volatility_ratio > 1.5) // Low trend, high volatility
      factor = 0.8; // Chaotic market - significantly reduce targets
   
   return factor;
  }

//+------------------------------------------------------------------+
//| 计算趋势持续性 - 用于利润最大化策略                                |
//+------------------------------------------------------------------+
double CalculateTrendPersistence()
  {
   // Default persistence if indicators unavailable
   double persistence = 0.5;
   
   // Calculate based on EMA50 slope consistency
   double ema50_slope_current = (GetEMA50(1) - GetEMA50(3)) / MathMax(GetEMA50(3), 1.0);
   double ema50_slope_prev = (GetEMA50(3) - GetEMA50(6)) / MathMax(GetEMA50(6), 1.0);
   
   // Check if slopes are in same direction and consistent
   if(ema50_slope_current != 0 && ema50_slope_prev != 0)
   {
      if((ema50_slope_current > 0 && ema50_slope_prev > 0) || 
         (ema50_slope_current < 0 && ema50_slope_prev < 0))
      {
         // Calculate persistence based on slope magnitude and consistency
         double slope_ratio = MathMin(1.0, MathAbs(ema50_slope_current / ema50_slope_prev));
         persistence = 0.5 + (slope_ratio * 0.5);
      }
   }
   
   return MathMax(0.1, MathMin(1.0, persistence));
  }

//+------------------------------------------------------------------+
//| 验证支撑/阻力位 - 确保其有效性和可靠性                              |
//+------------------------------------------------------------------+
bool ValidateSupportResistanceLevel(const double level, const bool is_buy, const double trend_strength)
  {
   // Basic validation - level must be significantly different from current price
   double current_price = is_buy ? Ask : Bid;
   double distance = MathAbs(level - current_price);
   double min_significant_distance = GetATR(0) * 0.5; // At least 0.5 ATR away
   
   if(distance < min_significant_distance)
      return false;
   
   // Check if level aligns with trend direction
   if(trend_strength > 0.6) // Strong trend
   {
      if(is_buy && level <= current_price) // Buy trade but resistance below current price
         return false;
      if(!is_buy && level >= current_price) // Sell trade but support above current price
         return false;
   }
   
   return true;
  }

//+------------------------------------------------------------------+
//| Execute trade based on signals and filters                       |
//+------------------------------------------------------------------+
void ExecuteTrade(const bool is_buy)
  {
   // Get current price
   double ask_price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid_price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double entry_price = is_buy ? ask_price : bid_price;
   
   // Calculate SL
   double sl_price = CalculateStopLossPrice(is_buy, entry_price);
   if(sl_price == 0)
     {
      Print("Error: Could not calculate stop loss price");
      return;
     }
   
   // Calculate SL size in USD and pips
   double sl_size_usd = is_buy ? (entry_price - sl_price) : (sl_price - entry_price);
   double sl_pips = sl_size_usd / _Point;
   
   // Check daily risk limit before opening new trade
   if(!CanTakeNewTrade(Risk_Per_Trade_Percent))
      return;
   
   // Calculate position size with signal direction for dynamic risk adjustment
   double lot_size = CalculatePositionSize(sl_pips, is_buy);
   if(lot_size <= 0)
     {
      Print("Error: Invalid position size calculated");
      return;
     }
   
   // Calculate TP
   double tp_price = CalculateTakeProfitPrice(is_buy, entry_price, sl_size_usd);
   
   // Execute trade
   string trade_type = is_buy ? "Buy" : "Sell";
   Print("Executing ", trade_type, " trade at ", DoubleToString(entry_price, _Digits),
  ", SL: ", DoubleToString(sl_price, _Digits),
  ", TP: ", DoubleToString(tp_price, _Digits),
  ", Lot size: ", DoubleToString(lot_size, 2));
   
   // Execute the trade
   MqlTradeResult result;
   if(is_buy)
     {
      if(!trade.Buy(lot_size, _Symbol, 0, sl_price, tp_price, trade_type + " Entry"))
        {
         Print("Error executing Buy trade: " + IntegerToString(GetLastError()));
         return;
        }
     }
   else
     {
      if(!trade.Sell(lot_size, _Symbol, 0, sl_price, tp_price, trade_type + " Entry"))
        {
         Print("Error executing Sell trade: " + IntegerToString(GetLastError()));
         return;
        }
     }
   
   // Update daily risk used
   daily_risk_used += Risk_Per_Trade_Percent;
   Print("Daily risk updated:", DoubleToString(daily_risk_used, 2), "% of account");
  }

//+------------------------------------------------------------------+
//| Get EMA50 value                                                  |
//+------------------------------------------------------------------+
double GetEMA50(const int shift = 0)
  {
   double ema50_value[1];
   if(CopyBuffer(handle_ema50, 0, shift, 1, ema50_value) <= 0)
      return(0.0);
   return(ema50_value[0]);
  }

//+------------------------------------------------------------------+
//| Get EMA200 value                                                 |
//+------------------------------------------------------------------+
double GetEMA200(const int shift = 0)
  {
   double ema200_value[1];
   if(CopyBuffer(handle_ema200, 0, shift, 1, ema200_value) <= 0)
      return(0.0);
   return(ema200_value[0]);
  }

//+------------------------------------------------------------------+
//| Get MACD values                                                  |
//+------------------------------------------------------------------+
bool GetMACDValues(double &main[], double &signal[], double &histogram[], const int shift = 0)
  {
   if(CopyBuffer(handle_macd, 0, shift, 1, histogram) <= 0) return(false);
   if(CopyBuffer(handle_macd, 1, shift, 1, signal) <= 0) return(false);
   if(CopyBuffer(handle_macd, 2, shift, 1, main) <= 0) return(false);
   return(true);
  }

//+------------------------------------------------------------------+
//| Get Volume SMA value                                             |
//+------------------------------------------------------------------+
double GetVolumeMA(const int shift = 0)
  {
   double volume_ma_value[1];
   if(CopyBuffer(handle_volume_ma, 0, shift, 1, volume_ma_value) <= 0)
      return(0.0);
   return(volume_ma_value[0]);
  }

//+------------------------------------------------------------------+
//| Get ATR value                                                    |
//+------------------------------------------------------------------+
double GetATR(const int shift = 0)
  {
   double atr_value[1];
   if(CopyBuffer(handle_atr, 0, shift, 1, atr_value) <= 0)
      return(0.0);
   return(atr_value[0]);
  }

//+------------------------------------------------------------------+
//| Get current tick volume                                          |
//+------------------------------------------------------------------+
long GetCurrentVolume(const int shift = 0)
  {
   return(iVolume(_Symbol, PERIOD_M15, shift));
  }

//+------------------------------------------------------------------+
//| Check for UT Bot signals                                         |
//+------------------------------------------------------------------+
void CheckUTBotSignals()
  {
//--- Add diagnostic logging for UT Bot signals
   static int bar_counter = 0;
   
//--- Only check for signals on bar close
   static datetime prev_bar_time = 0;
   datetime current_bar_time = iTime(_Symbol, PERIOD_M15, 0);
   
   if(current_bar_time == prev_bar_time)
      return; // No new bar yet
   
   bar_counter++;
   if(bar_counter % 10 == 0) // Log every 10 bars
      Print("Checking UT Bot signals on new bar: ", TimeToString(current_bar_time));
   
   prev_bar_time = current_bar_time;
   
   // Reset previous signals for the new bar
   prev_ut_buy_signal = 0;
   prev_ut_sell_signal = 0;
   
//--- Get ATR value and filter based on volatility
   double atr_value = GetATR(1); // Previous bar's ATR
   if(atr_value == 0)
     {
      Print("Warning: ATR value is zero, skipping UT Bot signal check");
      return;
     }
   
   // Get average ATR over longer period to filter out noise
   double avg_atr_20 = 0;
   for(int i=1; i<=20; i++)
     avg_atr_20 += GetATR(i);
   avg_atr_20 /= 20;
   
   // Skip signals during extremely low volatility periods
   if(atr_value < avg_atr_20 * 0.5)
     {
      Print("Low volatility environment detected, skipping UT Bot signals");
      return;
     }
   
//--- Calculate ATR-based thresholds with stricter multiplier
   double atr_threshold = atr_value * (UT_ATR_Multiplier > 0 ? UT_ATR_Multiplier : 1.2); // Ensure minimum multiplier
   
//--- Get price data for signal calculation with additional bars
   double close_prev = iClose(_Symbol, PERIOD_M15, 1);
   double close_prev_2 = iClose(_Symbol, PERIOD_M15, 2);
   double close_prev_3 = iClose(_Symbol, PERIOD_M15, 3);
   double high_prev = iHigh(_Symbol, PERIOD_M15, 1);
   double low_prev = iLow(_Symbol, PERIOD_M15, 1);
   double open_prev = iOpen(_Symbol, PERIOD_M15, 1);
   
   // Get EMA values for trend alignment
   double ema50_prev = GetEMA50(1);
   double ema50_prev_2 = GetEMA50(2);
   
   // Get volume for volume confirmation
   long volume_prev = GetCurrentVolume(1);
   double volume_ma_prev = GetVolumeMA(1);
   
//--- UT Bot Buy Signal logic: Enhanced with multiple confirmations
   bool ut_buy_signal = false;
   
   // Main price movement condition - stricter than before
   bool main_price_condition = (high_prev - close_prev_2) >= (atr_threshold * UT_Sensitivity) && close_prev > close_prev_2;
   
   // Trend alignment condition - price should be above EMA50 or EMA50 should be rising
   bool trend_alignment = (close_prev > ema50_prev) || (ema50_prev > ema50_prev_2);
   
   // Volume confirmation - volume should be higher than average
   bool volume_confirmation = volume_prev > volume_ma_prev * 1.2;
   
   // Price pattern confirmation - higher lows pattern
   bool higher_lows = (low_prev > iLow(_Symbol, PERIOD_M15, 2)) && (iLow(_Symbol, PERIOD_M15, 2) > iLow(_Symbol, PERIOD_M15, 3));
   
   // Close above open confirmation
   bool close_above_open = close_prev > open_prev;
   
   // Signal strength calculation
   int buy_signal_strength = 0;
   if(main_price_condition) buy_signal_strength++;
   if(trend_alignment) buy_signal_strength++;
   if(volume_confirmation) buy_signal_strength++;
   if(higher_lows) buy_signal_strength++;
   if(close_above_open) buy_signal_strength++;
   
   // Main price condition is mandatory, and need at least 3 conditions total
   if(main_price_condition && buy_signal_strength >= 3)
     {
      ut_buy_signal = true;
      Print("UT Bot Buy Signal conditions: Price: ", main_price_condition, ", Trend: ", trend_alignment, ", Volume: ", volume_confirmation, ", Higher Lows: ", higher_lows, ", Close>Open: ", close_above_open, ", Strength: ", buy_signal_strength);
     }
   
//--- UT Bot Sell Signal logic: Enhanced with multiple confirmations
   bool ut_sell_signal = false;
   
   // Main price movement condition - stricter than before
   bool sell_price_condition = (close_prev_2 - low_prev) >= (atr_threshold * UT_Sensitivity) && close_prev < close_prev_2;
   
   // Trend alignment condition - price should be below EMA50 or EMA50 should be falling
   bool sell_trend_alignment = (close_prev < ema50_prev) || (ema50_prev < ema50_prev_2);
   
   // Volume confirmation - volume should be higher than average
   bool sell_volume_confirmation = volume_prev > volume_ma_prev * 1.2;
   
   // Price pattern confirmation - lower highs pattern
   bool lower_highs = (high_prev < iHigh(_Symbol, PERIOD_M15, 2)) && (iHigh(_Symbol, PERIOD_M15, 2) < iHigh(_Symbol, PERIOD_M15, 3));
   
   // Close below open confirmation
   bool close_below_open = close_prev < open_prev;
   
   // Signal strength calculation
   int sell_signal_strength = 0;
   if(sell_price_condition) sell_signal_strength++;
   if(sell_trend_alignment) sell_signal_strength++;
   if(sell_volume_confirmation) sell_signal_strength++;
   if(lower_highs) sell_signal_strength++;
   if(close_below_open) sell_signal_strength++;
   
   // Main price condition is mandatory, and need at least 3 conditions total
   if(sell_price_condition && sell_signal_strength >= 3)
     {
      ut_sell_signal = true;
      Print("UT Bot Sell Signal conditions: Price: ", sell_price_condition, ", Trend: ", sell_trend_alignment, ", Volume: ", sell_volume_confirmation, ", Lower Highs: ", lower_highs, ", Close<Open: ", close_below_open, ", Strength: ", sell_signal_strength);
     }
   
//--- Check for new signals with conflict resolution
   if(ut_buy_signal && !ut_sell_signal)
     {
      // New UT Bot Buy signal detected
      prev_ut_buy_signal = buy_signal_strength; // Store signal strength
      
      // Store signal candle data for pullback calculations
      ut_signal_candle_high = high_prev;
      ut_signal_candle_low = low_prev;
      ut_signal_candle_midpoint = (high_prev + low_prev) / 2;
      
      // Set pullback direction and flag
      current_pullback_direction = BUY;
      waiting_for_pullback = true;
      
      Print("UT Bot Buy Signal detected at bar close (Strength: ", buy_signal_strength, "). Waiting for pullback.");
     }
   else if(ut_sell_signal && !ut_buy_signal)
     {
      // New UT Bot Sell signal detected
      prev_ut_sell_signal = sell_signal_strength; // Store signal strength
      
      // Store signal candle data for pullback calculations
      ut_signal_candle_high = high_prev;
      ut_signal_candle_low = low_prev;
      ut_signal_candle_midpoint = (high_prev + low_prev) / 2;
      
      // Set pullback direction and flag
      current_pullback_direction = SELL;
      waiting_for_pullback = true;
      
      Print("UT Bot Sell Signal detected at bar close (Strength: ", sell_signal_strength, "). Waiting for pullback.");
     }
   else if(ut_buy_signal && ut_sell_signal)
     {
      // Conflict: both signals detected. Choose stronger one if significant difference exists
      if(buy_signal_strength > sell_signal_strength + 1)
        {
         // Buy signal is significantly stronger
         prev_ut_buy_signal = buy_signal_strength;
         ut_signal_candle_high = high_prev;
         ut_signal_candle_low = low_prev;
         ut_signal_candle_midpoint = (high_prev + low_prev) / 2;
         current_pullback_direction = BUY;
         waiting_for_pullback = true;
         Print("UT Bot Signal Conflict: Buy signal (Strength: ", buy_signal_strength, ") stronger than Sell (Strength: ", sell_signal_strength, ")");
        }
      else if(sell_signal_strength > buy_signal_strength + 1)
        {
         // Sell signal is significantly stronger
         prev_ut_sell_signal = sell_signal_strength;
         ut_signal_candle_high = high_prev;
         ut_signal_candle_low = low_prev;
         ut_signal_candle_midpoint = (high_prev + low_prev) / 2;
         current_pullback_direction = SELL;
         waiting_for_pullback = true;
         Print("UT Bot Signal Conflict: Sell signal (Strength: ", sell_signal_strength, ") stronger than Buy (Strength: ", buy_signal_strength, ")");
        }
      else
        {
         // Signals are too close in strength, ignore both
         Print("UT Bot Signal Conflict: Both signals too close in strength (Buy: ", buy_signal_strength, ", Sell: ", sell_signal_strength, "). Ignoring both.");
        }
     }
  }

//+------------------------------------------------------------------+
//| Manage open positions                                            |
//+------------------------------------------------------------------+
void ManageOpenPositions()
  {
   // Get current prices and market data
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   datetime current_time = TimeCurrent();
   
   // Get indicator values for decision making
   double atr_value = GetATR(0);
   double ema50 = GetEMA50(0);
   double ema200 = GetEMA200(0);
   
   // Check all open positions for this EA
   for(int i = 0; i < PositionsTotal(); i++)
     {
      if(PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_MAGIC) == 20231114)
        {
         // Get position details
         ulong ticket = PositionGetInteger(POSITION_TICKET);
         int position_type = (int)PositionGetInteger(POSITION_TYPE);
         double open_price = PositionGetDouble(POSITION_PRICE_OPEN);
         double current_sl = PositionGetDouble(POSITION_SL);
         double current_tp = PositionGetDouble(POSITION_TP);
         double current_profit = PositionGetDouble(POSITION_PROFIT);
         double position_volume = PositionGetDouble(POSITION_VOLUME);
         datetime open_time = PositionGetInteger(POSITION_TIME);
         
         // Calculate position age in minutes
         int position_age_minutes = (int)((current_time - open_time) / 60);
         
         Print("Managing position #", ticket, ", Type: ", (position_type == POSITION_TYPE_BUY ? "BUY" : "SELL"), ", Age: ", position_age_minutes, " min, Profit: ", DoubleToString(current_profit, 2));
         
         // Check if trend has reversed against the position
         bool trend_reversal = false;
         if(position_type == POSITION_TYPE_BUY)
           {
            // For buy positions, check if trend reversed to downtrend
            if(ema50 < ema200 && ema50 < iMA(_Symbol, PERIOD_M15, 50, 0, MODE_EMA, PRICE_CLOSE, 1))
               trend_reversal = true;
           }
         else
           {
            // For sell positions, check if trend reversed to uptrend
            if(ema50 > ema200 && ema50 > iMA(_Symbol, PERIOD_M15, 50, 0, MODE_EMA, PRICE_CLOSE, 1))
               trend_reversal = true;
           }
         
         // Check if we've hit trailing stop conditions
         bool trailing_stop_hit = false;
         if(position_type == POSITION_TYPE_BUY)
           {
            // For buy positions, check trailing stop
            if(current_sl > 0 && bid - trailing_stop_distance_buy <= current_sl)
               trailing_stop_hit = true;
           }
         else
           {
            // For sell positions, check trailing stop
            if(current_sl > 0 && ask + trailing_stop_distance_sell >= current_sl)
               trailing_stop_hit = true;
           }
         
         // Check if we've reached take profit target
         bool take_profit_hit = false;
         if(position_type == POSITION_TYPE_BUY)
           {
            if(current_tp > 0 && bid >= current_tp)
               take_profit_hit = true;
           }
         else
           {
            if(current_tp > 0 && ask <= current_tp)
               take_profit_hit = true;
           }
         
         // Check if we should exit based on profit target or stop loss
         bool should_close = false;
         string close_reason = "";
         
         // 1. Close if trend reversed
         if(trend_reversal)
           {
            should_close = true;
            close_reason = "Trend reversal detected";
           }
         // 2. Close if trailing stop hit
         else if(trailing_stop_hit)
           {
            should_close = true;
            close_reason = "Trailing stop hit";
           }
         // 3. Close if take profit hit
         else if(take_profit_hit)
           {
            should_close = true;
            close_reason = "Take profit hit";
           }
         // 4. Close if position is losing money and has been open too long
         else if(current_profit < 0 && position_age_minutes > MaxLosingPositionMinutes)
           {
            should_close = true;
            close_reason = "Maximum losing position time exceeded";
           }
         // 5. Close if profit is significant and time-based exit criteria met
         else if(current_profit > 0 && position_age_minutes > MinProfitPositionMinutes)
           {
            // Calculate profit in pips
            double profit_pips = position_type == POSITION_TYPE_BUY ? 
                                (bid - open_price) / point : 
                                (open_price - ask) / point;
            
            // Close if profit reaches certain multiple of ATR
            double atr_profit_threshold = atr_value * ProfitATRMultiple;
            if(profit_pips * point >= atr_profit_threshold)
              {
               should_close = true;
               close_reason = "Profit target reached (" + (string)MathRound(profit_pips) + " pips)";
              }
           }
         
         // Close the position if any closing condition is met
         if(should_close)
           {
            Print("Closing position #", ticket, ", Reason: ", close_reason, ", Profit: ", DoubleToString(current_profit, 2));
            
            // Close the position
            CTrade trade;
            trade.SetTypeFillingBySymbol(_Symbol);
            trade.SetDeviation(5);
            
            if(position_type == POSITION_TYPE_BUY)
              {
               if(trade.PositionClose(ticket))
                 {
                  Print("Successfully closed BUY position #", ticket);
                  // Reset trailing stop distance
                  trailing_stop_distance_buy = 0;
                  
                  // Update daily risk tracking with trade result
                  UpdateDailyRiskOnTradeClose(current_profit);
                  
                  // Track trade result to update strategy performance
                  TrackTradeResult(position_type, current_profit, open_price);
                 }
               else
                  Print("Failed to close BUY position #", ticket, ", Error: ", trade.ResultRetcode(), " - ", trade.ResultRetcodeDescription());
              }
            else
              {
               if(trade.PositionClose(ticket))
                 {
                  Print("Successfully closed SELL position #", ticket);
                  // Reset trailing stop distance
                  trailing_stop_distance_sell = 0;
                  
                  // Update daily risk tracking with trade result
                  UpdateDailyRiskOnTradeClose(current_profit);
                  
                  // Track trade result to update strategy performance
                  TrackTradeResult(position_type, current_profit, open_price);
                 }
               else
                  Print("Failed to close SELL position #", ticket, ", Error: ", trade.ResultRetcode(), " - ", trade.ResultRetcodeDescription());
              }
           }
         // Update trailing stop if position is profitable
         else if(current_profit > 0)
           {
            // We'll use the ApplyTrailingStop function for this
            // No need to update it here separately
           }
        }
     }
  }

//+------------------------------------------------------------------+
//| Apply trailing stop to open positions                            |
//+------------------------------------------------------------------+
// Advanced trailing stop function with profit threshold, trend strength adjustment,
// intelligent volatility adaptation, partial take profit based on price targets, 
// and enhanced risk management
void ApplyTrailingStop()
  {
   // Get market data
   double atr_value = GetATR(0);
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   
   // Calculate trend strength for adaptive trailing
   double trend_strength = CalculateTrendStrength();
   
   // Get ATR moving average for volatility context
   double atr_ma = CalculateATR_MovingAverage(20);
   double atr_ratio = atr_value / atr_ma;
   
   // Define minimum profit threshold (in points) before trailing stop activates
   double min_profit_threshold = MathMax(atr_value * 0.5, TrailingStopPips * 0.75 * point);
   
   // Check all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      if(PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_MAGIC) == 20231114)
        {
         int position_type = (int)PositionGetInteger(POSITION_TYPE);
         double stop_loss = PositionGetDouble(POSITION_SL);
         ulong position_ticket = PositionGetInteger(POSITION_TICKET);
         double open_price = PositionGetDouble(POSITION_PRICE_OPEN);
         double current_profit = PositionGetDouble(POSITION_PROFIT);
         double position_volume = PositionGetDouble(POSITION_VOLUME);
         datetime open_time = PositionGetInteger(POSITION_TIME);
         
         // Calculate position age in hours
         double position_age_hours = (TimeCurrent() - open_time) / (double)PERIOD_H1;
         
         // Check if position has already been partially closed
         bool has_partial_closed_25 = false;
         bool has_partial_closed_50 = false;
         bool has_partial_closed_75 = false;
         
         // Get position comment to track partial closes
         string position_comment = PositionGetString(POSITION_COMMENT);
         if(StringFind(position_comment, "PARTIAL_25") >= 0) has_partial_closed_25 = true;
         if(StringFind(position_comment, "PARTIAL_50") >= 0) has_partial_closed_50 = true;
         if(StringFind(position_comment, "PARTIAL_75") >= 0) has_partial_closed_75 = true;
         
         // Calculate current position profit in points
         double profit_points;
         if(position_type == POSITION_TYPE_BUY)
             profit_points = (bid - open_price) / point;
         else
             profit_points = (open_price - ask) / point;
         
         // Only apply trailing stop if position has minimum profit
         if(profit_points * point < min_profit_threshold)
             continue; // Skip positions without enough profit
         
         // Check for partial take profit opportunities using multi-target strategy
         if(UsePartialTakeProfit)
         {
             // For BUY positions
             if(position_type == POSITION_TYPE_BUY)
             {
                 // 40% partial close at first profit target
                 if(bid >= global_tp1_price && !has_partial_closed_25)
                 {
                     double partial_volume = position_volume * 0.4; // 40% of position
                     if(trade.PositionClosePartial(position_ticket, partial_volume))
                     {
                         // Update position comment
                         string new_comment = position_comment + (position_comment == "" ? "" : ",") + "PARTIAL_40_CLOSED";
                         trade.PositionComment(position_ticket, new_comment);
                         if(DebugMode) Print("Partial 40% close executed for BUY position #", position_ticket, ", Volume: ", partial_volume, ", at TP1: ", global_tp1_price);
                     }
                     else if(DebugMode) Print("Failed to execute partial 40% close for position #", position_ticket, ", Error: ", GetLastError());
                 }
                 // 30% partial close at second profit target
                 else if(bid >= global_tp2_price && !has_partial_closed_50)
                 {
                     double partial_volume = position_volume * 0.3; // 30% of original position
                     if(trade.PositionClosePartial(position_ticket, partial_volume))
                     {
                         // Update position comment
                         string new_comment = position_comment + (position_comment == "" ? "" : ",") + "PARTIAL_70_CLOSED";
                         trade.PositionComment(position_ticket, new_comment);
                         if(DebugMode) Print("Partial 30% close executed for BUY position #", position_ticket, ", Volume: ", partial_volume, ", at TP2: ", global_tp2_price);
                     }
                     else if(DebugMode) Print("Failed to execute partial 30% close for position #", position_ticket, ", Error: ", GetLastError());
                 }
                 // 30% partial close at third profit target
                 else if(bid >= global_tp3_price && !has_partial_closed_75)
                 {
                     double partial_volume = position_volume * 0.3; // 30% of original position
                     if(trade.PositionClosePartial(position_ticket, partial_volume))
                     {
                         // Update position comment
                         string new_comment = position_comment + (position_comment == "" ? "" : ",") + "PARTIAL_100_CLOSED";
                         trade.PositionComment(position_ticket, new_comment);
                         if(DebugMode) Print("Partial 30% close executed for BUY position #", position_ticket, ", Volume: ", partial_volume, ", at TP3: ", global_tp3_price);
                     }
                     else if(DebugMode) Print("Failed to execute partial 30% close for position #", position_ticket, ", Error: ", GetLastError());
                 }
             }
             // For SELL positions
             else if(position_type == POSITION_TYPE_SELL)
             {
                 // 40% partial close at first profit target
                 if(ask <= global_tp1_price && !has_partial_closed_25)
                 {
                     double partial_volume = position_volume * 0.4; // 40% of position
                     if(trade.PositionClosePartial(position_ticket, partial_volume))
                     {
                         // Update position comment
                         string new_comment = position_comment + (position_comment == "" ? "" : ",") + "PARTIAL_40_CLOSED";
                         trade.PositionComment(position_ticket, new_comment);
                         if(DebugMode) Print("Partial 40% close executed for SELL position #", position_ticket, ", Volume: ", partial_volume, ", at TP1: ", global_tp1_price);
                     }
                     else if(DebugMode) Print("Failed to execute partial 40% close for position #", position_ticket, ", Error: ", GetLastError());
                 }
                 // 30% partial close at second profit target
                 else if(ask <= global_tp2_price && !has_partial_closed_50)
                 {
                     double partial_volume = position_volume * 0.3; // 30% of original position
                     if(trade.PositionClosePartial(position_ticket, partial_volume))
                     {
                         // Update position comment
                         string new_comment = position_comment + (position_comment == "" ? "" : ",") + "PARTIAL_70_CLOSED";
                         trade.PositionComment(position_ticket, new_comment);
                         if(DebugMode) Print("Partial 30% close executed for SELL position #", position_ticket, ", Volume: ", partial_volume, ", at TP2: ", global_tp2_price);
                     }
                     else if(DebugMode) Print("Failed to execute partial 30% close for position #", position_ticket, ", Error: ", GetLastError());
                 }
                 // 30% partial close at third profit target
                 else if(ask <= global_tp3_price && !has_partial_closed_75)
                 {
                     double partial_volume = position_volume * 0.3; // 30% of original position
                     if(trade.PositionClosePartial(position_ticket, partial_volume))
                     {
                         // Update position comment
                         string new_comment = position_comment + (position_comment == "" ? "" : ",") + "PARTIAL_100_CLOSED";
                         trade.PositionComment(position_ticket, new_comment);
                         if(DebugMode) Print("Partial 30% close executed for SELL position #", position_ticket, ", Volume: ", partial_volume, ", at TP3: ", global_tp3_price);
                     }
                     else if(DebugMode) Print("Failed to execute partial 30% close for position #", position_ticket, ", Error: ", GetLastError());
                 }
             }
         }
         
         // Calculate trailing stop distance with enhanced logic
         double trailing_stop_distance = 0.0;
         
         switch(TrailingStopType)
         {
             case 0: // Fixed pips
                 trailing_stop_distance = TrailingStopPips * point;
                 // Adjust based on trend strength, volatility, and position age
                 trailing_stop_distance *= (0.8 + 0.4 * trend_strength) * MathMin(1.2, 1.0 + position_age_hours / 24.0 * 0.1);
                 break;
                 
             case 1: // ATR based
                 trailing_stop_distance = TrailingATRMultiplier * atr_value;
                 // Adjust based on trend strength and position age
                 trailing_stop_distance *= (0.8 + 0.4 * trend_strength) * MathMin(1.2, 1.0 + position_age_hours / 24.0 * 0.1);
                 break;
                 
             case 2: // Advanced Dynamic
             {
                 // Multi-factor adjustment based on volatility, trend strength, profit level, and position age
                 double volatility_factor = MathMax(0.6, MathMin(1.5, 1.0 + (1.0 - atr_ratio) * 0.5));
                 double trend_factor = 0.8 + 0.4 * trend_strength;
                 double profit_factor = MathMin(1.3, 1.0 + (profit_points * point / (atr_value * 2)) * 0.25);
                 double age_factor = MathMin(1.2, 1.0 + position_age_hours / 24.0 * 0.1);
                 
                 trailing_stop_distance = TrailingATRMultiplier * atr_value * volatility_factor * trend_factor * profit_factor * age_factor;
                 
                 // Additional safety margin during high volatility
                 if(atr_ratio > 1.5)
                     trailing_stop_distance *= 1.1; // Add 10% safety margin
                 
                 break;
             }
             
             default:
                 trailing_stop_distance = TrailingStopPips * point;
                 break;
         }
         
         // For BUY positions
         if(position_type == POSITION_TYPE_BUY)
           {
            // Calculate new trailing level
            double new_trailing_level = bid - trailing_stop_distance;
            
            // Update trailing level if price has moved sufficiently
            if(new_trailing_level > last_trailing_level_buy)
              {
               last_trailing_level_buy = new_trailing_level;
               
               // Only update SL if new trailing level is above current SL and profit is sufficient
               if(new_trailing_level > stop_loss && profit_points * point >= min_profit_threshold)
                 {
                  // Round to appropriate digits
                  new_trailing_level = NormalizeDouble(new_trailing_level, digits);
                  
                  // Ensure new SL is at least min_profit_threshold away from entry
                  double min_sl_level = open_price + min_profit_threshold / 2;
                  
                  // Enforce minimum SL level
                  if(new_trailing_level < min_sl_level)
                      new_trailing_level = min_sl_level;
                  
                  // Risk-based adjustment: tighten SL more aggressively when profit is high
                  double profit_ratio = (profit_points * point) / min_profit_threshold;
                  if(profit_ratio > 3.0 && UseAdaptiveTrailingTightening)
                  {
                      // Tighten trailing stop by 5-15% based on profit ratio
                      double tightening_factor = MathMax(0.85, 1.0 - (profit_ratio - 3.0) * 0.025);
                      new_trailing_level = bid - (trailing_stop_distance * tightening_factor);
                      new_trailing_level = NormalizeDouble(new_trailing_level, digits);
                  }
                  
                  // Modify position
                  if(!trade.PositionModify(position_ticket, new_trailing_level, 0.0))
                    {
                     int error_code = GetLastError();
                     if(DebugMode) Print("Failed to modify trailing stop for BUY position #" + (string)position_ticket + ", Error: " + (string)error_code);
                    }
                  else
                    {
                     if(DebugMode) Print("Trailing stop updated for BUY position #", (string)position_ticket, ": New SL = ", DoubleToString(new_trailing_level, digits));
                    }
                 }
              }
           }
         // For SELL positions
         else if(position_type == POSITION_TYPE_SELL)
           {
            // Calculate new trailing level
            double new_trailing_level = ask + trailing_stop_distance;
            
            // Update trailing level if price has moved sufficiently
            if(new_trailing_level < last_trailing_level_sell)
              {
               last_trailing_level_sell = new_trailing_level;
               
               // Only update SL if new trailing level is below current SL and profit is sufficient
               if(new_trailing_level < stop_loss && profit_points * point >= min_profit_threshold)
                 {
                  // Round to appropriate digits
                  new_trailing_level = NormalizeDouble(new_trailing_level, digits);
                  
                  // Ensure new SL is at least min_profit_threshold away from entry
                  double min_sl_level = open_price - min_profit_threshold / 2;
                  
                  // Enforce minimum SL level
                  if(new_trailing_level > min_sl_level)
                      new_trailing_level = min_sl_level;
                  
                  // Risk-based adjustment: tighten SL more aggressively when profit is high
                  double profit_ratio = (profit_points * point) / min_profit_threshold;
                  if(profit_ratio > 3.0 && UseAdaptiveTrailingTightening)
                  {
                      // Tighten trailing stop by 5-15% based on profit ratio
                      double tightening_factor = MathMax(0.85, 1.0 - (profit_ratio - 3.0) * 0.025);
                      new_trailing_level = ask + (trailing_stop_distance * tightening_factor);
                      new_trailing_level = NormalizeDouble(new_trailing_level, digits);
                  }
                  
                  // Modify position
                  if(!trade.PositionModify(position_ticket, new_trailing_level, 0.0))
                    {
                     int error_code = GetLastError();
                     if(DebugMode) Print("Failed to modify trailing stop for SELL position #" + (string)position_ticket + ", Error: " + (string)error_code);
                    }
                  else
                    {
                     if(DebugMode) Print("Trailing stop updated for SELL position #", (string)position_ticket, ": New SL = ", DoubleToString(new_trailing_level, digits));
                    }
                 }
              }
           }
        }}
     }
  }