mql5/Include/Escape/RiskManager_Impl.mqh

//+------------------------------------------------------------------+
//|                                           RiskManager_Impl.mqh   |
//|                                          Copyright 2025, EscapeEA |
//|                                             https://www.escapeea.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, EscapeEA"
#property link      "https://www.escapeea.com"
#property version   "2.10"
#property strict

// Include necessary headers
#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\DealInfo.mqh>
#include <Trade\OrderInfo.mqh>
#include <Trade\HistoryOrderInfo.mqh>
#include <Arrays\ArrayObj.mqh>
#include <Arrays\ArrayString.mqh>
#include <Arrays\List.mqh>
#include <Files\FileBin.mqh>
#include <Files\FileTxt.mqh>
#include <Indicators\Oscilators.mqh>
#include <Math\Stat\Math.mqh>

// Logging levels
enum ENUM_LOG_LEVEL
{
   LOG_LEVEL_NONE = 0,    // No logging
   LOG_LEVEL_ERROR,       // Only errors
   LOG_LEVEL_WARNING,     // Errors and warnings
   LOG_LEVEL_INFO,        // Basic information
   LOG_LEVEL_DEBUG,       // Detailed debug information
   LOG_LEVEL_TRACE        // Very detailed tracing
};

// Trade metrics structure
struct STradeMetrics
{
   datetime   timestamp;          // Time of the trade
   string     symbol;             // Symbol
   double     volume;             // Trade volume
   double     entryPrice;         // Entry price
   double     exitPrice;          // Exit price
   double     pips;               // Pips gained/lost
   double     profit;             // Profit/loss in account currency
   double     drawdown;           // Drawdown at time of trade
   double     volatility;         // Market volatility (ATR)
   double     spread;             // Spread at time of trade
   int        duration;           // Trade duration in seconds
   string     comment;            // Additional comments
   
   // Default constructor
   STradeMetrics() : timestamp(0), symbol(""), volume(0), entryPrice(0), exitPrice(0), 
                     pips(0), profit(0), drawdown(0), volatility(0), spread(0), duration(0), comment("") {}
};

// Performance metrics structure
struct SPerformanceMetrics
{
   int         totalTrades;       // Total number of trades
   int         winningTrades;     // Number of winning trades
   double      totalProfit;       // Total profit
   double      totalLoss;         // Total loss
   double      largestWin;        // Largest winning trade
   double      largestLoss;       // Largest losing trade
   double      maxDrawdown;       // Maximum drawdown
   double      profitFactor;      // Profit factor (gross profit / gross loss)
   double      recoveryFactor;    // Net profit / max drawdown
   double      sharpeRatio;       // Risk-adjusted return
   double      sortinoRatio;      // Downside risk-adjusted return
   double      averageTrade;      // Average trade result
   double      standardDeviation; // Standard deviation of returns
   double      winRate;           // Win rate percentage
   
   // Default constructor
   SPerformanceMetrics() : totalTrades(0), winningTrades(0), totalProfit(0), totalLoss(0),
                          largestWin(0), largestLoss(0), maxDrawdown(0), profitFactor(0),
                          recoveryFactor(0), sharpeRatio(0), sortinoRatio(0), averageTrade(0),
                          standardDeviation(0), winRate(0) {}
};

// Forward declarations
class CSecurityManager;
class CTradeRiskRecord;

// Include the header file to get class declaration
#include "RiskManager.mqh"

// Circuit breaker thresholds
#define CIRCUIT_BREAKER_THRESHOLD 5      // Number of consecutive failures before tripping
#define CIRCUIT_BREAKER_TIMEOUT 300      // Timeout in seconds before reset attempt
#define MAX_RETRY_ATTEMPTS 3             // Maximum number of retry attempts
#define INITIAL_RETRY_DELAY 1000         // Initial retry delay in milliseconds
#define MAX_RETRY_DELAY 60000            // Maximum retry delay in milliseconds

// Metrics file constants
#define METRICS_FILE_PREFIX "RiskMetrics_"
#define MAX_METRICS_ENTRIES 10000        // Maximum number of metrics entries to keep in memory

// Log file constants
#define LOG_FILE_PREFIX "RiskManager_"
#define MAX_LOG_FILE_SIZE 10485760        // 10 MB max log file size
#define MAX_LOG_FILES 5                  // Maximum number of log files to keep

// Define missing ENUM_ACCOUNT_INFO_DOUBLE values if not already defined
#ifndef ACCOUNT_COMMISSION
   #define ACCOUNT_COMMISSION 16
#endif

#ifndef ACCOUNT_SWAP
   #define ACCOUNT_SWAP 32
