//+------------------------------------------------------------------+
//|                                              InputValidation.mqh  |
//|                                          Copyright 2025, EscapeEA |
//|                                             https://www.escapeea.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, EscapeEA"
#property link      "https://www.escapeea.com"
#property version   "1.10"  // Added string validation and rate limiting
#property strict

#include <Trade\SymbolInfo.mqh>
#include "SecureMemory.mqh"

// Pattern definitions for input validation
#define PATTERN_ALPHANUMERIC "^[a-zA-Z0-9_\\-\\. ]+$"
#define PATTERN_SYMBOL_NAME "^[A-Z0-9]+$"
#define PATTERN_COMMENT "^[a-zA-Z0-9_\\-\\.\\s]+$"

//+------------------------------------------------------------------+
//| Input validation functions                                       |
//+------------------------------------------------------------------+

class CInputValidator {
private:
   CSymbolInfo m_symbol;
   
   // Rate limiting
   struct RateLimit {
      int      count;
      datetime lastReset;
      int      maxRequests;
      int      timeWindow;  // in seconds
   };
   
   RateLimit m_rateLimits[];
   
   // Private constructor for singleton pattern
   CInputValidator() {
      // Initialize rate limits (5 requests per minute by default)
      ArrayResize(m_rateLimits, 1);
      m_rateLimits[0].count = 0;
      m_rateLimits[0].lastReset = TimeCurrent();
      m_rateLimits[0].maxRequests = 5;
      m_rateLimits[0].timeWindow = 60;
   }
   
   // Prevent copying
   CInputValidator(const CInputValidator&);
   void operator=(const CInputValidator&);
   
   // Check rate limiting
   bool CheckRateLimit(int limitIndex = 0) {
      if(limitIndex < 0 || limitIndex >= ArraySize(m_rateLimits)) return false;
      
      datetime currentTime = TimeCurrent();
      if(currentTime - m_rateLimits[limitIndex].lastReset > m_rateLimits[limitIndex].timeWindow) {
         m_rateLimits[limitIndex].count = 0;
         m_rateLimits[limitIndex].lastReset = currentTime;
      }
      
      if(m_rateLimits[limitIndex].count >= m_rateLimits[limitIndex].maxRequests) {
         return false;
      }
      
      m_rateLimits[limitIndex].count++;
      return true;
   }
   
public:
   // Get singleton instance
   static CInputValidator* Instance() {
      static CInputValidator instance;
      return &instance;
   }
   
   //--- Basic validation functions
   bool IsValidLotSize(double lots, const string symbol = "") {
      if(lots <= 0) return false;
      
      if(symbol != "" && !m_symbol.Name(symbol)) {
         Print("Error: Invalid symbol for lot size validation");
         return false;
      }
      
      double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
      double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
      double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
      
      // Check against minimum and maximum lot size
      if(lots < minLot || lots > maxLot) {
         PrintFormat("Error: Lot size %.2f is outside valid range [%.2f, %.2f]", lots, minLot, maxLot);
         return false;
      }
      
      // Check if lot size is a multiple of the lot step
      if(MathMod(lots, lotStep) > 0.0001) {
         PrintFormat("Error: Lot size %.2f is not a multiple of step size %.2f", lots, lotStep);
         return false;
      }
      
      return true;
   }
   
   bool IsValidPrice(double price, const string symbol = "") {
      if(price <= 0) return false;
      
      if(symbol != "") {
         double ask = SymbolInfoDouble(symbol, SYMBOL_ASK);
         double bid = SymbolInfoDouble(symbol, SYMBOL_BID);
         double spread = ask - bid;
         
         // Allow some buffer for price validation
         if(price < bid - spread * 10 || price > ask + spread * 10) {
            PrintFormat("Warning: Price %.5f is far from current market [%.5f, %.5f]", 
                       price, bid, ask);
            // Don't return false here as it might be a pending order
         }
      }
      
      return true;
   }
   
   bool IsValidStopLoss(double price, double stopLoss, const string symbol = "") {
      if(!IsValidPrice(price, symbol) || !IsValidPrice(stopLoss, symbol)) {
         return false;
      }
      
      if(symbol != "") {
         double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
         double stopLevel = SymbolInfoInteger(symbol, SYMBOL_TRADE_STOPS_LEVEL) * point;
         double minStopDistance = stopLevel * 1.5; // Add 50% buffer to minimum stop level
         
         if(MathAbs(price - stopLoss) < minStopDistance) {
            PrintFormat("Error: Stop loss too close to entry price. Min distance: %.5f", minStopDistance);
            return false;
         }
      }
      
      return true;
   }
   
