//+------------------------------------------------------------------+
//|                                              PositionSizer.mqh    |
//|                        Copyright 2025, Your Company Name          |
//|                                             https://www.yoursite.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Your Company Name"
#property link      "https://www.yoursite.com"
#property version   "1.00"
#property strict

#include "RiskParameters.mqh"
#include "RiskMetrics.mqh"

//+------------------------------------------------------------------+
//| Position Sizer Class                                             |
//+------------------------------------------------------------------+
class CPositionSizer
{
private:
   CRiskParameters*   m_params;         // Risk parameters
   CRiskMetrics*      m_metrics;        // Risk metrics
   
   // Position sizing parameters
   double            m_volatilityFactor;  // Current volatility adjustment factor
   double            m_correlationFactor; // Correlation adjustment factor
   
   // State
   bool              m_isInitialized;    // Initialization flag
   
   // Private methods
   double            CalculateBasePositionSize(const string symbol, const double stopLossPips, 
                                             const double riskPercent, const double accountEquity);
   double            ApplyVolatilityAdjustment(const string symbol, const double size);
   double            ApplyCorrelationAdjustment(const string symbol, const double size);
   double            ApplyLeverageAdjustment(const double size);
   double            ApplyLotStepRounding(const string symbol, const double size);
   
public:
   // Constructor/Destructor
                     CPositionSizer();
                    ~CPositionSizer();
   
   // Initialization
   bool              Initialize(CRiskParameters* params = NULL, CRiskMetrics* metrics = NULL);
   void              Deinitialize();
   
   // Position sizing
   bool              CalculateSize(const string symbol, const double stopLossPips, 
                                 const double riskPercent, const double accountEquity, 
                                 double &size);
   
   // Update methods
   void              UpdateVolatility(const double volatility);
   void              UpdateCorrelation(const double correlation);
   
   // Getters
   double            GetVolatilityFactor() const { return m_volatilityFactor; }
   double            GetCorrelationFactor() const { return m_correlationFactor; }
   bool              IsInitialized() const { return m_isInitialized; }
};

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CPositionSizer::CPositionSizer() : 
   m_params(NULL),
   m_metrics(NULL),
   m_volatilityFactor(1.0),
   m_correlationFactor(1.0),
   m_isInitialized(false)
{
}

//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CPositionSizer::~CPositionSizer()
{
   Deinitialize();
}

//+------------------------------------------------------------------+
//| Initialize position sizer                                        |
//+------------------------------------------------------------------+
bool CPositionSizer::Initialize(CRiskParameters* params = NULL, CRiskMetrics* metrics = NULL)
{
   m_params = params;
   m_metrics = metrics;
   m_volatilityFactor = 1.0;
   m_correlationFactor = 1.0;
   
   m_isInitialized = true;
   return true;
}

//+------------------------------------------------------------------+
//| Deinitialize position sizer                                      |
//+------------------------------------------------------------------+
void CPositionSizer::Deinitialize()
{
   m_params = NULL;
   m_metrics = NULL;
   m_isInitialized = false;
}

//+------------------------------------------------------------------+
//| Calculate position size                                          |
//+------------------------------------------------------------------+
bool CPositionSizer::CalculateSize(const string symbol, const double stopLossPips, 
                                 const double riskPercent, const double accountEquity, 
                                 double &size)
{
   if (!m_isInitialized || stopLossPips <= 0.0 || riskPercent <= 0.0 || accountEquity <= 0.0)
      return false;
      
   // Calculate base position size based on risk percentage
   double baseSize = CalculateBasePositionSize(symbol, stopLossPips, riskPercent, accountEquity);
   if (baseSize <= 0.0)
      return false;
      
   // Apply adjustments
   double adjustedSize = baseSize;
   
   // Apply volatility adjustment if metrics are available
   if (m_metrics != NULL)
   {
      adjustedSize = ApplyVolatilityAdjustment(symbol, adjustedSize);
   }
   
   // Apply correlation adjustment if metrics are available
   if (m_metrics != NULL)
   {
      adjustedSize = ApplyCorrelationAdjustment(symbol, adjustedSize);
   }
   
   // Apply leverage adjustment
   adjustedSize = ApplyLeverageAdjustment(adjustedSize);
   
   // Apply lot step rounding
   adjustedSize = ApplyLotStepRounding(symbol, adjustedSize);
   
   // Ensure size is within allowed limits
   if (m_params != NULL)
   {
      adjustedSize = MathMin(adjustedSize, m_params.GetMaxLotsPerTrade());
      adjustedSize = MathMax(adjustedSize, m_params.GetMinPositionSize());
   }
   
   size = adjustedSize;
   return (size > 0.0);
}

