//+------------------------------------------------------------------+
//|                      ATR QQE Conservative Trading System.mq5    |
//|              Conservative QQE with Enhanced Risk Management     |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025"
#property link      ""
#property version   "4.00"
#property strict
#property description "Conservative QQE system with enhanced filters and risk management"

#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\OrderInfo.mqh>

// EA input parameters
input group "Risk Management (Conservative Settings)"
input double              Risk_Percent = 1.0;        // Risk % of equity per trade (reduced)
input double              SL_ATR_Multiplier = 4.0;   // Stop Loss ATR Multiplier (increased)
input double              TP_ATR_Multiplier = 8.0;   // Take Profit ATR Multiplier (1:2 ratio)
input double              Trail_Start_Multiplier = 4.0; // Trailing Start ATR Multiplier
input double              Trail_Step_Multiplier = 1.0;  // Trailing Step ATR Multiplier
input double              Extra_Buffer_Pips = 10;    // Extra buffer in pips (increased)
input int                 Max_Consecutive_Losses = 3; // Stop trading after X losses
input int                 Min_Hours_Between_Trades = 4; // Minimum hours between trades

input group "Market Condition Filters"
input bool                Use_Trend_Filter = true;   // Only trade with trend
input int                 Trend_MA_Period = 200;     // Trend MA period
input bool                Use_Volatility_Filter = true; // Use ADX volatility filter
input int                 ADX_Period = 14;           // ADX period
input double              ADX_Threshold = 25;        // Minimum ADX for trading
input bool                Use_Time_Filter = true;    // Trade only during active hours
input int                 Start_Hour = 7;            // Trading start hour (GMT)
input int                 End_Hour = 17;             // Trading end hour (GMT)

input group "Enhanced QQE Parameters"
input int                 QQE_RSI_Period = 14;       // QQE RSI Period
input int                 QQE_Smoothing_Factor = 8;  // QQE Smoothing Factor (increased)
input double              QQE_Signal_Threshold = 5;  // Minimum distance between QQE lines
input bool                Use_QQE_Divergence_Filter = true; // Additional divergence filter

input group "ATR and Trading Parameters"
input int                 ATR_Period = 14;           // ATR Period
input int                 ATR_Shift = 1;             // ATR shift
input bool                Manage_SL = true;          // Manage Stop Loss
input bool                Manage_TP = true;          // Manage Take Profit
input bool                Use_Trailing_Stop = true;  // Use Trailing Stop
input bool                Allow_Long_Positions = true; // Allow Long Positions
input bool                Allow_Short_Positions = true; // Allow Short Positions
input int                 Max_Positions = 1;         // Maximum concurrent positions

input group "Timing Parameters"
input bool                Process_On_Bar_Close = true; // Process only on bar close

// Global variables
CTrade         trade;
CPositionInfo  posInfo;
COrderInfo     orderInfo;
double         atrValue;
double         point;
int            digits;
datetime       lastTradeTime = 0;
datetime       lastBarTime = 0;
int            atrHandle;
int            rsiHandle;
int            trendMAHandle;
int            adxHandle;
int            positionCount = 0;
ulong          positionTickets[];
int            consecutiveLosses = 0;
bool           tradingHalted = false;

// QQE calculation variables
int            Wilders_Period;
int            StartBar;

