mql5/Include/Escape/RiskManager.mqh

//+------------------------------------------------------------------+
//|                                                  RiskManager.mqh |
//|                                          Copyright 2025, EscapeEA |
//|                                             https://www.escapeea.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, EscapeEA"
#property link      "https://www.escapeea.com"
#property version   "2.20"  // Version bump for major enhancements
#property strict

// Standard Library Includes
#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\ArrayDouble.mqh>
#include <Files\FileBin.mqh>
#include <Math\Stat\Math.mqh>
#include <Math\Stat\Normal.mqh>

// Forward declarations
class CSecurityManager;

// Risk error codes
enum ENUM_RISK_ERROR_CODES
{
   RISK_ERROR_NONE = 0,           // No error
   RISK_ERROR_INVALID_STATE = 1000, // Invalid object state
   RISK_ERROR_MEMORY = 1001,      // Memory allocation failure
   RISK_ERROR_INVALID_PARAM = 1002, // Invalid parameter
   RISK_ERROR_IO = 1003,          // I/O operation failed
   RISK_ERROR_RATE_LIMIT = 1004,  // Rate limit exceeded
   RISK_ERROR_DAILY_LIMIT = 1005, // Daily limit reached
   RISK_ERROR_TRADE_LIMIT = 1006, // Trade limit reached
   RISK_ERROR_CONFIG = 1007,      // Configuration error
   RISK_ERROR_THREAD = 1008,      // Threading error
   RISK_ERROR_NOT_INITIALIZED = 1009, // Manager not initialized
   RISK_ERROR_SYMBOL = 1010,      // Invalid symbol
   RISK_ERROR_VOLUME = 1011,      // Invalid volume
   RISK_ERROR_PRICE = 1012,       // Invalid price
   RISK_ERROR_STOPLOSS = 1013,    // Invalid stop loss
   RISK_ERROR_TAKEPROFIT = 1014,  // Invalid take profit
   RISK_ERROR_MARGIN = 1015,      // Not enough margin
   RISK_ERROR_MARKET_CLOSED = 1016, // Market is closed
   RISK_ERROR_TRADE_DISABLED = 1017, // Trading is disabled
   RISK_ERROR_ACCOUNT = 1018,     // Account error
   RISK_ERROR_TIMEOUT = 1019,     // Operation timeout
   RISK_ERROR_CONNECTION = 1020   // Connection error
};

// Risk error severity levels
enum ENUM_RISK_ERROR_SEVERITY
{
   RISK_SEVERITY_NONE = 0,     // No error
   RISK_SEVERITY_INFO = 1,     // Informational message
   RISK_SEVERITY_WARNING = 2,  // Warning - non-critical issue
   RISK_SEVERITY_CRITICAL = 3, // Critical error - trading should be paused
   RISK_SEVERITY_FATAL = 4     // Fatal error - immediate action required
};

// Position sizing methods
enum ENUM_POSITION_SIZING_METHOD
{
   POSITION_SIZING_FIXED = 0,     // Fixed lot size
   POSITION_SIZING_RISK_BASED,    // Based on account risk percentage
   POSITION_SIZING_VOLATILITY,    // Based on market volatility (ATR)
   POSITION_SIZING_KELLY,         // Kelly Criterion
   POSITION_SIZING_OPTIMAL_F,     // Optimal F
   POSITION_SIZING_HYBRID,        // Hybrid approach
   POSITION_SIZING_MARTINGALE,    // Martingale (use with caution)
   POSITION_SIZING_ANTI_MARTINGALE // Anti-Martingale
};

// Position scaling methods
enum ENUM_POSITION_SCALING
{
   SCALING_NONE = 0,     // No scaling
   SCALING_LINEAR,       // Linear scaling with account growth
   SCALING_SQRT,         // Square root scaling
   SCALING_LOGARITHMIC,  // Logarithmic scaling
   SCALING_AGGRESSIVE,   // Aggressive scaling (exponential)
   SCALING_CONSERVATIVE  // Conservative scaling (diminishing returns)
};