//+------------------------------------------------------------------+
//| Calculate base position size based on risk percentage            |
//+------------------------------------------------------------------+
double CPositionSizer::CalculateBasePositionSize(const string symbol, const double stopLossPips, 
                                               const double riskPercent, const double accountEquity)
{
   // Get symbol information
   double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
   double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
   double lotSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_CONTRACT_SIZE);
   double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
   
   if (tickSize <= 0.0 || tickValue <= 0.0 || lotSize <= 0.0 || point <= 0.0)
      return 0.0;
      
   // Calculate pip value (accounting for 5-digit brokers)
   double pipValue = point * 10.0;
   
   // Calculate value per pip
   double valuePerPip = (tickValue / tickSize) * pipValue;
   
   // Calculate risk amount in account currency
   double riskAmount = accountEquity * (riskPercent / 100.0);
   
   // Calculate position size in lots
   double stopLossValue = stopLossPips * valuePerPip;
   if (stopLossValue <= 0.0)
      return 0.0;
      
   double positionSize = riskAmount / stopLossValue;
   
   // Convert to lots
   double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
   if (lotStep > 0.0)
   {
      positionSize = MathFloor(positionSize / lotStep) * lotStep;
   }
   
   return positionSize;
}

//+------------------------------------------------------------------+
//| Apply volatility adjustment to position size                     |
//+------------------------------------------------------------------
double CPositionSizer::ApplyVolatilityAdjustment(const string symbol, const double size)
{
   if (m_metrics == NULL || !m_params.UseVolatility())
      return size;
      
   double currentVol = m_metrics.GetCurrentVolatility();
   double historicalVol = m_metrics.GetHistoricalVolatility();
   
   // If we don't have valid volatility data, return original size
   if (currentVol <= 0.0 || historicalVol <= 0.0)
      return size;
      
   // Calculate volatility ratio (current / historical)
   double volRatio = currentVol / historicalVol;
   
   // Apply inverse relationship: higher volatility = smaller position
   // Cap the adjustment to avoid extreme position sizing
   volRatio = MathMax(0.5, MathMin(2.0, 1.0 / volRatio));
   
   // Apply volatility factor from parameters
   if (m_params != NULL)
   {
      volRatio *= m_params.GetVolatilityFactor();
   }
   
   m_volatilityFactor = volRatio;
   return size * volRatio;
}

//+------------------------------------------------------------------+
//| Apply correlation adjustment to position size                    |
//+------------------------------------------------------------------
double CPositionSizer::ApplyCorrelationAdjustment(const string symbol, const double size)
{
   if (m_metrics == NULL || !m_params.UseCorrelation())
      return size;
      
   // This is a simplified implementation
   // In practice, you would check correlation with existing positions
   
   // For now, we'll just return the original size
   // A full implementation would use the correlation matrix
   
   return size;
}

//+------------------------------------------------------------------+
//| Apply leverage adjustment to position size                       |
//+------------------------------------------------------------------
double CPositionSizer::ApplyLeverageAdjustment(const double size)
{
   if (m_params == NULL)
      return size;
      
   double maxLeverage = m_params.GetMaxLeverage();
   double accountLeverage = (double)AccountInfoInteger(ACCOUNT_LEVERAGE);
   
   if (maxLeverage <= 0.0 || accountLeverage <= 0.0)
      return size;
      
   // Adjust position size based on leverage
   double leverageRatio = MathMin(1.0, maxLeverage / accountLeverage);
   return size * leverageRatio;
}

//+------------------------------------------------------------------+
//| Apply lot step rounding                                          |
//+------------------------------------------------------------------
double CPositionSizer::ApplyLotStepRounding(const string symbol, const double size)
{
   double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
   double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
   
   if (lotStep <= 0.0)
      return size;
      
   // Round to nearest lot step
   double roundedSize = MathFloor(size / lotStep + 0.5) * lotStep;
   
   // Ensure within min/max limits
   if (minLot > 0.0)
      roundedSize = MathMax(roundedSize, minLot);
      
   if (maxLot > 0.0)
      roundedSize = MathMin(roundedSize, maxLot);
      
   return roundedSize;
}

//+------------------------------------------------------------------+
//| Update volatility factor                                         |
//+------------------------------------------------------------------
void CPositionSizer::UpdateVolatility(const double volatility)
{
   if (volatility > 0.0)
   {
      // Store the inverse of volatility (higher volatility = smaller position)
      m_volatilityFactor = 1.0 / (1.0 + volatility);
   }
}

//+------------------------------------------------------------------+
//| Update correlation factor                                        |
//+------------------------------------------------------------------
void CPositionSizer::UpdateCorrelation(const double correlation)
{
   // Store the inverse of correlation (higher correlation = smaller position)
   m_correlationFactor = 1.0 - (0.5 * correlation);
}