// QQE buffers
double         TrLevelSlow[];    // QQE Smoothed line
double         AtrRsi[];         // ATR of RSI
double         MaAtrRsi[];       // MA of ATR RSI
double         Rsi[];            // Raw RSI values
double         RsiMa[];          // QQE Main line (MA of RSI)
double         MaMaAtrRsi[];     // MA of MA of ATR RSI

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   trade.SetExpertMagicNumber(123456);
   
   digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   
   // Initialize QQE calculation parameters
   Wilders_Period = QQE_RSI_Period * 2 - 1;
   StartBar = MathMax(QQE_Smoothing_Factor, Wilders_Period);
   
   // Create indicator handles
   atrHandle = iATR(_Symbol, PERIOD_CURRENT, ATR_Period);
   rsiHandle = iRSI(_Symbol, PERIOD_CURRENT, QQE_RSI_Period, PRICE_CLOSE);
   trendMAHandle = iMA(_Symbol, PERIOD_CURRENT, Trend_MA_Period, 0, MODE_SMA, PRICE_CLOSE);
   adxHandle = iADX(_Symbol, PERIOD_CURRENT, ADX_Period);
   
   if(atrHandle == INVALID_HANDLE || rsiHandle == INVALID_HANDLE || 
      trendMAHandle == INVALID_HANDLE || adxHandle == INVALID_HANDLE)
   {
      Print("Error creating indicator handles");
      return(INIT_FAILED);
   }
   
   // Initialize QQE arrays
   ArraySetAsSeries(TrLevelSlow, true);
   ArraySetAsSeries(AtrRsi, true);
   ArraySetAsSeries(MaAtrRsi, true);
   ArraySetAsSeries(Rsi, true);
   ArraySetAsSeries(RsiMa, true);
   ArraySetAsSeries(MaMaAtrRsi, true);
   
   RefreshPositions();
   
   Print("Conservative ATR QQE Trading System initialized");
   Print("Risk per trade: ", Risk_Percent, "%");
   Print("Risk/Reward ratio: 1:", (TP_ATR_Multiplier/SL_ATR_Multiplier));
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   IndicatorRelease(atrHandle);
   IndicatorRelease(rsiHandle);
   IndicatorRelease(trendMAHandle);
   IndicatorRelease(adxHandle);
   Comment("");
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   if(Process_On_Bar_Close)
   {
      datetime currentBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);
      if(currentBarTime != lastBarTime)
      {
         lastBarTime = currentBarTime;
         UpdateIndicators();
         ManagePositions();
         CheckForEntrySignals();
      }
   }
}