// Trade direction
enum ENUM_TRADE_DIRECTION
{
   TRADE_DIRECTION_LONG = 1,  // Long position
   TRADE_DIRECTION_SHORT = -1, // Short position
   TRADE_DIRECTION_BOTH = 0    // Both directions
};

// Trade metrics structure for performance analysis
struct STradeMetrics
{
   datetime   timestamp;          // Time of the trade
   string     symbol;             // Symbol
   double     volume;             // Trade volume in lots
   double     entryPrice;         // Entry price
   double     exitPrice;          // Exit price (0 if still open)
   double     stopLoss;           // Stop loss level
   double     takeProfit;         // Take profit level
   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
   double     winRate;            // Current win rate when trade was opened
   double     riskReward;         // Risk/reward ratio
   double     kellySize;          // Kelly position size
   double     optimalFSize;       // Optimal F position size
   
   // Default constructor
   STradeMetrics() : timestamp(0), symbol(""), volume(0), entryPrice(0), exitPrice(0),
                    stopLoss(0), takeProfit(0), pips(0), profit(0), drawdown(0),
                    volatility(0), spread(0), duration(0), winRate(0), riskReward(0),
                    kellySize(0), optimalFSize(0) {}
};

//+------------------------------------------------------------------+
//| CRiskManager - Advanced Risk Management Class                    |
//+------------------------------------------------------------------+
class CRiskManager
{
private:
   // Thread synchronization
   CCriticalSection     m_cs;                // Thread synchronization object
   
   // Configuration
   double              m_riskPerTrade;       // Risk percentage per trade (0.1-5.0%)
   double              m_dailyLossLimit;     // Daily loss limit (% of account)
   int                 m_maxOpenTrades;      // Maximum number of open trades
   int                 m_maxOrdersPerDay;    // Maximum orders per day
   
   // State
   double              m_dailyPnL;           // Today's P&L
   int                 m_todayTrades;        // Trades executed today
   bool                m_initialized;        // Initialization flag
   datetime            m_lastTradeDay;       // Last trading day
   
   // Error handling
   string              m_lastError;          // Last error message
   ENUM_RISK_ERROR_CODES m_lastErrorCode;    // Last error code
   ENUM_RISK_ERROR_SEVERITY m_lastErrorSeverity; // Error severity
   
   // Position sizing
   ENUM_POSITION_SIZING_METHOD m_sizingMethod; // Current sizing method
   ENUM_POSITION_SCALING m_scalingMethod;    // Position scaling method
   double              m_minPositionSize;     // Minimum position size
   double              m_maxPositionSize;     // Maximum position size
   double              m_positionSizeStep;    // Position size step
   double              m_kellyFraction;       // Kelly fraction (0-1)
   double              m_optimalFFraction;    // Optimal F fraction (0-1)
   double              m_volatilityPeriod;    // Period for volatility calculation
   double              m_volatilityMultiplier; // Volatility multiplier
   
   // Caching
   struct SSymbolCache
   {
      double            lastPrice;           // Last price
      double            atrValue;            // Last ATR value
      datetime          lastUpdate;          // Last update time
      double            spread;              // Current spread
      double            pointValue;          // Point value in account currency
      
      SSymbolCache() : lastPrice(0), atrValue(0), lastUpdate(0), spread(0), pointValue(0) {}
   };
   
   CArrayObj*          m_symbolCache;        // Cache for symbol data
   
   // Trade history
   CArrayObj*          m_tradeHistory;       // Trade history for analysis
   int                 m_maxHistorySize;     // Maximum number of trades to keep in history
   
   // Performance metrics
   double              m_equityPeak;         // Peak equity for drawdown calculation
   double              m_maxDrawdown;        // Maximum drawdown percentage
   double              m_winRate;            // Current win rate
   double              m_avgWin;             // Average win amount
   double              m_avgLoss;            // Average loss amount
   double              m_riskRewardRatio;    // Average risk/reward ratio
   
