//+------------------------------------------------------------------+
//|                                  ATR Dynamic Risk Manager.mq5 |
//|                    Optimized Forex ATR Risk Management System |
// The MQL5 language is used for programming trading strategies and indicators for the MetaTrader 5platform. The script you mentioned, 
//"ATR Dynamic Risk Manager.mq5," seems to be a custom Expert Advisor (EA) or script designed to manage trading risk dynamically using the Average True Range (ATR) indicator. 
//Below is a general outline of how you might implement such a script:
// 

//+------------------------------------------------------------------+
//|                                             ATR Dynamic Risk Manager.mq5 |
//|                        Your Name or Company Name Here                        |
//|                                       Your Website or Contact Info                   |
//+------------------------------------------------------------------+
#property strict

// Input parameters
input double RiskPercentage = 1.0;  // Risk percentage per trade
input int ATRPeriod = 14;           // ATR calculation period
input double ATRMultiplier = 1.5;   // Multiplier for ATR to set stop loss

// Global variables
double atrValue;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   // Initialization of the ATR indicator
   atrValue = iATR(_Symbol, _Period, ATRPeriod);
   
   if(atrValue <= 0)
     {
      Print("Error initializing ATR indicator");
      return INIT_FAILED;
     }
   
   Print("ATR Dynamic Risk Manager initialized successfully");
   return INIT_SUCCEEDED;
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   // Cleanup code if necessary
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   // Update ATR value on each tick
   atrValue = iATR(_Symbol, _Period, ATRPeriod);
   
   // Calculate the lot size based on risk percentage and ATR
   double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   double riskAmount = accountBalance * (RiskPercentage / 100.0);
   double stopLoss = atrValue * ATRMultiplier;
   
   // Assuming a 1:1 risk-reward ratio for simplicity
   double lotSize = CalculateLotSize(riskAmount, stopLoss);
   
   // Example: Place a buy order with calculated lot size
   if(/* Your buy condition here */)
     {
      // Check for existing positions or orders if necessary
      // PlaceOrder function is a placeholder for your order logic
      PlaceOrder(ORDER_TYPE_BUY, lotSize, stopLoss);
     }
  }
//+------------------------------------------------------------------+
//| Function to calculate lot size based on risk and stop loss       |
//+------------------------------------------------------------------+
double CalculateLotSize(double riskAmount, double stopLoss)
  {
   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   
   if(tickValue <= 0 || tickSize <= 0)
     {
      Print("Error retrieving symbol information");
      return 0;
     }
   
   double lotSize = riskAmount / (stopLoss / tickSize * tickValue);
   return NormalizeDouble(lotSize, 2);  // Adjust precision as needed
  }
//+------------------------------------------------------------------+
//| Function to place an order                                       |
//+------------------------------------------------------------------+
void PlaceOrder(int orderType, double lotSize, double stopLoss)
  {
   // Implement order placement logic here
   // Example: OrderSend function with necessary parameters
   // Ensure to handle errors and order confirmation
  }
//+------------------------------------------------------------------+

// 
// ### Key Components:
// 1. **ATR Calculation**: The script uses the ATR indicator to determine market volatility. The ATR value is updated on each tick.
// 
// 2. **Risk Management**: The script calculates the lot size based on a specified risk percentage of the account balance and the ATR value, which is used to set the stop loss.
// 
// 3. **Order Placement**: The script includes a placeholder for order placement logic. You need to implement the actual conditions for opening trades and manage existing positions.
// 
// 4. **Error Handling**: Ensure to handle any errors, especially during order placement and ATR calculation.
// 
// ### Notes:
// - This script is a template and requires further development to be functional. You need to define the specific trading conditions and complete the order placement logic.
// - Always test your scripts on a demo account before deploying them on a live account to ensure they work as expected.
// - Consider adding more features such as take profit levels, trailing stops, and additional risk management rules.
// 

//+------------------------------------------------------------------+
#property copyright "Copyright 2025"
#property link      ""
#property version   "1.00"
#property strict
#property description "Dynamic ATR-based risk management EA for forex"

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

// EA input parameters
input group "ATR Risk Parameters"
input int                 ATR_Period = 14;           // ATR Period
input double              SL_ATR_Multiplier = 3.0;   // Stop Loss ATR Multiplier
input double              TP_ATR_Multiplier = 3.5;   // Take Profit ATR Multiplier
input double              Trail_Start_Multiplier = 2.5; // Trailing Start ATR Multiplier
input double              Trail_Step_Multiplier = 0.5;  // Trailing Step ATR Multiplier
input int                 ATR_Shift = 1;             // ATR shift (1 for previous bar)
input double              Extra_Buffer_Pips = 5;     // Extra buffer in pips

