//+------------------------------------------------------------------+
//|                                          CorrelationMatrix.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 <Arrays\ArrayObj.mqh>
#include <Math\Stat\Math.mqh>

// Forward declaration
class CCorrelationMatrix;

//+------------------------------------------------------------------+
//| Correlation Pair Structure                                       |
//+------------------------------------------------------------------+
struct SCorrelationPair
{
   string         symbol1;       // First symbol
   string         symbol2;       // Second symbol
   double         correlation;    // Correlation coefficient (-1 to 1)
   int            period;         // Lookback period (bars)
   ENUM_TIMEFRAME timeframe;      // Timeframe for calculation
   datetime       lastUpdate;     // Last update time
   
   // Constructor
   SCorrelationPair() : symbol1(""), symbol2(""), correlation(0.0), 
                       period(0), timeframe(PERIOD_CURRENT), lastUpdate(0) {}
   
   SCorrelationPair(string s1, string s2, int p, ENUM_TIMEFRAME tf) : 
      symbol1(s1), symbol2(s2), correlation(0.0), period(p), timeframe(tf), lastUpdate(0) {}
   
   // Comparison operator
   bool operator==(const SCorrelationPair &other) const
   {
      return ((symbol1 == other.symbol1 && symbol2 == other.symbol2) ||
              (symbol1 == other.symbol2 && symbol2 == other.symbol1)) &&
              period == other.period && timeframe == other.timeframe;
   }
};

//+------------------------------------------------------------------+
//| Correlation Matrix Class                                         |
//+------------------------------------------------------------------+
class CCorrelationMatrix
{
private:
   CArrayObj*        m_pairs;           // Array of correlation pairs
   string            m_symbols[];       // Array of symbols being tracked
   int               m_lookback;        // Default lookback period (bars)
   ENUM_TIMEFRAME    m_timeframe;       // Default timeframe
   double            m_minCorrelation;  // Minimum correlation to track
   bool              m_isInitialized;   // Initialization flag
   
   // Private methods
   bool              CalculateCorrelation(SCorrelationPair &pair);
   int               FindPair(const string symbol1, const string symbol2) const;
   bool              UpdateSymbolList();
   
public:
   // Constructor/Destructor
                     CCorrelationMatrix();
                    ~CCorrelationMatrix();
   
   // Initialization
   bool              Initialize(const int lookback = 100, 
                              const ENUM_TIMEFRAME timeframe = PERIOD_CURRENT,
                              const double minCorrelation = 0.5);
   void              Deinitialize();
   
   // Update methods
   bool              Update();
   bool              UpdatePair(const string symbol1, const string symbol2);
   
   // Correlation access
   double            GetCorrelation(const string symbol1, const string symbol2);
   bool              GetCorrelationMatrix(const string &symbols[], double &matrix[][]);
   
   // Risk management
   bool              ValidateNewPosition(const string symbol, const ENUM_ORDER_TYPE type,
                                       const double price, const double size);
   
   // Getters
   int               GetSymbolCount() const { return ArraySize(m_symbols); }
   int               GetPairCount() const { return (m_pairs != NULL) ? m_pairs.Total() : 0; }
   bool              IsInitialized() const { return m_isInitialized; }
   
   // Configuration
   bool              SetLookback(const int lookback);
   bool              SetTimeframe(const ENUM_TIMEFRAME timeframe);
   void              SetMinCorrelation(const double minCorrelation) { m_minCorrelation = minCorrelation; }
   
   // Utility
   static double     CalculateCorrelation(const double &x[], const double &y[], const int count);
};

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CCorrelationMatrix::CCorrelationMatrix() :
   m_pairs(NULL),
   m_lookback(100),
   m_timeframe(PERIOD_CURRENT),
   m_minCorrelation(0.5),
   m_isInitialized(false)
{
   ArrayResize(m_symbols, 0);
}

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

//+------------------------------------------------------------------+
//| Initialize correlation matrix                                    |
//+------------------------------------------------------------------+
bool CCorrelationMatrix::Initialize(const int lookback, const ENUM_TIMEFRAME timeframe,
                                  const double minCorrelation)
{
   if (m_isInitialized)
      return true;
      
   if (lookback <= 0 || minCorrelation < 0.0 || minCorrelation > 1.0)
      return false;
      
   m_pairs = new CArrayObj();
   if (m_pairs == NULL)
      return false;
      
   m_lookback = lookback;
   m_timeframe = timeframe;
   m_minCorrelation = minCorrelation;
   
   // Update symbol list
   if (!UpdateSymbolList())
   {
      Print("Failed to update symbol list");
      return false;
   }
   
   m_isInitialized = true;
   return true;
}

