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

#include <Escape/Common/ErrorHandler.mqh>

//+------------------------------------------------------------------+
//| Volatility Calculation Methods                                   |
//+------------------------------------------------------------------+
enum ENUM_VOLATILITY_METHOD
  {
   VOL_ATR,         // Average True Range
   VOL_STD_DEV,     // Standard Deviation
   VOL_PARKINSON,   // Parkinson's volatility
   VOL_GK,          // Garman-Klass volatility
   VOL_RS,          // Rogers-Satchell volatility
   VOL_YZ           // Yang-Zhang volatility
  };

//+------------------------------------------------------------------+
//| Volatility Manager Class                                         |
//+------------------------------------------------------------------+
class CVolatilityManager
  {
private:
   // Configuration
   ENUM_TIMEFRAMES   m_timeframe;     // Default timeframe for calculations
   int               m_period;        // Default period for calculations
   ENUM_VOLATILITY_METHOD m_method;   // Default calculation method
   
   // State
   bool              m_initialized;   // Initialization flag
   
   // Cache
   double            m_lastValues[];  // Cache of last calculated values
   datetime          m_lastUpdate;    // Last update time
   
public:
   //--- Constructor/Destructor
                     CVolatilityManager(void);
                    ~CVolatilityManager(void);
   
   //--- Initialization
   bool              Initialize(void);
   void              Shutdown(void);
   
   //--- Volatility Calculation
   double            GetVolatility(const string symbol, const ENUM_TIMEFRAMES timeframe, const int period,
                                 const ENUM_VOLATILITY_METHOD method, const int shift=0);
   
   double            GetCurrentVolatility(const string symbol, const ENUM_TIMEFRAMES timeframe, 
                                       const int period, const ENUM_VOLATILITY_METHOD method);
   
   double            GetAverageVolatility(const string symbol, const ENUM_TIMEFRAMES timeframe, 
                                        const int period, const int bars, const ENUM_VOLATILITY_METHOD method);
   
   //--- Configuration
   void              SetDefaultTimeframe(const ENUM_TIMEFRAMES timeframe) { m_timeframe = timeframe; }
   void              SetDefaultPeriod(const int period) { m_period = period; }
   void              SetDefaultMethod(const ENUM_VOLATILITY_METHOD method) { m_method = method; }
   
private:
   //--- Calculation Methods
   double            CalculateATR(const string symbol, const int period, const int shift);
   double            CalculateStdDev(const string symbol, const int period, const int shift);
   double            CalculateParkinson(const string symbol, const int period, const int shift);
   double            CalculateGarmanKlass(const string symbol, const int period, const int shift);
   double            CalculateRogersSatchell(const string symbol, const int period, const int shift);
   double            CalculateYangZhang(const string symbol, const int period, const int shift);
   
   //--- Helper Methods
   void              UpdateCache(const string symbol, const ENUM_TIMEFRAMES timeframe, 
                               const int period, const ENUM_VOLATILITY_METHOD method);
   string            GenerateCacheKey(const string symbol, const ENUM_TIMEFRAMES timeframe, 
                                   const int period, const ENUM_VOLATILITY_METHOD method) const;
   double            GetCachedValue(const string key);
   void              SetCachedValue(const string key, const double value);
  };

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CVolatilityManager::CVolatilityManager(void) :
   m_timeframe(PERIOD_CURRENT),
   m_period(14),
   m_method(VOL_ATR),
   m_initialized(false),
   m_lastUpdate(0)
  {
   ArrayResize(m_lastValues, 0);
  }

//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CVolatilityManager::~CVolatilityManager(void)
  {
   Shutdown();
  }

//+------------------------------------------------------------------+
//| Initialize the volatility manager                                |
//+------------------------------------------------------------------+
bool CVolatilityManager::Initialize(void)
  {
   if(m_initialized)
      return true;
      
   // Initialize any required resources
   m_initialized = true;
   return true;
  }

//+------------------------------------------------------------------+
//| Shutdown the volatility manager                                  |
//+------------------------------------------------------------------+
void CVolatilityManager::Shutdown(void)
  {
   if(!m_initialized)
      return;
      
   // Clean up resources
   ArrayFree(m_lastValues);
   m_initialized = false;
  }

//+------------------------------------------------------------------+
//| Get volatility using specified parameters                        |
//+------------------------------------------------------------------+
double CVolatilityManager::GetVolatility(const string symbol, const ENUM_TIMEFRAMES timeframe, 
                                       const int period, const ENUM_VOLATILITY_METHOD method, const int shift)
  {
   // Check for valid parameters
   if(period <= 0)
     {
      CErrorHandler::HandleError(ERR_INVALID_PARAMETER, "Invalid period: " + IntegerToString(period));
      return 0.0;
     }
     
   // Use default values if not specified
   ENUM_TIMEFRAMES tf = (timeframe == PERIOD_CURRENT) ? m_timeframe : timeframe;
   int p = (period <= 0) ? m_period : period;
   ENUM_VOLATILITY_METHOD m = (method == -1) ? m_method : method;
   
   // Calculate volatility based on selected method
   double volatility = 0.0;
   switch(m)
     {
      case VOL_ATR:
         volatility = CalculateATR(symbol, p, shift);
         break;
         
      case VOL_STD_DEV:
         volatility = CalculateStdDev(symbol, p, shift);
         break;
         
      case VOL_PARKINSON:
         volatility = CalculateParkinson(symbol, p, shift);
         break;
         
      case VOL_GK:
         volatility = CalculateGarmanKlass(symbol, p, shift);
         break;
         
      case VOL_RS:
         volatility = CalculateRogersSatchell(symbol, p, shift);
         break;
         
      case VOL_YZ:
         volatility = CalculateYangZhang(symbol, p, shift);
         break;
         
      default:
         CErrorHandler::HandleError(ERR_INVALID_PARAMETER, "Unknown volatility method: " + IntegerToString(m));
         break;
     }
     
   return volatility;
  }