   bool IsValidTakeProfit(double price, double takeProfit, const string symbol = "") {
      if(!IsValidPrice(price, symbol) || !IsValidPrice(takeProfit, symbol)) {
         return false;
      }
      
      if(symbol != "") {
         double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
         double stopLevel = SymbolInfoInteger(symbol, SYMBOL_TRADE_STOPS_LEVEL) * point;
         double minTakeProfitDistance = stopLevel * 1.5; // Add 50% buffer
         
         if(MathAbs(price - takeProfit) < minTakeProfitDistance) {
            PrintFormat("Error: Take profit too close to entry price. Min distance: %.5f", minTakeProfitDistance);
            return false;
         }
      }
      
      return true;
   }
   
   bool IsValidMagicNumber(ulong magic) {
      // Magic number should be non-zero and within reasonable range
      if(magic == 0 || magic > 999999999) {
         Print("Error: Invalid magic number");
         return false;
      }
      return true;
   }
   
   bool IsValidSlippage(int slippage) {
      // Slippage should be reasonable (0-100 pips)
      if(slippage < 0 || slippage > 1000) { // 1000 points = 10 pips for 5-digit brokers
         Print("Error: Invalid slippage value");
         return false;
      }
      return true;
   }
   
   bool IsValidRiskPercentage(double riskPercent) {
      // Risk per trade should be between 0.1% and 5%
      if(riskPercent < 0.1 || riskPercent > 5.0) {
         Print("Error: Risk percentage should be between 0.1% and 5.0%");
         return false;
      }
      return true;
   }
   
   bool IsValidLeverage(double leverage) {
      // Leverage should be between 1:1 and 1:500
      if(leverage < 1.0 || leverage > 500.0) {
         Print("Error: Leverage should be between 1 and 500");
         return false;
      }
      return true;
   }
   
   //--- String validation functions
   bool ValidateStringPattern(const string text, const string pattern, const string fieldName = "") {
      if(!CheckRateLimit()) {
         Print("Rate limit exceeded for string validation");
         return false;
      }
      
      int textLen = StringLen(text);
      if(textLen == 0) {
         if(fieldName != "") Print("Error: ", fieldName, " cannot be empty");
         return false;
      }
      
      // Simple pattern matching (MQL5 doesn't have built-in regex)
      if(StringFind(text, "\0") >= 0) {
         if(fieldName != "") Print("Error: ", fieldName, " contains null bytes");
         return false;
      }
      
      // More comprehensive pattern matching can be added here
      return true;
   }
   
   // Validate symbol name (alphanumeric and some special chars)
   bool IsValidSymbolName(const string &symbol) {
      if(!ValidateStringPattern(symbol, PATTERN_SYMBOL_NAME, "Symbol name")) {
         return false;
      }
      
      // Additional symbol-specific validation
      if(StringLen(symbol) < 2 || StringLen(symbol) > 32) {
         Print("Error: Symbol name must be between 2 and 32 characters");
         return false;
      }
      
      return true;
   }
   
   // Validate trade comment
   bool IsValidTradeComment(const string &comment) {
      if(!ValidateStringPattern(comment, PATTERN_COMMENT, "Trade comment")) {
         return false;
      }
      
      // Comment length check
      if(StringLen(comment) > 128) {
         Print("Error: Trade comment is too long (max 128 characters)");
         return false;
      }
      
      return true;
   }
   
   // Validate file path
   bool IsValidFilePath(const string &path) {
      if(!ValidateStringPattern(path, "", "File path")) {
         return false;
      }
      
      // Basic path traversal prevention
      if(StringFind(path, "..\\") >= 0 || StringFind(path, "../") >= 0) {
         Print("Error: Invalid file path - path traversal not allowed");
         return false;
      }
      
      return true;
   }
   
   // Set rate limit for validation functions
   bool SetRateLimit(int maxRequests, int timeWindow, int limitIndex = 0) {
      if(limitIndex < 0) return false;
      
      if(limitIndex >= ArraySize(m_rateLimits)) {
         int oldSize = ArraySize(m_rateLimits);
         if(ArrayResize(m_rateLimits, limitIndex + 1) <= 0) return false;
         
         // Initialize new entries
         for(int i = oldSize; i < ArraySize(m_rateLimits); i++) {
            m_rateLimits[i].count = 0;
            m_rateLimits[i].lastReset = TimeCurrent();
            m_rateLimits[i].maxRequests = 5;  // Default
            m_rateLimits[i].timeWindow = 60;   // Default 1 minute
         }
      }
      
      m_rateLimits[limitIndex].maxRequests = maxRequests;
      m_rateLimits[limitIndex].timeWindow = timeWindow;
      return true;
   }
};

// Global instance
CInputValidator* ExtInputValidator = NULL;