#endif

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CRiskManager::CRiskManager() :
   m_security(NULL),
   m_riskPerTrade(1.0),
   m_dailyLossLimit(2.0),
   m_maxOpenTrades(5),
   m_maxOrdersPerDay(20),
   m_useVolatilityAdjustment(true),
   m_atrPeriod(14),
   m_maxSpread(50.0),
   m_circuitBreakerActive(false),
   m_consecutiveFailures(0),
   m_circuitBreakerTime(0),
   m_logLevel(LOG_LEVEL_INFO),
   m_enableMetrics(true),
   m_enableDetailedLogging(false),
   m_lastMetricsUpdate(0),
   m_metricsUpdateInterval(60),  // Update metrics every 60 seconds
   m_retryAttempts(0),
   m_nextRetryTime(0),
   m_anomalyDetection(true),
   m_maxLeverage(30),
   m_dailyPnL(0.0),
   m_todayOrders(0),
   m_lastTradeDay(0),
   m_equityHigh(0.0),
   m_maxDrawdown(0.0),
   m_openTrades(NULL),
   m_watchlist(NULL),
   m_lastError(""),
   m_lastErrorSeverity(RISK_ERROR_NONE),
   m_atrHandle(INVALID_HANDLE),
   m_rateLimitHistory(NULL),
   m_enableRateLimiting(true),
   m_maxRequestsPerMinute(60),
   m_ordersToday(0)
{
   m_openTrades = new CArrayObj();
   m_watchlist = new CArrayString();
   m_security = new CSecurityManager();
   m_rateLimitHistory = new CArrayObj();
}

//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CRiskManager::~CRiskManager()
{
   if(CheckPointer(m_openTrades) == POINTER_DYNAMIC)
      delete m_openTrades;
      
   if(CheckPointer(m_watchlist) == POINTER_DYNAMIC)
      delete m_watchlist;
      
   if(CheckPointer(m_security) == POINTER_DYNAMIC)
      delete m_security;
      
   if(CheckPointer(m_rateLimitHistory) == POINTER_DYNAMIC)
      delete m_rateLimitHistory;
      
   if(m_atrHandle != INVALID_HANDLE)
      IndicatorRelease(m_atrHandle);
}