   // Private methods
   double              CalculateRiskBasedSize(const string symbol, double entryPrice, double stopLoss, double riskAmount);
   double              CalculateVolatilitySize(const string symbol, double entryPrice, double stopLoss, double riskAmount);
   double              CalculateKellySize(double winRate, double winLossRatio, double riskAmount);
   double              CalculateOptimalFSize(double winRate, double winLossRatio, double riskAmount);
   double              CalculateHybridSize(const string symbol, double entryPrice, double stopLoss, double riskAmount);
   double              ScalePositionSize(double size, double accountGrowth);
   
   // Helper methods
   bool                IsValidSymbol(const string symbol) const;
   double              NormalizeLotSize(double lots) const;
   double              GetATR(const string symbol, int timeframe, int period, int shift = 0) const;
   void                UpdateSymbolCache(const string symbol);
   void                UpdateTradeMetrics(const STradeMetrics& metrics);
   double              CalculateWinRate() const;
   double              CalculateWinLossRatio() const;
   
public:
   // Constructor/Destructor
                        CRiskManager();
                       ~CRiskManager();
   
   // Initialization
   bool                  Initialize();
   void                  Deinitialize();
   bool                  IsInitialized() const { return m_initialized; }
   
   // Configuration
   void                  SetRiskParameters(double riskPerTrade, double dailyLossLimit, int maxOpenTrades, int maxOrdersPerDay);
   void                  SetPositionSizingMethod(ENUM_POSITION_SIZING_METHOD method) { m_sizingMethod = method; }
   void                  SetPositionScaling(ENUM_POSITION_SCALING method) { m_scalingMethod = method; }
   void                  SetPositionSizeLimits(double minSize, double maxSize, double step = 0.01);
   void                  SetKellyFraction(double fraction) { m_kellyFraction = MathClamp(fraction, 0.0, 1.0); }
   void                  SetOptimalFFraction(double fraction) { m_optimalFFraction = MathClamp(fraction, 0.0, 1.0); }
   void                  SetVolatilityPeriod(int period) { m_volatilityPeriod = MathMax(5, period); }
   void                  SetVolatilityMultiplier(double multiplier) { m_volatilityMultiplier = MathMax(0.1, multiplier); }
   
   // Position sizing
   double                CalculatePositionSize(const string symbol, double entryPrice, double stopLoss, double riskAmount);
   
   // Risk management
   bool                  CheckTradeRisk(const string symbol, double lots, double entryPrice, double stopLoss, double takeProfit, ENUM_ORDER_TYPE orderType);
   bool                  CheckDailyLossLimit() const;
   bool                  CheckMaxOpenTrades() const;
   bool                  CheckDrawdownLimit() const;
   bool                  CheckVolatility(const string symbol) const;
   
   // Trade event handlers
   void                  OnTradeOpen(ulong ticket, const string symbol, ENUM_ORDER_TYPE orderType, double volume, double price, double stopLoss, double takeProfit);
   void                  OnTradeClose(ulong ticket, const string symbol, ENUM_ORDER_TYPE orderType, double volume, double price, double profit, double swap);
   
   // Performance analysis
   double                GetWinRate() const { return m_winRate; }
   double                GetMaxDrawdown() const { return m_maxDrawdown; }
   double                GetRiskRewardRatio() const { return m_riskRewardRatio; }
   int                   GetTotalTrades() const { return m_tradeHistory.Total(); }
   
   // Error handling
   string                GetLastError() const { return m_lastError; }
   ENUM_RISK_ERROR_CODES GetLastErrorCode() const { return m_lastErrorCode; }
   ENUM_RISK_ERROR_SEVERITY GetLastErrorSeverity() const { return m_lastErrorSeverity; }
   
   // State management
   void                  ResetDailyMetrics();
   void                  ResetAllMetrics();
   double                GetDailyPnL() const { return m_dailyPnL; }
   int                   GetTodayTrades() const { return m_todayTrades; }
   
   // Reporting
   string                GenerateReport() const;
   
   // Adversarial testing hooks
   #ifdef ADVSECURITY_ENABLE_TESTING
   friend class CRiskManagerTester;
   #endif
};

// Include implementation
#include "RiskManager_Impl.mqh"