//+------------------------------------------------------------------+
//|                                          EnhancedSecurity.mqh     |
//|                        Copyright 2023, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

#include <Trade\AccountInfo.mqh>
#include <Trade\SymbolInfo.mqh>

//+------------------------------------------------------------------+
//| Security Enhancement Class                                       |
//+------------------------------------------------------------------+
class CEnhancedSecurity
{
private:
   // Security parameters
   bool              m_enabled;              // Security features enabled
   bool              m_allowLiveTrading;     // Allow live trading
   bool              m_allowModifyOrders;    // Allow order modifications
   bool              m_allowDeleteOrders;    // Allow order deletions
   
   // Rate limiting
   int               m_maxTradesPerMinute;   // Maximum trades per minute
   int               m_maxOrdersPerMinute;   // Maximum orders per minute
   datetime          m_lastTradeTime;        // Time of last trade
   int               m_tradeCount;           // Trade counter for rate limiting
   
   // Authorization
   string            m_allowedAccountNumbers[]; // Allowed account numbers
   
   // Objects
   CAccountInfo     *m_account;              // Pointer to account info
   
   // Private methods
   bool              IsAccountAuthorized();
   bool              CheckRateLimits();
   
public:
                     CEnhancedSecurity();
                    ~CEnhancedSecurity();
                    
   // Initialization
   bool              Initialize(CAccountInfo *account);
   
   // Security checks
   bool              ValidateTradeRequest(double lots, double price, 
                                        double sl, double tp, 
                                        ENUM_ORDER_TYPE type);
   
   // Getters
   bool              IsEnabled() const { return m_enabled; }
   bool              IsLiveTradingAllowed() const { return m_allowLiveTrading; }
   
   // Setters
   void              SetEnabled(bool enabled) { m_enabled = enabled; }
   void              SetLiveTrading(bool allow) { m_allowLiveTrading = allow; }
   
   // Security utilities
   static string     GetAccountFingerprint();
   static bool       IsValidSymbol(const string symbol);
   static bool       IsValidPrice(double price);
   static bool       IsValidLotSize(double lots, const string symbol);
};

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CEnhancedSecurity::CEnhancedSecurity() : m_enabled(true),
                                       m_allowLiveTrading(false),
                                       m_allowModifyOrders(true),
                                       m_allowDeleteOrders(true),
                                       m_maxTradesPerMinute(10),
                                       m_maxOrdersPerMinute(30),
                                       m_lastTradeTime(0),
                                       m_tradeCount(0),
                                       m_account(NULL)
{
   // Initialize allowed accounts array
   ArrayResize(m_allowedAccountNumbers, 0);
}

//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CEnhancedSecurity::~CEnhancedSecurity()
{
   m_account = NULL;
}