//+------------------------------------------------------------------+
//| Get current volatility                                           |
//+------------------------------------------------------------------+
double CVolatilityManager::GetCurrentVolatility(const string symbol, const ENUM_TIMEFRAMES timeframe, 
                                             const int period, const ENUM_VOLATILITY_METHOD method)
  {
   return GetVolatility(symbol, timeframe, period, method, 0);
  }

//+------------------------------------------------------------------+
//| Get average volatility over a number of bars                     |
//+------------------------------------------------------------------+
double CVolatilityManager::GetAverageVolatility(const string symbol, const ENUM_TIMEFRAMES timeframe, 
                                             const int period, const int bars, const ENUM_VOLATILITY_METHOD method)
  {
   if(bars <= 0)
     {
      CErrorHandler::HandleError(ERR_INVALID_PARAMETER, "Invalid number of bars: " + IntegerToString(bars));
      return 0.0;
     }
     
   double sum = 0.0;
   int count = 0;
   
   // Calculate average volatility over the specified number of bars
   for(int i = 0; i < bars; i++)
     {
      double vol = GetVolatility(symbol, timeframe, period, method, i);
      if(vol > 0)
        {
         sum += vol;
         count++;
        }
     }
     
   return (count > 0) ? sum / count : 0.0;
  }

//+------------------------------------------------------------------+
//| Calculate Average True Range (ATR)                               |
//+------------------------------------------------------------------+
double CVolatilityManager::CalculateATR(const string symbol, const int period, const int shift)
  {
   double atr = iATR(symbol, m_timeframe, period, shift);
   if(atr == 0)
     {
      CErrorHandler::HandleError(ERR_INDICATOR_CALCULATION, "Failed to calculate ATR for " + symbol);
      return 0.0;
     }
     
   return atr;
  }

//+------------------------------------------------------------------+
//| Calculate Standard Deviation                                     |
//+------------------------------------------------------------------+
double CVolatilityManager::CalculateStdDev(const string symbol, const int period, const int shift)
  {
   double close[];
   ArraySetAsSeries(close, true);
   
   // Get close prices
   if(CopyClose(symbol, m_timeframe, shift, period, close) != period)
     {
      CErrorHandler::HandleError(ERR_HISTORY_NOT_FOUND, "Failed to get close prices for " + symbol);
      return 0.0;
     }
     
   // Calculate mean
   double sum = 0.0;
   for(int i = 0; i < period; i++)
      sum += close[i];
   double mean = sum / period;
   
   // Calculate variance
   double variance = 0.0;
   for(int i = 0; i < period; i++)
      variance += MathPow(close[i] - mean, 2);
   variance /= period;
   
   // Standard deviation is the square root of variance
   return MathSqrt(variance);
  }

//+------------------------------------------------------------------+
//| Calculate Parkinson Volatility                                   |
//+------------------------------------------------------------------+
double CVolatilityManager::CalculateParkinson(const string symbol, const int period, const int shift)
  {
   double high[], low[];
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   
   // Get high and low prices
   if(CopyHigh(symbol, m_timeframe, shift, period, high) != period ||
      CopyLow(symbol, m_timeframe, shift, period, low) != period)
     {
      CErrorHandler::HandleError(ERR_HISTORY_NOT_FOUND, "Failed to get price data for Parkinson");
      return 0.0;
     }
     
   // Calculate Parkinson volatility
   double sum = 0.0;
   for(int i = 0; i < period; i++)
     {
      if(high[i] > 0 && low[i] > 0)
         sum += MathLog(high[i] / low[i]) * MathLog(high[i] / low[i]);
     }
     
   return MathSqrt(sum / (4 * period * MathLog(2)));
  }