input group "Trading Parameters"
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                Manage_New_Positions = true; // Apply to new positions
input bool                Manage_Existing_Positions = true; // Apply to existing positions
input int                 Magic_Number = 123456;     // EA Magic Number (0 for all positions)
input bool                Close_At_Profit_Target = false; // Close position at profit target instead of setting TP

input group "Timing Parameters"
input int                 Check_Interval_Seconds = 5; // Interval between checks (seconds)
input bool                Process_On_Bar_Close = false; // Process only on bar close

// Global variables
CTrade         trade;
CPositionInfo  posInfo;
COrderInfo     orderInfo;
double         atrValue;
double         point;
int            digits;
datetime       lastCheckTime = 0;
datetime       lastBarTime = 0;
int            atrHandle;
int            positionCount = 0;
ulong          positionTickets[];

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   // Initialize trade operations
   trade.SetExpertMagicNumber(Magic_Number);
   
   // Initialize market information
   digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   
   // Create ATR indicator handle
   atrHandle = iATR(_Symbol, PERIOD_CURRENT, ATR_Period);
   if(atrHandle == INVALID_HANDLE)
   {
      Print("Error creating ATR indicator handle");
      return(INIT_FAILED);
   }
   
   // Set timer
   if(!EventSetTimer(Check_Interval_Seconds))
   {
      Print("Error setting timer");
      return(INIT_FAILED);
   }
   
   // Initial identification of positions
   RefreshPositions();
   
   Print("ATR Dynamic Risk Manager EA initialized successfully");
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   // Release indicator handles
   IndicatorRelease(atrHandle);
   
   // Remove timer
   EventKillTimer();
   
   // Clean up
   Comment("");
}

//+------------------------------------------------------------------+
//| Timer function                                                  |
//+------------------------------------------------------------------+
void OnTimer()
{
   // Check if it's time to update
   if(!IsTimeToCheck())
      return;
      
   // Update ATR value and manage positions
   UpdateATRValue();
   ManagePositions();
   
   // Record the check time
   lastCheckTime = TimeCurrent();
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   // Check if we process only on bar close
   if(Process_On_Bar_Close)
   {
      datetime currentBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);
      if(currentBarTime != lastBarTime)
      {
         lastBarTime = currentBarTime;
         UpdateATRValue();
         ManagePositions();
      }
      return;
   }
   
   // Otherwise, check if it's time to update based on timer
   if(IsTimeToCheck())
   {
      UpdateATRValue();
      ManagePositions();
      lastCheckTime = TimeCurrent();
   }
}

//+------------------------------------------------------------------+
//| Check if it's time to process                                    |
//+------------------------------------------------------------------+
bool IsTimeToCheck()
{
   if(TimeCurrent() - lastCheckTime >= Check_Interval_Seconds)
      return true;
   return false;
}

//+------------------------------------------------------------------+
//| Update ATR value                                                 |
//+------------------------------------------------------------------+
void UpdateATRValue()
{
   double atrBuffer[];
   
   // Get current ATR value
   if(CopyBuffer(atrHandle, 0, ATR_Shift, 1, atrBuffer) > 0)
   {
      atrValue = NormalizeDouble(atrBuffer[0], digits);
      
      if(atrValue <= 0)
      {
         Print("Warning: ATR calculation returned zero or negative value. Using fallback value.");
         atrValue = 0.0001; // Fallback to prevent errors
      }
   }
   else
   {
      Print("Error getting ATR value: ", GetLastError());
   }
}