//+------------------------------------------------------------------+
//| Deinitialize correlation matrix                                  |
//+------------------------------------------------------------------+
void CCorrelationMatrix::Deinitialize()
{
   if (m_pairs != NULL)
   {
      m_pairs.Clear();
      delete m_pairs;
      m_pairs = NULL;
   }
   
   ArrayFree(m_symbols);
   m_isInitialized = false;
}

//+------------------------------------------------------------------+
//| Update all correlation pairs                                     |
//+------------------------------------------------------------------+
bool CCorrelationMatrix::Update()
{
   if (!m_isInitialized)
      return false;
      
   // Update symbol list first
   if (!UpdateSymbolList())
      return false;
      
   int symbolCount = ArraySize(m_symbols);
   if (symbolCount < 2)
      return false;
      
   // Update all pairs
   bool success = true;
   for (int i = 0; i < symbolCount - 1; i++)
   {
      for (int j = i + 1; j < symbolCount; j++)
      {
         if (!UpdatePair(m_symbols[i], m_symbols[j]))
            success = false;
      }
   }
   
   return success;
}

//+------------------------------------------------------------------+
//| Update correlation for a specific pair                           |
//+------------------------------------------------------------------+
bool CCorrelationMatrix::UpdatePair(const string symbol1, const string symbol2)
{
   if (!m_isInitialized || symbol1 == "" || symbol2 == "" || symbol1 == symbol2)
      return false;
      
   // Find or create the correlation pair
   int pairIndex = FindPair(symbol1, symbol2);
   SCorrelationPair* pair = NULL;
   
   if (pairIndex >= 0)
   {
      pair = (SCorrelationPair*)m_pairs.At(pairIndex);
   }
   else
   {
      pair = new SCorrelationPair(symbol1, symbol2, m_lookback, m_timeframe);
      if (pair == NULL)
         return false;
         
      m_pairs.Add(pair);
   }
   
   // Calculate correlation
   return CalculateCorrelation(*pair);
}

//+------------------------------------------------------------------+
//| Calculate correlation for a pair                                 |
//+------------------------------------------------------------------+
bool CCorrelationMatrix::CalculateCorrelation(SCorrelationPair &pair)
{
   if (pair.symbol1 == "" || pair.symbol2 == "" || pair.period <= 0)
      return false;
      
   // Get close prices for both symbols
   double close1[], close2[];
   int count = pair.period;
   
   if (CopyClose(pair.symbol1, pair.timeframe, 0, count, close1) != count ||
       CopyClose(pair.symbol2, pair.timeframe, 0, count, close2) != count)
   {
      Print("Failed to get price data for correlation calculation");
      return false;
   }
   
   // Calculate returns
   double returns1[], returns2[];
   ArrayResize(returns1, count-1);
   ArrayResize(returns2, count-1);
   
   for (int i = 0; i < count-1; i++)
   {
      if (close1[i+1] > 0.0 && close2[i+1] > 0.0)
      {
         returns1[i] = (close1[i] - close1[i+1]) / close1[i+1];
         returns2[i] = (close2[i] - close2[i+1]) / close2[i+1];
      }
      else
      {
         returns1[i] = 0.0;
         returns2[i] = 0.0;
      }
   }
   
   // Calculate correlation
   pair.correlation = CalculateCorrelation(returns1, returns2, count-1);
   pair.lastUpdate = TimeCurrent();
   
   return true;
}

//+------------------------------------------------------------------+
//| Find correlation pair in the list                                |
//+------------------------------------------------------------------+
int CCorrelationMatrix::FindPair(const string symbol1, const string symbol2) const
{
   if (!m_isInitialized || m_pairs == NULL)
      return -1;
      
   SCorrelationPair tempPair(symbol1, symbol2, m_lookback, m_timeframe);
   
   for (int i = 0; i < m_pairs.Total(); i++)
   {
      SCorrelationPair* pair = (SCorrelationPair*)m_pairs.At(i);
      if (pair != NULL && *pair == tempPair)
         return i;
   }
   
   return -1;
}