//+------------------------------------------------------------------+
//| Initialize the risk manager                                      |
//+------------------------------------------------------------------+
bool CRiskManager::Initialize()
{
   if(m_initialized)
   {
      m_lastError = "Risk manager already initialized";
      return true;
   }
   
   // Initialize ATR indicator for volatility calculation
   m_atrHandle = iATR(_Symbol, PERIOD_CURRENT, m_atrPeriod);
   if(m_atrHandle == INVALID_HANDLE)
   {
      m_lastError = "Failed to create ATR indicator";
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Initialize security manager
   if(m_security == NULL)
   {
      m_security = new CSecurityManager();
   }
   
   if(!m_security.Initialize())
   {
      m_lastError = "Failed to initialize security manager: " + m_security.GetLastError();
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Initialize state
   m_equityHigh = AccountInfoDouble(ACCOUNT_EQUITY);
   m_lastTradeDay = TimeCurrent();
   m_initialized = true;
   
   // Load configuration
   if(!LoadConfiguration())
   {
      m_lastError = "Warning: Using default configuration - " + m_lastError;
      m_lastErrorSeverity = RISK_ERROR_WARNING;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Deinitialize the risk manager                                   |
//+------------------------------------------------------------------+
void CRiskManager::Deinitialize()
{
   if(m_atrHandle != INVALID_HANDLE)
   {
      IndicatorRelease(m_atrHandle);
      m_atrHandle = INVALID_HANDLE;
   }
   
   if(CheckPointer(m_security) == POINTER_DYNAMIC)
   {
      m_security.Deinitialize();
   }
   
   m_initialized = false;
}

//+------------------------------------------------------------------+
//| Validate a trade request                                        |
//+------------------------------------------------------------------+
bool CRiskManager::ValidateTrade(const string symbol, double volume, double price, double sl, double tp)
{
   if(!m_initialized)
   {
      m_lastError = "Risk manager not initialized";
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Check if trading is allowed
   if(!IsTradingAllowed())
      return false;
      
   // Check if symbol is in watchlist
   if(m_watchlist.Total() > 0 && m_watchlist.SearchLinear(symbol) < 0)
   {
      m_lastError = "Symbol " + symbol + " not in watchlist";
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return false;
   }
   
   // Validate lot size
   if(!ValidateLotSize(symbol, volume))
      return false;
      
   // Validate spread
   if(!ValidateSpread(symbol))
      return false;
      
   // Check daily loss limit
   if(!ValidateDailyLossLimit())
      return false;
      
   // Check circuit breaker
   if(m_circuitBreakerActive)
   {
      m_lastError = "Trading suspended - circuit breaker active";
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Validate lot size                                               |
//+------------------------------------------------------------------+
bool CRiskManager::ValidateLotSize(const string symbol, double volume)
{
   double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
   double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
   
   if(volume < minLot || volume > maxLot)
   {
      m_lastError = StringFormat("Invalid lot size %.2f for %s (min: %.2f, max: %.2f)", 
                               volume, symbol, minLot, maxLot);
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return false;
   }
   
   // Check if volume is a multiple of lot step
   if(MathMod(volume, lotStep) > 0.0001) // Account for floating point precision
   {
      m_lastError = StringFormat("Lot size %.2f for %s must be a multiple of %.2f", 
                               volume, symbol, lotStep);
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return false;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Validate spread                                                 |
//+------------------------------------------------------------------+
bool CRiskManager::ValidateSpread(const string symbol)
{
   double spread = SymbolInfoInteger(symbol, SYMBOL_SPREAD);
   if(spread > m_maxSpread)
   {
      m_lastError = StringFormat("Spread %.1f for %s exceeds maximum allowed (%.1f)", 
                               spread, symbol, m_maxSpread);
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return false;
   }
   return true;
}

//+------------------------------------------------------------------+
//| Validate daily loss limit                                       |
//+------------------------------------------------------------------+
bool CRiskManager::ValidateDailyLossLimit()
{
   if(m_dailyPnL < 0 && MathAbs(m_dailyPnL) >= (AccountInfoDouble(ACCOUNT_BALANCE) * m_dailyLossLimit / 100.0))
   {
      m_lastError = StringFormat("Daily loss limit reached (%.2f%% of balance)", m_dailyLossLimit);
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   return true;
}

//+------------------------------------------------------------------+
//| Calculate position size based on risk parameters                |
//+------------------------------------------------------------------+
double CRiskManager::CalculatePositionSize(const string symbol, const double entryPrice, const double stopLoss, const double riskAmount)
{
   if(entryPrice <= 0 || stopLoss <= 0 || riskAmount <= 0)
   {
      m_lastError = "Invalid parameters for position sizing";
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return 0.0;
   }
   
   double positionSize = 0.0;
   
   // Select position sizing method
   switch(m_positionSizingMethod)
   {
      case POSITION_SIZING_FIXED:
         positionSize = m_fixedLotSize;
         break;
         
      case POSITION_SIZING_VOLATILITY:
         positionSize = CalculateVolatilityBasedSize(symbol, entryPrice, stopLoss, riskAmount);
         break;
         
      case POSITION_SIZING_KELLY:
      {
         double winRate = CalculateWinRate(symbol);
         double winLossRatio = CalculateWinLossRatio(symbol);
         positionSize = CalculateKellySize(symbol, entryPrice, stopLoss, winRate, winLossRatio);
         break;
      }
         
      case POSITION_SIZING_OPTIMAL_F:
      {
         double winRate = CalculateWinRate(symbol);
         double winLossRatio = CalculateWinLossRatio(symbol);
         positionSize = CalculateOptimalFSize(symbol, entryPrice, stopLoss, winRate, winLossRatio);
         break;
      }
         
      case POSITION_SIZING_HYBRID:
      {
         double winRate = CalculateWinRate(symbol);
         double winLossRatio = CalculateWinLossRatio(symbol);
         positionSize = CalculateHybridSize(symbol, entryPrice, stopLoss, riskAmount, winRate, winLossRatio);
         break;
      }
         
      case POSITION_SIZING_RISK_BASED:
      default:
         positionSize = CalculateRiskBasedSize(symbol, entryPrice, stopLoss, riskAmount);
   }
   
   // Apply position scaling based on account growth if enabled
   if(m_positionScaling != SCALING_NONE)
   {
      double initialBalance = AccountInfoDouble(ACCOUNT_BALANCE);
      double currentBalance = AccountInfoDouble(ACCOUNT_EQUITY);
      double growthFactor = (currentBalance - initialBalance) / initialBalance;
      positionSize = ScalePositionSize(positionSize, growthFactor);
   }
   
   // Apply position size limits
   positionSize = MathMax(m_minPositionSize, MathMin(positionSize, m_maxPositionSize));
   
   // Round to nearest step
   if(m_positionSizeStep > 0)
   {
      positionSize = MathRound(positionSize / m_positionSizeStep) * m_positionSizeStep;
   }
   
   return NormalizeLotSize(positionSize);
}

//+------------------------------------------------------------------+
//| Calculate position size based on volatility (ATR)               |
//+------------------------------------------------------------------+
double CRiskManager::CalculateVolatilityBasedSize(const string symbol, const double entryPrice, const double stopLoss, const double riskAmount)
{
   double atrValue = GetATRValue(symbol, PERIOD_CURRENT, (int)m_volatilityPeriod);
   
   if(atrValue <= 0)
   {
      // Fall back to standard risk-based if ATR is not available
      return CalculateRiskBasedSize(symbol, entryPrice, stopLoss, riskAmount);
   }
   
   double stopDistance = MathAbs(entryPrice - stopLoss);
   double atrMultiple = stopDistance / atrValue;
   
   // Adjust risk amount based on volatility
   double adjustedRisk = riskAmount * (1.0 + (1.0 - 1.0 / (1.0 + atrMultiple)) * m_volatilityMultiplier);
   
   return CalculateRiskBasedSize(symbol, entryPrice, stopLoss, adjustedRisk);
}

//+------------------------------------------------------------------+
//| Calculate position size using Kelly Criterion                    |
//+------------------------------------------------------------------+
double CRiskManager::CalculateKellySize(const string symbol, const double entryPrice, const double stopLoss, 
                                      const double winRate, const double winLossRatio)
{
   if(winRate <= 0 || winRate >= 1.0 || winLossRatio <= 0)
   {
      // Fall back to standard risk-based if invalid parameters
      return CalculateRiskBasedSize(symbol, entryPrice, stopLoss, m_riskPerTrade);
   }
   
   // Kelly formula: f* = (bp - q) / b
   // where: f* = fraction of current bankroll to wager
   //        b = net odds received on wager (win amount / loss amount)
   //        p = probability of winning
   //        q = probability of losing (1 - p)
   double kellyFraction = (winRate * winLossRatio - (1.0 - winRate)) / winLossRatio;
   
   // Apply user-defined fraction of Kelly (0.0 to 1.0)
   kellyFraction = MathMax(0.0, MathMin(kellyFraction * m_kellyFraction, 1.0));
   
   // Calculate position size based on Kelly fraction
   double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   double riskAmount = accountBalance * kellyFraction;
   
   return CalculateRiskBasedSize(symbol, entryPrice, stopLoss, riskAmount);
}

//+------------------------------------------------------------------+
//| Calculate position size using Optimal F                          |
//+------------------------------------------------------------------+
double CRiskManager::CalculateOptimalFSize(const string symbol, const double entryPrice, const double stopLoss, 
                                         const double winRate, const double winLossRatio)
{
   if(winRate <= 0 || winRate >= 1.0 || winLossRatio <= 0)
   {
      // Fall back to standard risk-based if invalid parameters
      return CalculateRiskBasedSize(symbol, entryPrice, stopLoss, m_riskPerTrade);
   }
   
   // Simplified Optimal F calculation
   // Optimal f = ( (1 + winLossRatio) * winRate - 1 ) / winLossRatio
   double optimalF = ((1.0 + winLossRatio) * winRate - 1.0) / winLossRatio;
   
   // Apply user-defined fraction of Optimal F (0.0 to 1.0)
   optimalF = MathMax(0.0, MathMin(optimalF * m_optimalFFraction, 1.0));
   
   // Calculate position size based on Optimal F
   double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   double riskAmount = accountBalance * optimalF;
   
   return CalculateRiskBasedSize(symbol, entryPrice, stopLoss, riskAmount);
}

//+------------------------------------------------------------------+
//| Calculate position size using hybrid approach                    |
//+------------------------------------------------------------------+
double CRiskManager::CalculateHybridSize(const string symbol, const double entryPrice, const double stopLoss, 
                                       const double riskAmount, const double winRate, const double winLossRatio)
{
   // Calculate position sizes using different methods
   double riskBased = CalculateRiskBasedSize(symbol, entryPrice, stopLoss, riskAmount);
   double volatilityBased = CalculateVolatilityBasedSize(symbol, entryPrice, stopLoss, riskAmount);
   
   // If we have valid win rate and win/loss ratio, include Kelly and Optimal F
   if(winRate > 0 && winRate < 1.0 && winLossRatio > 0)
   {
      double kellySize = CalculateKellySize(symbol, entryPrice, stopLoss, winRate, winLossRatio);
      double optimalFSize = CalculateOptimalFSize(symbol, entryPrice, stopLoss, winRate, winLossRatio);
      
      // Use weighted average of all methods
      return (riskBased * 0.2 + volatilityBased * 0.3 + kellySize * 0.25 + optimalFSize * 0.25);
   }
   
   // Fall back to average of risk-based and volatility-based
   return (riskBased + volatilityBased) / 2.0;
}

//+------------------------------------------------------------------+
//| Scale position size based on account growth                      |
//+------------------------------------------------------------------+
double CRiskManager::ScalePositionSize(const double size, const double accountGrowth)
{
   if(accountGrowth <= 0 || m_positionScaling == SCALING_NONE)
   {
      return size;
   }
   
   double scaleFactor = 1.0;
   
   switch(m_positionScaling)
   {
      case SCALING_LINEAR:
         scaleFactor = 1.0 + accountGrowth;
         break;
         
      case SCALING_SQRT:
         scaleFactor = MathSqrt(1.0 + accountGrowth);
         break;
         
      case SCALING_LOG:
         scaleFactor = 1.0 + MathLog(1.0 + accountGrowth);
         break;
         
      case SCALING_NONE:
      default:
         return size;
   }
   
   return size * scaleFactor;
}

//+------------------------------------------------------------------+
//| Calculate position size based on risk (base method)              |
//+------------------------------------------------------------------+
double CRiskManager::CalculateRiskBasedSize(const string symbol, const double entryPrice, 
                                          const double stopLoss, const double riskAmount)
{
   if(entryPrice <= 0 || stopLoss <= 0 || riskAmount <= 0)
   {
      m_lastError = "Invalid parameters for risk-based position sizing";
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return 0.0;
   }
   
   double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
   double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
   double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
   
   if(tickSize <= 0 || tickValue <= 0 || lotStep <= 0)
   {
      m_lastError = "Invalid symbol parameters for position sizing";
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return 0.0;
   }
   
   double stopDistance = MathAbs(entryPrice - stopLoss) / tickSize;
   double riskPerLot = stopDistance * tickValue;
   
   if(riskPerLot <= 0)
   {
      m_lastError = "Invalid risk per lot calculation";
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return 0.0;
   }
   
   double lots = riskAmount / riskPerLot;
   
   // Normalize to lot step
   lots = MathFloor(lots / lotStep) * lotStep;
   
   // Check against symbol limits
   double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
   
   return MathMax(minLot, MathMin(lots, maxLot));
}

//+------------------------------------------------------------------+
//| Calculate risk amount based on account balance and risk percent |
//+------------------------------------------------------------------+
double CRiskManager::CalculateRiskAmount(double accountBalance, double riskPercent)
{
   if(accountBalance <= 0 || riskPercent <= 0)
      return 0.0;
      
   return accountBalance * riskPercent / 100.0;
}

//+------------------------------------------------------------------+
//| Calculate risk for a trade                                      |
//+------------------------------------------------------------------+
double CRiskManager::CalculateTradeRisk(const string symbol, double volume, double entryPrice, double stopLoss)
{
   if(entryPrice <= 0 || stopLoss <= 0 || volume <= 0)
      return 0.0;
      
   double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
   double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
   double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
   
   if(tickSize == 0 || tickValue == 0 || point == 0)
      return 0.0;
      
   double riskPoints = MathAbs(entryPrice - stopLoss) / point;
   return riskPoints * tickValue * volume / (tickSize / point);
}

//+------------------------------------------------------------------+
//| Get current risk exposure                                       |
//+------------------------------------------------------------------+
double CRiskManager::GetCurrentRiskExposure()
{
   if(!m_initialized)
      return 0.0;
      
   double totalRisk = 0.0;
   
   // Calculate risk from open positions
   for(int i = 0; i < m_openTrades.Total(); i++)
   {
      CTradeRiskRecord* trade = m_openTrades.At(i);
      if(trade != NULL)
      {
         totalRisk += CalculateTradeRisk(trade.symbol, trade.volume, trade.entry, trade.sl);
      }
   }
   
   return totalRisk;
}

//+------------------------------------------------------------------+
//| Check circuit breaker status                                    |
//+------------------------------------------------------------------+
bool CRiskManager::CheckCircuitBreaker()
{
   if(!m_initialized)
   {
      m_lastError = "Risk manager not initialized";
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   double equity = AccountInfoDouble(ACCOUNT_EQUITY);
   double balance = AccountInfoDouble(ACCOUNT_BALANCE);
   double drawdown = 1.0 - (equity / m_equityHigh);
   
   if(drawdown >= m_circuitBreakerLevel)
   {
      m_circuitBreakerActive = true;
      m_circuitBreakerLevel = drawdown;
      m_lastError = StringFormat("Circuit breaker triggered at %.2f%% drawdown", drawdown * 100.0);
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Reset circuit breaker                                           |
//+------------------------------------------------------------------+
void CRiskManager::ResetCircuitBreaker()
{
   m_circuitBreakerActive = false;
   m_equityHigh = AccountInfoDouble(ACCOUNT_EQUITY);
   m_lastError = "Circuit breaker reset";
   m_lastErrorSeverity = RISK_ERROR_NONE;
}

//+------------------------------------------------------------------+
//| Load configuration from file                                    |
//+------------------------------------------------------------------+
bool CRiskManager::LoadConfiguration()
{
   string filename = "RiskManager.cfg";
   int handle = FileOpen(filename, FILE_READ|FILE_BIN|FILE_COMMON);
   
   if(handle == INVALID_HANDLE)
   {
      m_lastError = "No configuration file found, using defaults";
      return false;
   }
   
   // Read configuration values
   m_riskPerTrade = FileReadDouble(handle);
   m_dailyLossLimit = FileReadDouble(handle);
   m_maxOpenTrades = (int)FileReadInteger(handle);
   m_maxOrdersPerDay = (int)FileReadInteger(handle);
   m_useVolatilityAdjustment = FileReadInteger(handle) != 0;
   m_atrPeriod = (int)FileReadInteger(handle);
   m_maxSpread = FileReadDouble(handle);
   m_anomalyDetection = FileReadInteger(handle) != 0;
   m_maxLeverage = (int)FileReadInteger(handle);
   m_enableRateLimiting = FileReadInteger(handle) != 0;
   m_maxRequestsPerMinute = (int)FileReadInteger(handle);
   
   FileClose(handle);
   return true;
}

//+------------------------------------------------------------------+
//| Save configuration to file                                      |
//+------------------------------------------------------------------+
bool CRiskManager::SaveConfiguration()
{
   if(!m_initialized)
   {
      m_lastError = "Risk manager not initialized";
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   string filename = "RiskManager.cfg";
   int handle = FileOpen(filename, FILE_WRITE|FILE_BIN|FILE_COMMON);
   
   if(handle == INVALID_HANDLE)
   {
      m_lastError = "Failed to open configuration file for writing";
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return false;
   }
   
   // Write configuration values
   FileWriteDouble(handle, m_riskPerTrade);
   FileWriteDouble(handle, m_dailyLossLimit);
   FileWriteInteger(handle, m_maxOpenTrades);
   FileWriteInteger(handle, m_maxOrdersPerDay);
   FileWriteInteger(handle, m_useVolatilityAdjustment ? 1 : 0);
   FileWriteInteger(handle, m_atrPeriod);
   FileWriteDouble(handle, m_maxSpread);
   FileWriteInteger(handle, m_anomalyDetection ? 1 : 0);
   FileWriteInteger(handle, m_maxLeverage);
   FileWriteInteger(handle, m_enableRateLimiting ? 1 : 0);
   FileWriteInteger(handle, m_maxRequestsPerMinute);
   
   FileClose(handle);
   return true;
}

//+------------------------------------------------------------------+
//| Event handler for tick events                                   |
//+------------------------------------------------------------------+
void CRiskManager::OnTick()
{
   if(!m_initialized)
      return;
      
   // Update equity high water mark
   double equity = AccountInfoDouble(ACCOUNT_EQUITY);
   if(equity > m_equityHigh)
      m_equityHigh = equity;
      
   // Check for new trading day
   MqlDateTime dt;
   TimeCurrent(dt);
   MqlDateTime lastDt;
   TimeToStruct(m_lastTradeDay, lastDt);
   
   if(dt.day != lastDt.day || dt.mon != lastDt.mon || dt.year != lastDt.year)
   {
      // New trading day - reset daily counters
      m_todayOrders = 0;
      m_dailyPnL = 0;
      m_lastTradeDay = TimeCurrent();
   }
   
   // Check circuit breaker
   CheckCircuitBreaker();
}

//+------------------------------------------------------------------+
//| Event handler for trade events                                  |
//+------------------------------------------------------------------+
void CRiskManager::OnTrade()
{
   if(!m_initialized)
      return;
      
   // Update open trades list
   UpdateOpenTrades();
   
   // Update daily P&L
   UpdateDailyPnL();
}

//+------------------------------------------------------------------+
//| Update list of open trades                                      |
//+------------------------------------------------------------------+
void CRiskManager::UpdateOpenTrades()
{
   if(!m_initialized)
      return;
      
   m_openTrades.Clear();
   
   // Get all open positions
   for(int i = 0; i < PositionsTotal(); i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0)
      {
         CTradeRiskRecord* trade = new CTradeRiskRecord();
         trade.ticket = ticket;
         trade.symbol = PositionGetString(POSITION_SYMBOL);
         trade.volume = PositionGetDouble(POSITION_VOLUME);
         trade.entry = PositionGetDouble(POSITION_PRICE_OPEN);
         trade.sl = PositionGetDouble(POSITION_SL);
         trade.tp = PositionGetDouble(POSITION_TP);
         trade.risk = CalculateTradeRisk(trade.symbol, trade.volume, trade.entry, trade.sl);
         trade.openTime = (datetime)PositionGetInteger(POSITION_TIME);
         
         m_openTrades.Add(trade);
      }
   }
}

//+------------------------------------------------------------------+
//| Update daily P&L                                                |
//+------------------------------------------------------------------+
void CRiskManager::UpdateDailyPnL()
{
   if(!m_initialized)
      return;
      
   m_dailyPnL = 0.0;
   
   // Calculate P&L for today's closed trades
   HistorySelect(TimeCurrent() - 86400, TimeCurrent());
   int totalDeals = HistoryDealsTotal();
   
   for(int i = 0; i < totalDeals; i++)
   {
      ulong ticket = HistoryDealGetTicket(i);
      if(ticket > 0)
      {
         datetime dealTime = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);
         if(TimeDay(dealTime) == TimeDay(TimeCurrent()))
         {
            double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT) +
                          HistoryDealGetDouble(ticket, DEAL_COMMISSION) +
                          HistoryDealGetDouble(ticket, DEAL_SWAP);
            m_dailyPnL += profit;
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Event handler for trade transactions                            |
//+------------------------------------------------------------------+
void CRiskManager::OnTradeTransaction(const MqlTradeTransaction& trans,
                                     const MqlTradeRequest& request,
                                     const MqlTradeResult& result)
{
   if(!m_initialized)
      return;
      
   // Increment order counter for the day
   if(trans.type == TRADE_TRANSACTION_ORDER_ADD || 
      trans.type == TRADE_TRANSACTION_ORDER_UPDATE ||
      trans.type == TRADE_TRANSACTION_ORDER_DELETE)
   {
      m_todayOrders++;
   }
   
   // Update open trades if position was opened/closed
   if(trans.type == TRADE_TRANSACTION_DEAL_ADD)
   {
      UpdateOpenTrades();
      UpdateDailyPnL();
   }
}

//+------------------------------------------------------------------+
//| Check if trading is allowed                                     |
//+------------------------------------------------------------------+
bool CRiskManager::IsTradingAllowed()
{
   if(!m_initialized)
   {
      m_lastError = "Risk manager not initialized";
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Check circuit breaker
   if(m_circuitBreakerActive)
   {
      m_lastError = "Circuit breaker active";
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Check security manager
   if(m_security != NULL && !m_security.IsTradingAllowed())
   {
      m_lastError = "Security restrictions: " + m_security.GetLastError();
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Check daily order limit
   if(m_todayOrders >= m_maxOrdersPerDay)
   {
      m_lastError = "Daily order limit reached";
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Check open trades limit
   if(m_openTrades.Total() >= m_maxOpenTrades)
   {
      m_lastError = "Maximum number of open trades reached";
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return false;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Save risk manager state                                         |
//+------------------------------------------------------------------+
bool CRiskManager::Save(const int handle)
{
   if(handle == INVALID_HANDLE)
   {
      m_lastError = "Invalid file handle";
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return false;
   }
   
   // Save state variables
   FileWriteLong(handle, m_lastTradeDay);
   FileWriteDouble(handle, m_equityHigh);
   FileWriteDouble(handle, m_dailyPnL);
   FileWriteInteger(handle, m_todayOrders);
   FileWriteInteger(handle, m_circuitBreakerActive ? 1 : 0);
   FileWriteDouble(handle, m_circuitBreakerLevel);
   FileWriteInteger(handle, m_ordersToday);
   
   return true;
}

//+------------------------------------------------------------------+
//| Load risk manager state                                         |
//+------------------------------------------------------------------+
bool CRiskManager::Load(const int handle)
{
   if(handle == INVALID_HANDLE)
   {
      m_lastError = "Invalid file handle";
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return false;
   }
   
   // Load state variables
   m_lastTradeDay = (datetime)FileReadLong(handle);
   m_equityHigh = FileReadDouble(handle);
   m_dailyPnL = FileReadDouble(handle);
   m_todayOrders = (int)FileReadInteger(handle);
   m_circuitBreakerActive = FileReadInteger(handle) != 0;
   m_circuitBreakerLevel = FileReadDouble(handle);
   m_ordersToday = (int)FileReadInteger(handle);
   
   return true;
}

//+------------------------------------------------------------------+
//| Update symbol cache with latest market data                     |
//+------------------------------------------------------------------+
void CRiskManager::UpdateSymbolCache(const string symbol)
{
   // Implementation for updating symbol cache
   // This is a placeholder - actual implementation would depend on requirements
}

//+------------------------------------------------------------------+
//| Check if rate limit is exceeded                                 |
//+------------------------------------------------------------------+
bool CRiskManager::CheckRateLimit()
{
   // Thread-safe section
   CCriticalLock lock(m_cs);
   
   // Check if rate limiting is enabled
   if(!m_enableRateLimiting)
   {
      m_lastErrorCode = RISK_ERROR_NONE;
      return true; // Rate limiting is disabled
   }
      
   // Get current time once to ensure consistency
   datetime currentTime = TimeCurrent();
   MqlDateTime timeStruct;
   if(!TimeToStruct(currentTime, timeStruct))
   {
      m_lastError = FormatError("Failed to get time structure", RISK_ERROR_INVALID_STATE);
      m_lastErrorCode = RISK_ERROR_INVALID_STATE;
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Validate configuration
   if(!ValidateConfig())
   {
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Validate member variables
   if(CheckPointer(m_rateLimitHistory) == POINTER_INVALID)
   {
      m_lastError = FormatError("Rate limit history not initialized", RISK_ERROR_INVALID_STATE);
      m_lastErrorCode = RISK_ERROR_INVALID_STATE;
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Clean up old entries from the rate limit history
   for(int i = m_rateLimitHistory.Total() - 1; i >= 0; i--)
   {
      CTradeRiskRecord* record = m_rateLimitHistory.At(i);
      if(CheckPointer(record) == POINTER_INVALID) 
      {
         m_rateLimitHistory.Delete(i);
         continue;
      }
      
      // Remove entries older than our rate limit window (1 minute)
      if(currentTime - record.Time() > 60) // 60 seconds window
      {
         CTradeRiskRecord* oldRecord = m_rateLimitHistory.Detach(i);
         if(CheckPointer(oldRecord) == POINTER_DYNAMIC)
            delete oldRecord;
      }
   }
   
   // Check if we've exceeded the maximum allowed requests per minute
   if(m_rateLimitHistory.Total() >= m_maxRequestsPerMinute)
   {
      m_lastError = FormatError("Rate limit exceeded: " + 
                               IntegerToString(m_rateLimitHistory.Total()) + 
                               " requests in the last minute", 
                               RISK_ERROR_RATE_LIMIT);
      m_lastErrorCode = RISK_ERROR_RATE_LIMIT;
      m_lastErrorSeverity = RISK_ERROR_WARNING;
      return false;
   }
   
   // Check if we've exceeded the maximum concurrent open trades
   int totalPositions = PositionsTotal();
   if(totalPositions < 0) // Handle error case
   {
      m_lastError = FormatError("Failed to get open positions count", RISK_ERROR_INVALID_STATE);
      m_lastErrorCode = RISK_ERROR_INVALID_STATE;
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   if(totalPositions >= m_maxOpenTrades)
   {
      m_lastError = FormatError("Maximum open trades limit reached: " + 
                               IntegerToString(m_maxOpenTrades), 
                               RISK_ERROR_TRADE_LIMIT);
      m_lastErrorCode = RISK_ERROR_TRADE_LIMIT;
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Check if we've exceeded daily order limit with boundary check
   if(m_ordersToday < 0) 
      m_ordersToday = 0; // Fix corrupted counter
   
   if(m_ordersToday >= m_maxOrdersPerDay)
   {
      m_lastError = FormatError("Daily order limit reached: " + 
                               IntegerToString(m_ordersToday) + " of " + 
                               IntegerToString(m_maxOrdersPerDay), 
                               RISK_ERROR_DAILY_LIMIT);
      m_lastErrorCode = RISK_ERROR_DAILY_LIMIT;
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Add current request to rate limit history with memory safety
   CTradeRiskRecord* newRecord = new CTradeRiskRecord();
   if(CheckPointer(newRecord) == POINTER_INVALID)
   {
      m_lastError = FormatError("Failed to allocate memory for rate limit tracking", 
                               RISK_ERROR_MEMORY);
      m_lastErrorCode = RISK_ERROR_MEMORY;
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   newRecord.SetTime(currentTime);
   if(m_rateLimitHistory.Add(newRecord) < 0)
   {
      delete newRecord;
      m_lastError = FormatError("Failed to track rate limit", RISK_ERROR_INVALID_STATE);
      m_lastErrorCode = RISK_ERROR_INVALID_STATE;
      m_lastErrorSeverity = RISK_ERROR_CRITICAL;
      return false;
   }
   
   // Reset daily counters at the start of a new trading day
   if(timeStruct.day != m_lastTradeDay)
   {
      m_lastTradeDay = timeStruct.day;
      m_ordersToday = 0;
      m_todayOrders = 0;
   }
   
   m_lastErrorCode = RISK_ERROR_NONE;
   return true;
}

//+------------------------------------------------------------------+
//| Adversarial testing: Simulate slippage                          |
//+------------------------------------------------------------------+
#ifdef ADVERSARIAL_TESTING
void CRiskManager::SimulateSlippage()
{
   // Implementation for slippage simulation in testing
}

//+------------------------------------------------------------------+
//| Adversarial testing: Simulate network latency                   |
//+------------------------------------------------------------------+
void CRiskManager::SimulateNetworkLatency()
{
   // Implementation for network latency simulation in testing
}

//+------------------------------------------------------------------+
//| Adversarial testing: Inject fault                               |
//+------------------------------------------------------------------+
void CRiskManager::InjectFault(const string component, const string type)
{
   // Implementation for fault injection in testing
}
#endif