//+------------------------------------------------------------------+
//| Initialize security module                                       |
//+------------------------------------------------------------------+
bool CEnhancedSecurity::Initialize(CAccountInfo *account)
{
   if(account == NULL)
   {
      Print("Error: Invalid account info in security initialization");
      return false;
   }
   
   m_account = account;
   
   // Add current account to allowed accounts if empty
   if(ArraySize(m_allowedAccountNumbers) == 0)
   {
      ArrayResize(m_allowedAccountNumbers, 1);
      m_allowedAccountNumbers[0] = ""; // Empty means current account is allowed
   }
   
   // Reset rate limiting
   m_lastTradeTime = 0;
   m_tradeCount = 0;
   
   // Check if we're in the strategy tester
   if(MQLInfoInteger(MQL_TESTER) || MQLInfoInteger(MQL_VISUAL_MODE) || MQLInfoInteger(MQL_OPTIMIZATION))
   {
      // Allow everything in tester/optimization
      m_allowLiveTrading = true;
      m_allowModifyOrders = true;
      m_allowDeleteOrders = true;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Validate trade request                                           |
//+------------------------------------------------------------------+
bool CEnhancedSecurity::ValidateTradeRequest(double lots, double price, 
                                           double sl, double tp, 
                                           ENUM_ORDER_TYPE type)
{
   if(!m_enabled)
      return true;
      
   // Check account authorization
   if(!IsAccountAuthorized())
   {
      Print("Security: Account not authorized");
      return false;
   }
   
   // Check rate limits
   if(!CheckRateLimits())
   {
      Print("Security: Rate limit exceeded");
      return false;
   }
   
   // Validate price
   if(!IsValidPrice(price))
   {
      Print("Security: Invalid price: ", price);
      return false;
   }
   
   // Validate lot size
   CSymbolInfo symbol;
   symbol.Name(_Symbol);
   if(!IsValidLotSize(lots, symbol.Name()))
   {
      Print("Security: Invalid lot size: ", lots);
      return false;
   }
   
   // Validate stop loss and take profit if provided
   if((sl > 0 && !IsValidPrice(sl)) || (tp > 0 && !IsValidPrice(tp)))
   {
      Print("Security: Invalid stop loss or take profit");
      return false;
   }
   
   // For market orders, check if live trading is allowed
   if((type == ORDER_TYPE_BUY || type == ORDER_TYPE_SELL) && !m_allowLiveTrading)
   {
      Print("Security: Live trading is disabled");
      return false;
   }
   
   // Update trade count for rate limiting
   m_tradeCount++;
   m_lastTradeTime = TimeCurrent();
   
   return true;
}

//+------------------------------------------------------------------+
//| Check if account is authorized                                   |
//+------------------------------------------------------------------+
bool CEnhancedSecurity::IsAccountAuthorized()
{
   if(m_account == NULL)
      return false;
      
   // If no accounts are specified, allow all (for backward compatibility)
   if(ArraySize(m_allowedAccountNumbers) == 0)
      return true;
      
   // Check if current account is in the allowed list
   string currentAccount = IntegerToString(m_account.Login());
   
   for(int i = 0; i < ArraySize(m_allowedAccountNumbers); i++)
   {
      if(m_allowedAccountNumbers[i] == "" || m_allowedAccountNumbers[i] == currentAccount)
         return true;
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| Check rate limits                                                |
//+------------------------------------------------------------------+
bool CEnhancedSecurity::CheckRateLimits()
{
   // Reset counter if more than a minute has passed
   if(TimeCurrent() - m_lastTradeTime > 60)
   {
      m_tradeCount = 0;
      return true;
   }
   
   // Check if we've exceeded the rate limits
   if(m_tradeCount >= m_maxTradesPerMinute)
      return false;
      
   return true;
}

//+------------------------------------------------------------------+
//| Get account fingerprint                                          |
//+------------------------------------------------------------------+
string CEnhancedSecurity::GetAccountFingerprint()
{
   CAccountInfo account;
   string fingerprint = "";
   
   // Create a fingerprint based on account and machine info
   fingerprint += IntegerToString(account.Login());
   fingerprint += "|" + account.Company();
   fingerprint += "|" + account.Server();
   fingerprint += "|" + TerminalInfoString(TERMINAL_COMMONPATH);
   
   // Hash the fingerprint for security
   uchar hash[];
   StringToCharArray(fingerprint, hash, 0, -1, CP_UTF8);
   
   // Use a simple hash (in a real application, use a proper cryptographic hash)
   uint h = 0;
   for(int i = 0; i < ArraySize(hash); i++)
      h = 31 * h + hash[i];
   
   return StringFormat("%X", h);
}

//+------------------------------------------------------------------+
//| Check if symbol is valid                                         |
//+------------------------------------------------------------------+
bool CEnhancedSecurity::IsValidSymbol(const string symbol)
{
   if(symbol == NULL || StringLen(symbol) == 0)
      return false;
      
   // Check if symbol is selected in MarketWatch
   if(!SymbolSelect(symbol, true))
   {
      Print("Security: Symbol ", symbol, " is not available");
      return false;
   }
   
   // Check if symbol is visible and tradable
   if(!SymbolInfoInteger(symbol, SYMBOL_TRADE_MODE) == SYMBOL_TRADE_MODE_DISABLED)
   {
      Print("Security: Trading is disabled for symbol ", symbol);
      return false;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Check if price is valid                                          |
//+------------------------------------------------------------------+
bool CEnhancedSecurity::IsValidPrice(double price)
{
   // Check for NaN and infinity
   if(!MathIsValidNumber(price))
      return false;
      
   // Check if price is within reasonable bounds
   if(price <= 0 || price > 1000000) // Adjust these values based on your needs
      return false;
      
   return true;
}

//+------------------------------------------------------------------+
//| Check if lot size is valid                                       |
//+------------------------------------------------------------------+
bool CEnhancedSecurity::IsValidLotSize(double lots, const string symbol)
{
   if(lots <= 0)
      return false;
      
   // Get symbol parameters
   double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
   double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
   
   // Check against symbol limits
   if(lots < minLot || lots > maxLot)
      return false;
      
   // Check if lot size is a multiple of lot step
   double remainder = MathMod(lots, lotStep);
   if(remainder > 0.0000001) // Account for floating point precision
      return false;
      
   return true;
}
//+------------------------------------------------------------------+