//+------------------------------------------------------------------+
//| Update the list of symbols being tracked                         |
//+------------------------------------------------------------------+
bool CCorrelationMatrix::UpdateSymbolList()
{
   // This is a simplified implementation
   // In practice, you might want to get symbols from market watch or a predefined list
   
   // For now, we'll just use a few major currency pairs
   string defaultSymbols[] = {"EURUSD", "GBPUSD", "USDJPY", "AUDUSD", "USDCAD", "USDCHF", "NZDUSD"};
   
   // Check which symbols are available
   string availableSymbols[];
   int count = 0;
   
   for (int i = 0; i < ArraySize(defaultSymbols); i++)
   {
      if (SymbolSelect(defaultSymbols[i], true))
      {
         count++;
         ArrayResize(availableSymbols, count);
         availableSymbols[count-1] = defaultSymbols[i];
      }
   }
   
   // Update symbols array
   if (count > 0)
   {
      ArrayCopy(m_symbols, availableSymbols);
      return true;
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| Get correlation between two symbols                              |
//+------------------------------------------------------------------+
double CCorrelationMatrix::GetCorrelation(const string symbol1, const string symbol2)
{
   if (!m_isInitialized || symbol1 == "" || symbol2 == "" || symbol1 == symbol2)
      return 0.0;
      
   int pairIndex = FindPair(symbol1, symbol2);
   if (pairIndex >= 0)
   {
      SCorrelationPair* pair = (SCorrelationPair*)m_pairs.At(pairIndex);
      if (pair != NULL)
         return pair.correlation;
   }
   
   // If pair not found, try to calculate it
   if (UpdatePair(symbol1, symbol2))
   {
      pairIndex = FindPair(symbol1, symbol2);
      if (pairIndex >= 0)
      {
         SCorrelationPair* pair = (SCorrelationPair*)m_pairs.At(pairIndex);
         if (pair != NULL)
            return pair.correlation;
      }
   }
   
   return 0.0;
}

//+------------------------------------------------------------------+
//| Get full correlation matrix                                      |
//+------------------------------------------------------------------+
bool CCorrelationMatrix::GetCorrelationMatrix(const string &symbols[], double &matrix[][])
{
   if (!m_isInitialized || ArraySize(symbols) < 2)
      return false;
      
   int size = ArraySize(symbols);
   ArrayResize(matrix, size);
   
   for (int i = 0; i < size; i++)
   {
      ArrayResize(matrix[i], size);
      matrix[i][i] = 1.0; // Correlation with self is 1
      
      for (int j = i + 1; j < size; j++)
      {
         double corr = GetCorrelation(symbols[i], symbols[j]);
         matrix[i][j] = corr;
         matrix[j][i] = corr; // Matrix is symmetric
      }
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Validate if a new position would exceed correlation limits       |
//+------------------------------------------------------------------+
bool CCorrelationMatrix::ValidateNewPosition(const string symbol, const ENUM_ORDER_TYPE type,
                                           const double price, const double size)
{
   if (!m_isInitialized || symbol == "" || size <= 0.0)
      return false;
      
   // This is a simplified implementation
   // In practice, you would check correlation with all existing positions
   
   return true; // Placeholder
}

//+------------------------------------------------------------------+
//| Set lookback period for correlation calculation                  |
//+------------------------------------------------------------------+
bool CCorrelationMatrix::SetLookback(const int lookback)
{
   if (lookback <= 0)
      return false;
      
   m_lookback = lookback;
   
   // Update all pairs
   if (m_pairs != NULL)
   {
      for (int i = 0; i < m_pairs.Total(); i++)
      {
         SCorrelationPair* pair = (SCorrelationPair*)m_pairs.At(i);
         if (pair != NULL)
            pair.period = lookback;
      }
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Set timeframe for correlation calculation                        |
//+------------------------------------------------------------------+
bool CCorrelationMatrix::SetTimeframe(const ENUM_TIMEFRAME timeframe)
{
   m_timeframe = timeframe;
   
   // Update all pairs
   if (m_pairs != NULL)
   {
      for (int i = 0; i < m_pairs.Total(); i++)
      {
         SCorrelationPair* pair = (SCorrelationPair*)m_pairs.At(i);
         if (pair != NULL)
            pair.timeframe = timeframe;
      }
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Static method to calculate correlation between two arrays        |
//+------------------------------------------------------------------+
double CCorrelationMatrix::CalculateCorrelation(const double &x[], const double &y[], const int count)
{
   if (count <= 1)
      return 0.0;
      
   double sumX = 0.0, sumY = 0.0;
   double sumXSq = 0.0, sumYSq = 0.0;
   double sumXY = 0.0;
   
   for (int i = 0; i < count; i++)
   {
      sumX += x[i];
      sumY += y[i];
      sumXSq += x[i] * x[i];
      sumYSq += y[i] * y[i];
      sumXY += x[i] * y[i];
   }
   
   double numerator = sumXY - (sumX * sumY / count);
   double denominator = MathSqrt((sumXSq - (sumX * sumX / count)) * (sumYSq - (sumY * sumY / count)));
   
   if (denominator == 0.0)
      return 0.0;
      
   return numerator / denominator;
}