//+------------------------------------------------------------------+
//| Calculate Garman-Klass Volatility                                |
//+------------------------------------------------------------------+
double CVolatilityManager::CalculateGarmanKlass(const string symbol, const int period, const int shift)
  {
   double open[], high[], low[], close[];
   ArraySetAsSeries(open, true);
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);
   
   // Get price data
   if(CopyOpen(symbol, m_timeframe, shift, period, open) != period ||
      CopyHigh(symbol, m_timeframe, shift, period, high) != period ||
      CopyLow(symbol, m_timeframe, shift, period, low) != period ||
      CopyClose(symbol, m_timeframe, shift, period, close) != period)
     {
      CErrorHandler::HandleError(ERR_HISTORY_NOT_FOUND, "Failed to get price data for Garman-Klass");
      return 0.0;
     }
     
   // Calculate Garman-Klass volatility
   double sum = 0.0;
   for(int i = 0; i < period; i++)
     {
      if(open[i] > 0 && high[i] > 0 && low[i] > 0 && close[i] > 0)
        {
         double u = MathLog(high[i] / open[i]);
         double d = MathLog(low[i] / open[i]);
         double c = MathLog(close[i] / open[i]);
         sum += 0.511 * (u - d) * (u - d) - 0.019 * (c * (u + d) - 2 * u * d) - 0.383 * c * c;
        }
     }
     
   return MathSqrt(sum / period);
  }

//+------------------------------------------------------------------+
//| Calculate Rogers-Satchell Volatility                             |
//+------------------------------------------------------------------+
double CVolatilityManager::CalculateRogersSatchell(const string symbol, const int period, const int shift)
  {
   double open[], high[], low[], close[];
   ArraySetAsSeries(open, true);
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);
   
   // Get price data
   if(CopyOpen(symbol, m_timeframe, shift, period, open) != period ||
      CopyHigh(symbol, m_timeframe, shift, period, high) != period ||
      CopyLow(symbol, m_timeframe, shift, period, low) != period ||
      CopyClose(symbol, m_timeframe, shift, period, close) != period)
     {
      CErrorHandler::HandleError(ERR_HISTORY_NOT_FOUND, "Failed to get price data for Rogers-Satchell");
      return 0.0;
     }
     
   // Calculate Rogers-Satchell volatility
   double sum = 0.0;
   for(int i = 0; i < period; i++)
     {
      if(open[i] > 0 && high[i] > 0 && low[i] > 0 && close[i] > 0)
        {
         double u = MathLog(high[i] / open[i]);
         double d = MathLog(low[i] / open[i]);
         double c = MathLog(close[i] / open[i]);
         sum += u * (u - c) + d * (d - c);
        }
     }
     
   return MathSqrt(sum / period);
  }

//+------------------------------------------------------------------+
//| Calculate Yang-Zhang Volatility                                  |
//+------------------------------------------------------------------+
double CVolatilityManager::CalculateYangZhang(const string symbol, const int period, const int shift)
  {
   double open[], close[];
   ArraySetAsSeries(open, true);
   ArraySetAsSeries(close, true);
   
   // Get open and close prices
   if(CopyOpen(symbol, m_timeframe, shift, period, open) != period ||
      CopyClose(symbol, m_timeframe, shift-1, period+1, close) != period+1)
     {
      CErrorHandler::HandleError(ERR_HISTORY_NOT_FOUND, "Failed to get price data for Yang-Zhang");
      return 0.0;
     }
     
   // Calculate Yang-Zhang volatility
   double sum_var = 0.0;
   double sum_mean = 0.0;
   
   for(int i = 0; i < period; i++)
     {
      if(open[i] > 0 && close[i] > 0 && close[i+1] > 0)
        {
         double o = MathLog(open[i] / close[i+1]);
         double c = MathLog(close[i] / open[i]);
         double u = MathLog(high[i] / open[i]);
         double d = MathLog(low[i] / open[i]);
         
         double rs = u * (u - c) + d * (d - c);
         double o_c = o * o;
         double c_c = c * c;
         
         sum_var += 0.511 * rs - 0.019 * (c * (u + d) - 2 * u * d) - 0.383 * c_c;
         sum_mean += o_c;
        }
     }
     
   double k = 0.34 / (1.34 + (period + 1) / (period - 1));
   return MathSqrt(sum_var / period + k * sum_mean / (period - 1));
  }

//+------------------------------------------------------------------+
//| Update the cache with latest values                              |
//+------------------------------------------------------------------+
void CVolatilityManager::UpdateCache(const string symbol, const ENUM_TIMEFRAMES timeframe, 
                                   const int period, const ENUM_VOLATILITY_METHOD method)
  {
   // Implementation for caching would go here
   // This is a placeholder for actual caching logic
  }

//+------------------------------------------------------------------+
//| Generate a cache key                                             |
//+------------------------------------------------------------------+
string CVolatilityManager::GenerateCacheKey(const string symbol, const ENUM_TIMEFRAMES timeframe, 
                                         const int period, const ENUM_VOLATILITY_METHOD method) const
  {
   return symbol + "_" + IntegerToString(timeframe) + "_" + IntegerToString(period) + "_" + IntegerToString(method);
  }

//+------------------------------------------------------------------+
//| Get a value from cache                                           |
//+------------------------------------------------------------------+
double CVolatilityManager::GetCachedValue(const string key)
  {
   // Implementation for getting cached values would go here
   // This is a placeholder for actual caching logic
   return 0.0;
  }

//+------------------------------------------------------------------+
//| Set a value in cache                                             |
//+------------------------------------------------------------------+
void CVolatilityManager::SetCachedValue(const string key, const double value)
  {
   // Implementation for setting cached values would go here
   // This is a placeholder for actual caching logic
  }
//+------------------------------------------------------------------+