//+------------------------------------------------------------------+
//| Refresh list of position tickets                                 |
//+------------------------------------------------------------------+
void RefreshPositions()
{
   int total = PositionsTotal();
   int count = 0;
   
   // First, count valid positions
   for(int i = 0; i < total; i++)
   {
      if(posInfo.SelectByIndex(i))
      {
         if(Magic_Number == 0 || posInfo.Magic() == Magic_Number)
         {
            if(posInfo.Symbol() == _Symbol)
               count++;
         }
      }
   }
   
   // Resize array and fill with position tickets
   ArrayResize(positionTickets, count);
   positionCount = 0;
   
   for(int i = 0; i < total; i++)
   {
      if(posInfo.SelectByIndex(i))
      {
         if(Magic_Number == 0 || posInfo.Magic() == Magic_Number)
         {
            if(posInfo.Symbol() == _Symbol)
            {
               positionTickets[positionCount] = posInfo.Ticket();
               positionCount++;
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Manage all positions                                             |
//+------------------------------------------------------------------+
void ManagePositions()
{
   // Get current open positions
   RefreshPositions();
   
   // Convert buffer from pips to points
   double bufferInPoints = Extra_Buffer_Pips * 10 * point;
   
   // Display current ATR info
   string info = "Current ATR: " + DoubleToString(atrValue, digits) + "\n";
   info += "SL distance: " + DoubleToString(atrValue * SL_ATR_Multiplier + bufferInPoints, digits) + "\n";
   info += "TP distance: " + DoubleToString(atrValue * TP_ATR_Multiplier, digits) + "\n";
   info += "Positions managed: " + IntegerToString(positionCount);
   Comment(info);
   
   // Process existing positions
   if(Manage_Existing_Positions)
   {
      for(int i = 0; i < positionCount; i++)
      {
         if(posInfo.SelectByTicket(positionTickets[i]))
         {
            // Process the position
            ProcessPosition(posInfo.PositionType(), posInfo.PriceOpen(), 
                       posInfo.StopLoss(), posInfo.TakeProfit(), 
                       posInfo.Ticket(), bufferInPoints);
         }
      }
   }
   
   // Process pending orders if needed
   if(Manage_New_Positions)
      ProcessPendingOrders(bufferInPoints);
}

//+------------------------------------------------------------------+
//| Process pending orders                                           |
//+------------------------------------------------------------------+
void ProcessPendingOrders(double bufferInPoints)
{
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(orderInfo.SelectByIndex(i))
      {
         // Check if it's our order and symbol
         if((Magic_Number == 0 || orderInfo.Magic() == Magic_Number) && 
            orderInfo.Symbol() == _Symbol)
         {
            // Get order type
            ENUM_ORDER_TYPE orderType = orderInfo.OrderType();
            
            // Process only if it's a pending order
            if(orderType == ORDER_TYPE_BUY_LIMIT || orderType == ORDER_TYPE_BUY_STOP || 
               orderType == ORDER_TYPE_SELL_LIMIT || orderType == ORDER_TYPE_SELL_STOP)
            {
               double newSL = 0.0, newTP = 0.0;
               double entryPrice = orderInfo.PriceOpen();
               
               // Calculate SL and TP based on order type
               if(orderType == ORDER_TYPE_BUY_LIMIT || orderType == ORDER_TYPE_BUY_STOP)
               {
                  if(Manage_SL)
                     newSL = NormalizeDouble(entryPrice - (atrValue * SL_ATR_Multiplier) - bufferInPoints, digits);
                  
                  if(Manage_TP)
                     newTP = NormalizeDouble(entryPrice + (atrValue * TP_ATR_Multiplier), digits);
               }
               else // Sell orders
               {
                  if(Manage_SL)
                     newSL = NormalizeDouble(entryPrice + (atrValue * SL_ATR_Multiplier) + bufferInPoints, digits);
                  
                  if(Manage_TP)
                     newTP = NormalizeDouble(entryPrice - (atrValue * TP_ATR_Multiplier), digits);
               }
               
               // Get current SL and TP
               double currentSL = orderInfo.StopLoss();
               double currentTP = orderInfo.TakeProfit();
               
               // Check if we need to modify the order
               if((currentSL != newSL && Manage_SL) || (currentTP != newTP && Manage_TP))
               {
                  if(!Manage_SL) newSL = currentSL; // Keep current SL if not managing it
                  if(!Manage_TP) newTP = currentTP; // Keep current TP if not managing it
                  
                  // Modify the order
                  if(!trade.OrderModify(orderInfo.Ticket(), entryPrice, newSL, newTP, orderInfo.TypeTime(), orderInfo.TimeExpiration()))
                  {
                     Print("Failed to modify order #", orderInfo.Ticket(), " Error: ", GetLastError());
                  }
               }
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Process a single position                                        |
//+------------------------------------------------------------------+
void ProcessPosition(ENUM_POSITION_TYPE posType, double openPrice, 
                   double currentSL, double currentTP, ulong ticket, 
                   double bufferInPoints)
{
   double newSL = 0, newTP = 0;
   double trailingStartLevel = 0;
   double currentPrice = 0;
   bool modifyPosition = false;
   
   // Get current bid/ask
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   
   // Set SL and TP based on position type
   if(posType == POSITION_TYPE_BUY)
   {
      currentPrice = bid;
      
      // Calculate new stop loss if needed
      if(Manage_SL)
      {
         // Initial SL calculation
         newSL = NormalizeDouble(openPrice - (atrValue * SL_ATR_Multiplier) - bufferInPoints, digits);
      }
      else
      {
         newSL = currentSL; // Keep current SL
      }
      
      // Calculate new take profit if needed
      if(Manage_TP && !Close_At_Profit_Target)
      {
         newTP = NormalizeDouble(openPrice + (atrValue * TP_ATR_Multiplier), digits);
      }
      else
      {
         newTP = currentTP; // Keep current TP
      }
      
      // Check for profit target if closing instead of TP
      if(Close_At_Profit_Target)
      {
         double profitTarget = openPrice + (atrValue * TP_ATR_Multiplier);
         if(currentPrice >= profitTarget)
         {
            // Close the position at profit target
            if(trade.PositionClose(ticket))
            {
               Print("Position #", ticket, " closed at profit target!");
            }
            return; // Exit the function
         }
      }
      
      // Check for trailing stop if enabled
      if(Use_Trailing_Stop && Manage_SL)
      {
         // Calculate trailing start level
         trailingStartLevel = NormalizeDouble(openPrice + (atrValue * Trail_Start_Multiplier), digits);
         
         // Check if price has moved enough to activate trailing
         if(currentPrice >= trailingStartLevel)
         {
            // Calculate new trailing stop level
            double trailingSL = NormalizeDouble(currentPrice - (atrValue * Trail_Step_Multiplier) - bufferInPoints, digits);
            
            // Only move stop up, never down
            if(trailingSL > currentSL || currentSL == 0)
            {
               newSL = trailingSL;
               modifyPosition = true;
            }
         }
      }
   }
   else if(posType == POSITION_TYPE_SELL)
   {
      currentPrice = ask;
      
      // Calculate new stop loss if needed
      if(Manage_SL)
      {
         // Initial SL calculation
         newSL = NormalizeDouble(openPrice + (atrValue * SL_ATR_Multiplier) + bufferInPoints, digits);
      }
      else
      {
         newSL = currentSL; // Keep current SL
      }
      
      // Calculate new take profit if needed
      if(Manage_TP && !Close_At_Profit_Target)
      {
         newTP = NormalizeDouble(openPrice - (atrValue * TP_ATR_Multiplier), digits);
      }
      else
      {
         newTP = currentTP; // Keep current TP
      }
      
      // Check for profit target if closing instead of TP
      if(Close_At_Profit_Target)
      {
         double profitTarget = openPrice - (atrValue * TP_ATR_Multiplier);
         if(currentPrice <= profitTarget)
         {
            // Close the position at profit target
            if(trade.PositionClose(ticket))
            {
               Print("Position #", ticket, " closed at profit target!");
            }
            return; // Exit the function
         }
      }
      
      // Check for trailing stop if enabled
      if(Use_Trailing_Stop && Manage_SL)
      {
         // Calculate trailing start level
         trailingStartLevel = NormalizeDouble(openPrice - (atrValue * Trail_Start_Multiplier), digits);
         
         // Check if price has moved enough to activate trailing
         if(currentPrice <= trailingStartLevel)
         {
            // Calculate new trailing stop level
            double trailingSL = NormalizeDouble(currentPrice + (atrValue * Trail_Step_Multiplier) + bufferInPoints, digits);
            
            // Only move stop down (for shorts), never up
            if(trailingSL < currentSL || currentSL == 0)
            {
               newSL = trailingSL;
               modifyPosition = true;
            }
         }
      }
   }
   
   // Ensure we're not moving SL in wrong direction for position type
   if(posType == POSITION_TYPE_BUY && currentSL > 0 && newSL < currentSL)
   {
      // Keep current SL
      newSL = currentSL;
   }
   else if(posType == POSITION_TYPE_SELL && currentSL > 0 && newSL > currentSL)
   {
      // Keep current SL
      newSL = currentSL;
   }
   
   // Check if SL or TP needs to be changed
   if((MathAbs(currentSL - newSL) > Point() && Manage_SL) || 
      (MathAbs(currentTP - newTP) > Point() && Manage_TP) || 
      modifyPosition)
   {
      // Apply the new SL and TP
      if(trade.PositionModify(ticket, newSL, newTP))
      {
         string action = modifyPosition ? "Trailing Stop" : "Initial SL/TP";
         Print(action, " applied to position #", ticket, " New SL: ", newSL, " New TP: ", newTP);
      }
      else
      {
         Print("Failed to modify position #", ticket, " Error: ", GetLastError());
      }
   }
}