//+------------------------------------------------------------------+
//| Check if trading is allowed based on filters                    |
//+------------------------------------------------------------------+
bool IsTradingAllowed()
{
   // Check if trading is halted due to consecutive losses
   if(tradingHalted)
   {
      Print("Trading halted due to ", Max_Consecutive_Losses, " consecutive losses");
      return false;
   }
   
   // Check minimum time between trades
   if(TimeCurrent() - lastTradeTime < Min_Hours_Between_Trades * 3600)
   {
      return false;
   }
   
   // Check trading hours
   if(Use_Time_Filter)
   {
      MqlDateTime dt;
      TimeToStruct(TimeCurrent(), dt);
      if(dt.hour < Start_Hour || dt.hour >= End_Hour)
         return false;
   }
   
   // Check volatility filter (ADX)
   if(Use_Volatility_Filter)
   {
      double adxBuffer[];
      if(CopyBuffer(adxHandle, 0, 1, 1, adxBuffer) <= 0)
         return false;
         
      if(adxBuffer[0] < ADX_Threshold)
      {
         Print("ADX too low for trading: ", adxBuffer[0]);
         return false;
      }
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Check trend direction                                            |
//+------------------------------------------------------------------+
int GetTrendDirection()
{
   if(!Use_Trend_Filter)
      return 0; // No filter
      
   double maBuffer[], closeBuffer[];
   if(CopyBuffer(trendMAHandle, 0, 1, 1, maBuffer) <= 0)
      return 0;
   if(CopyClose(_Symbol, PERIOD_CURRENT, 1, 1, closeBuffer) <= 0)
      return 0;
      
   if(closeBuffer[0] > maBuffer[0])
      return 1;  // Uptrend
   else if(closeBuffer[0] < maBuffer[0])
      return -1; // Downtrend
   else
      return 0;  // Neutral
}

//+------------------------------------------------------------------+
//| Calculate lot size based on equity risk                         |
//+------------------------------------------------------------------+
double CalculateLotSize(double entryPrice, double stopLoss)
{
   double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   double riskAmount = accountBalance * Risk_Percent / 100.0;
   
   double stopDistance = MathAbs(entryPrice - stopLoss);
   if(stopDistance == 0) return 0;
   
   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   
   if(tickValue == 0 || tickSize == 0) return 0;
   
   double lotSize = riskAmount / (stopDistance / tickSize * tickValue);
   
   // Apply lot size limits
   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   
   lotSize = MathMax(lotSize, minLot);
   lotSize = MathMin(lotSize, maxLot);
   
   // Round to lot step
   lotSize = MathFloor(lotSize / lotStep) * lotStep;
   
   return lotSize;
}

//+------------------------------------------------------------------+
//| Exponential Moving Average                                       |
//+------------------------------------------------------------------+
void CalculateEMA(int begin, int period, const double &price[], double &result[])
{
   if(period <= 0) return;
   if(begin < 0) begin = 0;
   
   int priceSize = ArraySize(price);
   int resultSize = ArraySize(result);
   
   if(priceSize == 0 || resultSize == 0) return;
   if(begin >= priceSize || begin >= resultSize) return;
   
   double SmoothFactor = 2.0 / (1.0 + period);

   for(int i = begin; i >= 0; i--)
   {
      if(i >= priceSize || i >= resultSize) continue;
      if(i + 1 >= resultSize) 
      {
         if(price[i] == EMPTY_VALUE) 
            result[i] = 0;
         else 
            result[i] = price[i];
         continue;
      }
      
      if(price[i] == EMPTY_VALUE) 
         result[i] = 0;
      else 
         result[i] = price[i] * SmoothFactor + result[i + 1] * (1.0 - SmoothFactor);
   }
}

//+------------------------------------------------------------------+
//| Calculate proper QQE values                                     |
//+------------------------------------------------------------------+
bool CalculateQQE(int bars_needed)
{
   int total_bars = bars_needed + StartBar + 10;
   
   int available_bars = iBars(_Symbol, PERIOD_CURRENT);
   if(available_bars < total_bars)
   {
      total_bars = available_bars - 1;
      if(total_bars < StartBar + 10)
      {
         return false;
      }
   }
   
   if(total_bars < 50)
      return false;
   
   if(!ArrayResize(Rsi, total_bars) || 
      !ArrayResize(RsiMa, total_bars) ||
      !ArrayResize(AtrRsi, total_bars) ||
      !ArrayResize(MaAtrRsi, total_bars) ||
      !ArrayResize(MaMaAtrRsi, total_bars) ||
      !ArrayResize(TrLevelSlow, total_bars))
   {
      return false;
   }
   
   if(CopyBuffer(rsiHandle, 0, 0, total_bars, Rsi) != total_bars)
      return false;
   
   ArrayInitialize(RsiMa, 0.0);
   ArrayInitialize(AtrRsi, 0.0);
   ArrayInitialize(MaAtrRsi, 0.0);
   ArrayInitialize(MaMaAtrRsi, 0.0);
   ArrayInitialize(TrLevelSlow, 0.0);
   
   if(total_bars > QQE_Smoothing_Factor)
      CalculateEMA(total_bars - 1, QQE_Smoothing_Factor, Rsi, RsiMa);
   
   for(int i = total_bars - 2; i >= 0; i--)
   {
      if(i + 1 < total_bars && i >= 0)
         AtrRsi[i] = MathAbs(RsiMa[i + 1] - RsiMa[i]);
   }
   
   if(total_bars > Wilders_Period)
   {
      CalculateEMA(total_bars - 2, Wilders_Period, AtrRsi, MaAtrRsi);
      CalculateEMA(total_bars - 2, Wilders_Period, MaAtrRsi, MaMaAtrRsi);
   }
   
   int start_index = total_bars - StartBar - 1;
   if(start_index < 0) start_index = total_bars - 1;
   
   double tr = 0;
   double rsi1 = 0;
   
   if(start_index >= 0 && start_index < total_bars)
   {
      tr = TrLevelSlow[start_index];
      rsi1 = RsiMa[start_index];
   }
   
   for(int i = start_index - 1; i >= 0; i--)
   {
      if(i < 0 || i >= total_bars) continue;
      
      double rsi0 = RsiMa[i];
      double dar = MaMaAtrRsi[i] * 4.236;
      double dv = tr;

      if(rsi0 < tr)
      {
         tr = rsi0 + dar;
         if((rsi1 < dv) && (tr > dv)) tr = dv;
      }
      else if(rsi0 > tr)
      {
         tr = rsi0 - dar;
         if((rsi1 > dv) && (tr < dv)) tr = dv;
      }

      TrLevelSlow[i] = tr;
      rsi1 = rsi0;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Update indicators                                                |
//+------------------------------------------------------------------+
void UpdateIndicators()
{
   double atrBuffer[];
   
   if(CopyBuffer(atrHandle, 0, ATR_Shift, 1, atrBuffer) > 0)
   {
      atrValue = NormalizeDouble(atrBuffer[0], digits);
      if(atrValue <= 0)
         atrValue = 0.0001;
   }
   else
   {
      Print("Error getting ATR value: ", GetLastError());
   }
   
   if(iBars(_Symbol, PERIOD_CURRENT) > StartBar + 50)
   {
      CalculateQQE(50);
   }
}

//+------------------------------------------------------------------+
//| Check for QQE entry signals with enhanced filters               |
//+------------------------------------------------------------------+
void CheckForEntrySignals()
{
   if(positionCount >= Max_Positions || !IsTradingAllowed())
      return;
   
   if(ArraySize(RsiMa) < 3 || ArraySize(TrLevelSlow) < 3 || atrValue <= 0)
      return;
   
   // Additional validation
   if(RsiMa[1] == 0 || TrLevelSlow[1] == 0 || RsiMa[2] == 0 || TrLevelSlow[2] == 0)
      return;
   
   double currentRsiMa = RsiMa[1];
   double prevRsiMa = RsiMa[2];
   double currentSmoothed = TrLevelSlow[1];
   double prevSmoothed = TrLevelSlow[2];
   
   // Check QQE signal strength
   double signalStrength = MathAbs(currentRsiMa - currentSmoothed);
   if(signalStrength < QQE_Signal_Threshold)
   {
      Print("QQE signal too weak: ", signalStrength);
      return;
   }
   
   // Get trend direction
   int trendDirection = GetTrendDirection();
   
   bool buySignal = false;
   bool sellSignal = false;
   
   // Enhanced QQE signal detection
   if(prevRsiMa <= prevSmoothed && currentRsiMa > currentSmoothed)
   {
      // Additional divergence filter
      if(Use_QQE_Divergence_Filter)
      {
         if(currentRsiMa < 30) // Coming from oversold
            buySignal = true;
      }
      else
      {
         buySignal = true;
      }
   }
   
   if(prevRsiMa >= prevSmoothed && currentRsiMa < currentSmoothed)
   {
      if(Use_QQE_Divergence_Filter)
      {
         if(currentRsiMa > 70) // Coming from overbought
            sellSignal = true;
      }
      else
      {
         sellSignal = true;
      }
   }
   
   // Apply trend filter
   if(Use_Trend_Filter)
   {
      if(buySignal && trendDirection != 1)
      {
         Print("Buy signal filtered out - not in uptrend");
         buySignal = false;
      }
      if(sellSignal && trendDirection != -1)
      {
         Print("Sell signal filtered out - not in downtrend");
         sellSignal = false;
      }
   }
   
   double currentPrice;
   double stopLoss, takeProfit;
   double bufferInPoints = Extra_Buffer_Pips * 10 * point;
   
   // Execute Buy Signal
   if(buySignal && Allow_Long_Positions)
   {
      currentPrice = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      
      stopLoss = NormalizeDouble(currentPrice - (atrValue * SL_ATR_Multiplier) - bufferInPoints, digits);
      takeProfit = NormalizeDouble(currentPrice + (atrValue * TP_ATR_Multiplier), digits);
      
      double lotSize = CalculateLotSize(currentPrice, stopLoss);
      
      if(lotSize > 0 && !trade.Buy(lotSize, _Symbol, 0, stopLoss, takeProfit, "Conservative QQE Buy"))
      {
         Print("Buy order failed with error: ", GetLastError());
      }
      else if(lotSize > 0)
      {
         Print("Conservative QQE Buy executed - Lot: ", lotSize, " Entry: ", currentPrice);
         Print("SL: ", stopLoss, " TP: ", takeProfit, " Risk: ", Risk_Percent, "%");
         lastTradeTime = TimeCurrent();
      }
   }
   
   // Execute Sell Signal
   if(sellSignal && Allow_Short_Positions)
   {
      currentPrice = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      
      stopLoss = NormalizeDouble(currentPrice + (atrValue * SL_ATR_Multiplier) + bufferInPoints, digits);
      takeProfit = NormalizeDouble(currentPrice - (atrValue * TP_ATR_Multiplier), digits);
      
      double lotSize = CalculateLotSize(currentPrice, stopLoss);
      
      if(lotSize > 0 && !trade.Sell(lotSize, _Symbol, 0, stopLoss, takeProfit, "Conservative QQE Sell"))
      {
         Print("Sell order failed with error: ", GetLastError());
      }
      else if(lotSize > 0)
      {
         Print("Conservative QQE Sell executed - Lot: ", lotSize, " Entry: ", currentPrice);
         Print("SL: ", stopLoss, " TP: ", takeProfit, " Risk: ", Risk_Percent, "%");
         lastTradeTime = TimeCurrent();
      }
   }
}

//+------------------------------------------------------------------+
//| Track trade results and consecutive losses                       |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction& trans,
                       const MqlTradeRequest& request,
                       const MqlTradeResult& result)
{
   if(trans.type == TRADE_TRANSACTION_DEAL_ADD)
   {
      CDealInfo deal;
      if(deal.SelectByIndex(trans.deal))
      {
         if(deal.Magic() == 123456 && deal.Entry() == DEAL_ENTRY_OUT)
         {
            double profit = deal.Profit();
            if(profit < 0)
            {
               consecutiveLosses++;
               Print("Consecutive losses: ", consecutiveLosses);
               
               if(consecutiveLosses >= Max_Consecutive_Losses)
               {
                  tradingHalted = true;
                  Print("Trading halted after ", Max_Consecutive_Losses, " consecutive losses");
               }
            }
            else
            {
               consecutiveLosses = 0; // Reset counter on winning trade
               tradingHalted = false; // Resume trading
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Refresh list of position tickets                                 |
//+------------------------------------------------------------------+
void RefreshPositions()
{
   int total = PositionsTotal();
   int count = 0;
   
   for(int i = 0; i < total; i++)
   {
      if(posInfo.SelectByIndex(i))
      {
         if(posInfo.Symbol() == _Symbol && posInfo.Magic() == 123456)
            count++;
      }
   }
   
   ArrayResize(positionTickets, count);
   positionCount = 0;
   
   for(int i = 0; i < total; i++)
   {
      if(posInfo.SelectByIndex(i))
      {
         if(posInfo.Symbol() == _Symbol && posInfo.Magic() == 123456)
         {
            positionTickets[positionCount] = posInfo.Ticket();
            positionCount++;
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Manage all positions                                             |
//+------------------------------------------------------------------+
void ManagePositions()
{
   RefreshPositions();
   
   double bufferInPoints = Extra_Buffer_Pips * 10 * point;
   
   // Display current info
   string info = "Conservative QQE ATR System\n";
   info += "Risk per trade: " + DoubleToString(Risk_Percent, 1) + "%\n";
   info += "Risk/Reward: 1:" + DoubleToString(TP_ATR_Multiplier/SL_ATR_Multiplier, 1) + "\n";
   info += "Current ATR: " + DoubleToString(atrValue, digits) + "\n";
   if(ArraySize(RsiMa) > 1 && ArraySize(TrLevelSlow) > 1)
   {
      info += "RSI MA: " + DoubleToString(RsiMa[1], 2) + "\n";
      info += "QQE Smoothed: " + DoubleToString(TrLevelSlow[1], 2) + "\n";
   }
   info += "Consecutive Losses: " + IntegerToString(consecutiveLosses) + "/" + IntegerToString(Max_Consecutive_Losses) + "\n";
   info += "Positions: " + IntegerToString(positionCount);
   Comment(info);
   
   // Process existing positions with trailing stops
   for(int i = 0; i < positionCount; i++)
   {
      if(posInfo.SelectByTicket(positionTickets[i]))
      {
         ProcessPosition(posInfo.PositionType(), posInfo.PriceOpen(), 
                    posInfo.StopLoss(), posInfo.TakeProfit(), 
                    posInfo.Ticket(), bufferInPoints);
      }
   }
}

//+------------------------------------------------------------------+
//| Process a single position with trailing stops                   |
//+------------------------------------------------------------------+
void ProcessPosition(ENUM_POSITION_TYPE posType, double openPrice, 
                   double currentSL, double currentTP, ulong ticket, 
                   double bufferInPoints)
{
   if(!Use_Trailing_Stop || !Manage_SL)
      return;
      
   double newSL = currentSL;
   double trailingStartLevel = 0;
   double currentPrice = 0;
   bool modifyPosition = false;
   
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   
   if(posType == POSITION_TYPE_BUY)
   {
      currentPrice = bid;
      trailingStartLevel = NormalizeDouble(openPrice + (atrValue * Trail_Start_Multiplier), digits);
      
      if(currentPrice >= trailingStartLevel)
      {
         double trailingSL = NormalizeDouble(currentPrice - (atrValue * Trail_Step_Multiplier) - bufferInPoints, digits);
         
         if(trailingSL > currentSL || currentSL == 0)
         {
            newSL = trailingSL;
            modifyPosition = true;
         }
      }
   }
   else if(posType == POSITION_TYPE_SELL)
   {
      currentPrice = ask;
      trailingStartLevel = NormalizeDouble(openPrice - (atrValue * Trail_Start_Multiplier), digits);
      
      if(currentPrice <= trailingStartLevel)
      {
         double trailingSL = NormalizeDouble(currentPrice + (atrValue * Trail_Step_Multiplier) + bufferInPoints, digits);
         
         if(trailingSL < currentSL || currentSL == 0)
         {
            newSL = trailingSL;
            modifyPosition = true;
         }
      }
   }
   
   if(modifyPosition)
   {
      if(trade.PositionModify(ticket, newSL, currentTP))
      {
         Print("Trailing stop updated for position #", ticket, " New SL: ", newSL);
      }
   }
}