//+------------------------------------------------------------------+
//|                                                   GrangerMTF.mq5 |
//|                                  Copyright 2025, MetaQuotes Ltd. |
//|                     https://www.mql5.com/en/users/johnhlomohang/ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/en/users/johnhlomohang/"
#property version   "1.00"

#include <Trade\Trade.mqh>
#include <Math\Stat\F.mqh>

#define GC_SCALE   10000.0      // returns in basis points (must match SCALE in the notebook)
#define GC_PREFIX  "GCM_"

enum ENUM_STATUS_SOURCE
  {
   STATUS_OFFLINE = 0,          // Offline (Jupyter table only)
   STATUS_LIVE    = 1,          // Live (rolling test in MQL5 only)
   STATUS_BOTH    = 2           // Both must agree
  };

//--- inputs
input group "=== Causality Source ==="
input string             InpCausalityFile   = "granger_mtf_causality.csv"; // Calibration file from Jupyter
input bool               InpUseCommonFolder = true;                        // Read from Common\Files
input ENUM_STATUS_SOURCE InpStatusSource    = STATUS_BOTH;                 // How VALID is decided
input int                InpRetestBars      = 12;                          // Re-run live F-test every N lag-TF bars
input string             InpFallbackPairs   = "M30>M15,H1>M15,M15>M5,H1>M5"; // Pairs if file is missing
input int                InpFallbackP       = 1;                           // Fallback lead lags
input int                InpFallbackQ       = 2;                           // Fallback own lags
input int                InpFallbackWindow  = 1500;                        // Fallback window (bars)
input double             InpFallbackAlpha   = 0.05;                        // Fallback alpha

input group "=== Signal Generator ==="
input ENUM_TIMEFRAMES    InpSignalTF           = PERIOD_M5; // Signal evaluation timeframe
input bool               InpUseCausalityFilter = true;      // Only VALID pairs may vote
input double             InpMinEdgeSigma       = 0.05;      // Min |forecast| as a fraction of return std
input int                InpMinVotes           = 1;         // Min agreeing votes (with zero opposition)
input bool               InpShowSignals        = true;      // Display signals (panel + chart arrows)
input bool               InpAlertOnSignal      = false;     // Pop-up alert on a new signal

input group "=== Execution ==="
input bool               InpExecuteTrades   = true;   // Trade the internal signals
input double             InpLots            = 0.01;   // Lot size
input int                InpATRPeriod       = 14;     // ATR period (signal TF)
input double             InpSL_ATR          = 1.5;    // Stop loss (x ATR)
input double             InpTP_ATR          = 2.0;    // Take profit (x ATR)
input bool               InpCloseOnOpposite = true;   // Close on an opposite signal
input ulong              InpMagic           = 110011; // Magic number

input group "=== Panel ==="
input bool               InpShowPanel = true;  // Show the causality panel
input int                InpPanelX    = 15;    // Panel X offset
input int                InpPanelY    = 25;    // Panel Y offset
input int                InpFontSize  = 9;     // Panel font size

//--- one lead -> lag relationship
struct SCausalPair
  {
   ENUM_TIMEFRAMES   lead;
   ENUM_TIMEFRAMES   lag;
   string            leadName;
   string            lagName;
   int               p;              // lags of the lead TF (completed lead bars)
   int               q;              // own lags of the lag TF
   int               window;         // rolling window (lag-TF bars)
   double            alpha;
   //--- offline (Jupyter) results
   bool              hasOffline;
   bool              offlineValid;
   double            offlineF;
   double            offlineP;
   double            stability;
   //--- live results
   bool              liveReady;
   double            liveF;
   double            liveP;
   double            beta[];         // unrestricted model: [const, y lags, x lags]
   double            sigmaY;
   datetime          lastLagBar;
   int               barsSinceTest;
   //--- signal state
   double            pred;           // forecast of the current lag-TF bar return (bps)
   int               vote;           // +1 / -1 / 0
   bool              valid;
  };

//--- globals
SCausalPair g_pairs[];
int         g_pairCount    = 0;
bool        g_fileLoaded   = false;
datetime    g_lastSigBar   = 0;
int         g_lastSignal   = 0;
int         g_bulls        = 0;
int         g_bears        = 0;
int         g_atrHandle    = INVALID_HANDLE;
CTrade      g_trade;

//+------------------------------------------------------------------+
//| Timeframe helpers                                                |
//+------------------------------------------------------------------+
ENUM_TIMEFRAMES TfFromString(const string text)
  {
   string s = text;
   StringTrimLeft(s);
   StringTrimRight(s);
   StringToUpper(s);
   if(s == "M1")
      return PERIOD_M1;
   if(s == "M5")
      return PERIOD_M5;
   if(s == "M15")
      return PERIOD_M15;
   if(s == "M30")
      return PERIOD_M30;
   if(s == "H1")
      return PERIOD_H1;
   if(s == "H4")
      return PERIOD_H4;
   if(s == "D1")
      return PERIOD_D1;
   return PERIOD_CURRENT;
  }

string TfToString(const ENUM_TIMEFRAMES tf)
  {
   string s = EnumToString(tf);
   StringReplace(s, "PERIOD_", "");
   return s;
  }

//+------------------------------------------------------------------+
//| Register one pair                                                |
//+------------------------------------------------------------------+
bool AddPair(const ENUM_TIMEFRAMES lead, const ENUM_TIMEFRAMES lag,
             const int p, const int q, const int window, const double alpha)
  {
   if(lead == PERIOD_CURRENT || lag == PERIOD_CURRENT)
      return false;
   if(PeriodSeconds(lead) <= PeriodSeconds(lag))
     {
      PrintFormat("Pair %s>%s rejected: lead must be the higher timeframe",
                  TfToString(lead), TfToString(lag));
      return false;
     }
   if(p < 1 || q < 1 || window < 5 * (1 + p + q))
     {
      PrintFormat("Pair %s>%s rejected: invalid lags/window", TfToString(lead), TfToString(lag));
      return false;
     }

   int i = g_pairCount;
   ArrayResize(g_pairs, i + 1);
   g_pairs[i].lead          = lead;
   g_pairs[i].lag           = lag;
   g_pairs[i].leadName      = TfToString(lead);
   g_pairs[i].lagName       = TfToString(lag);
   g_pairs[i].p             = p;
   g_pairs[i].q             = q;
   g_pairs[i].window        = window;
   g_pairs[i].alpha         = alpha;
   g_pairs[i].hasOffline    = false;
   g_pairs[i].offlineValid  = false;
   g_pairs[i].offlineF      = 0.0;
   g_pairs[i].offlineP      = 1.0;
   g_pairs[i].stability     = 0.0;
   g_pairs[i].liveReady     = false;
   g_pairs[i].liveF         = 0.0;
   g_pairs[i].liveP         = 1.0;
   g_pairs[i].sigmaY        = 0.0;
   g_pairs[i].lastLagBar    = 0;
   g_pairs[i].barsSinceTest = 0;
   g_pairs[i].pred          = 0.0;
   g_pairs[i].vote          = 0;
   g_pairs[i].valid         = false;
   ArrayResize(g_pairs[i].beta, 1 + q + p);
   ArrayInitialize(g_pairs[i].beta, 0.0);
   g_pairCount++;
   return true;
  }

//+------------------------------------------------------------------+
//| Load the Jupyter calibration table                               |
//+------------------------------------------------------------------+
bool LoadCausalityFile()
  {
   int flags = FILE_READ | FILE_TXT | FILE_ANSI | FILE_SHARE_READ;
   if(InpUseCommonFolder)
      flags |= FILE_COMMON;

   int h = FileOpen(InpCausalityFile, flags);
   if(h == INVALID_HANDLE)
     {
      PrintFormat("Causality file '%s' not found (error %d). Using fallback pairs.",
                  InpCausalityFile, GetLastError());
      return false;
     }

   int line = 0;
   while(!FileIsEnding(h))
     {
      string row = FileReadString(h);
      line++;
      if(line == 1)
         continue;                               // header
      StringTrimLeft(row);
      StringTrimRight(row);
      if(StringLen(row) == 0)
         continue;

      string f[];
      if(StringSplit(row, ',', f) < 13)
         continue;

      ENUM_TIMEFRAMES lead = TfFromString(f[0]);
      ENUM_TIMEFRAMES lag  = TfFromString(f[1]);
      if(!AddPair(lead, lag, (int)StringToInteger(f[2]), (int)StringToInteger(f[3]),
                  (int)StringToInteger(f[4]), StringToDouble(f[5])))
         continue;

      int i = g_pairCount - 1;
      string status = f[12];
      StringTrimLeft(status);
      StringTrimRight(status);
      g_pairs[i].hasOffline   = true;
      g_pairs[i].offlineF     = StringToDouble(f[6]);
      g_pairs[i].offlineP     = StringToDouble(f[8]);
      g_pairs[i].stability    = StringToDouble(f[9]);
      g_pairs[i].offlineValid = (status == "VALID");
     }
   FileClose(h);
   return (g_pairCount > 0);
  }

//+------------------------------------------------------------------+
//| Fallback pairs from inputs, "H1>M15,M30>M15"                |
//+------------------------------------------------------------------+
void LoadFallbackPairs()
  {
   string items[];
   int n = StringSplit(InpFallbackPairs, ',', items);
   for(int i = 0; i < n; i++)
     {
      string tf[];
      if(StringSplit(items[i], '>', tf) != 2)
         continue;
      AddPair(TfFromString(tf[0]), TfFromString(tf[1]),
              InpFallbackP, InpFallbackQ, InpFallbackWindow, InpFallbackAlpha);
     }
  }

//+------------------------------------------------------------------+
//| Log return of bar i (series order) in basis points               |
//+------------------------------------------------------------------+
double LogRet(const MqlRates &r[], const int i)
  {
   if(r[i].close <= 0.0 || r[i + 1].close <= 0.0)
      return 0.0;
   return GC_SCALE * MathLog(r[i].close / r[i + 1].close);
  }

//+------------------------------------------------------------------+
//| Gaussian elimination with partial pivoting                       |
//+------------------------------------------------------------------+
bool SolveLinear(const double &A[], const double &b[], const int k, double &x[])
  {
   double M[], v[];
   ArrayCopy(M, A);
   ArrayCopy(v, b);

   for(int c = 0; c < k; c++)
     {
      int    piv  = c;
      double best = MathAbs(M[c * k + c]);
      for(int r = c + 1; r < k; r++)
        {
         double a = MathAbs(M[r * k + c]);
         if(a > best)
           {
            best = a;
            piv  = r;
           }
        }
      if(best < 1e-12)
         return false;

      if(piv != c)
        {
         for(int j = 0; j < k; j++)
           {
            double t       = M[c * k + j];
            M[c * k + j]   = M[piv * k + j];
            M[piv * k + j] = t;
           }
         double tb = v[c];
         v[c]      = v[piv];
         v[piv]    = tb;
        }

      for(int r = c + 1; r < k; r++)
        {
         double factor = M[r * k + c] / M[c * k + c];
         if(factor == 0.0)
            continue;
         for(int j = c; j < k; j++)
            M[r * k + j] -= factor * M[c * k + j];
         v[r] -= factor * v[c];
        }
     }

   ArrayResize(x, k);
   for(int r = k - 1; r >= 0; r--)
     {
      double s = v[r];
      for(int j = r + 1; j < k; j++)
         s -= M[r * k + j] * x[j];
      x[r] = s / M[r * k + r];
     }
   return true;
  }

//+------------------------------------------------------------------+
//| OLS on the first kUse columns                                    |
//+------------------------------------------------------------------+
bool FitOLS(const double &X[], const double &Y[], const int n, const int kTot,
            const int kUse, double &beta[], double &rss)
  {
   double XtX[], Xty[];
   ArrayResize(XtX, kUse * kUse);
   ArrayResize(Xty, kUse);
   ArrayInitialize(XtX, 0.0);
   ArrayInitialize(Xty, 0.0);

   for(int i = 0; i < n; i++)
     {
      int o = i * kTot;
      for(int a = 0; a < kUse; a++)
        {
         double xa = X[o + a];
         Xty[a] += xa * Y[i];
         for(int c = a; c < kUse; c++)
            XtX[a * kUse + c] += xa * X[o + c];
        }
     }
   for(int a = 0; a < kUse; a++)
     {
      for(int c = 0; c < a; c++)
         XtX[a * kUse + c] = XtX[c * kUse + a];
      XtX[a * kUse + a] += 1e-9;                 // tiny ridge for numerical safety
     }

   if(!SolveLinear(XtX, Xty, kUse, beta))
      return false;

   rss = 0.0;
   for(int i = 0; i < n; i++)
     {
      int    o   = i * kTot;
      double fit = 0.0;
      for(int a = 0; a < kUse; a++)
         fit += beta[a] * X[o + a];
      double e = Y[i] - fit;
      rss += e * e;
     }
   return true;
  }

//+------------------------------------------------------------------+
//| Live Granger F-test                                              |
//+------------------------------------------------------------------+
bool RunGranger(SCausalPair &cp)
  {
   const int p = cp.p;
   const int q = cp.q;
   const int W = cp.window;
   const int k = 1 + q + p;

   int needLow = W + q + 3;
   MqlRates lo[];
   ArraySetAsSeries(lo, true);
   if(CopyRates(_Symbol, cp.lag, 0, needLow, lo) < needLow)
      return false;

   int ratio    = MathMax(1, PeriodSeconds(cp.lead) / PeriodSeconds(cp.lag));
   int needHigh = needLow / ratio + p + 20;
   MqlRates hi[];
   ArraySetAsSeries(hi, true);
   int gotHigh = CopyRates(_Symbol, cp.lead, 0, needHigh, hi);
   if(gotHigh < p + 3)
      return false;

   int    perH = PeriodSeconds(cp.lead);
   double X[], Y[];
   ArrayResize(X, W * k);
   ArrayResize(Y, W);

   int    n = 0, h = 0;
   double sumY = 0.0, sumY2 = 0.0;
   for(int s = 1; s <= W; s++)
     {
      if(s + q + 1 >= needLow)
         break;
      datetime cutoff = lo[s].time - perH;       // lead bar must have closed by lo[s].time
      while(h < gotHigh && hi[h].time > cutoff)
         h++;
      if(h + p >= gotHigh)
         break;

      int o = n * k;
      X[o] = 1.0;
      for(int j = 1; j <= q; j++)
         X[o + j] = LogRet(lo, s + j);
      for(int m = 1; m <= p; m++)
         X[o + q + m] = LogRet(hi, h + m - 1);
      Y[n]   = LogRet(lo, s);
      sumY  += Y[n];
      sumY2 += Y[n] * Y[n];
      n++;
     }
   if(n < 5 * k)
      return false;

   double betaU[], betaR[];
   double rssU = 0.0, rssR = 0.0;
   if(!FitOLS(X, Y, n, k, k, betaU, rssU))
      return false;
   if(!FitOLS(X, Y, n, k, 1 + q, betaR, rssR))
      return false;

   int    df2   = n - k;
   double fStat = (rssU > 0.0) ? ((rssR - rssU) / p) / (rssU / df2) : 0.0;
   if(fStat < 0.0)
      fStat = 0.0;

   int    err = 0;
   double cdf = MathCumulativeDistributionF(fStat, (double)p, (double)df2, true, false, err);
   double pv  = (err == 0 && MathIsValidNumber(cdf)) ? 1.0 - cdf : 1.0;

   cp.liveF = fStat;
   cp.liveP = MathMax(pv, 0.0);
   ArrayCopy(cp.beta, betaU);
   double mean = sumY / n;
   cp.sigmaY    = MathSqrt(MathMax(sumY2 / n - mean * mean, 0.0));
   cp.liveReady = true;
   return true;
  }

//+------------------------------------------------------------------+
//| Forecast the current lag-TF bar from closed bars only            |
//+------------------------------------------------------------------+
bool ComputePrediction(SCausalPair &cp)
  {
   cp.pred = 0.0;
   cp.vote = 0;
   if(!cp.liveReady)
      return false;

   const int p = cp.p;
   const int q = cp.q;

   MqlRates lo[];
   ArraySetAsSeries(lo, true);
   if(CopyRates(_Symbol, cp.lag, 0, q + 2, lo) < q + 2)
      return false;

//--- most recent lead bar that closed at or before the current lag bar opened
   datetime cutoff = lo[0].time - PeriodSeconds(cp.lead);
   int h0 = iBarShift(_Symbol, cp.lead, cutoff, false);
   if(h0 < 0)
      return false;
   while(iTime(_Symbol, cp.lead, h0) > cutoff)
      h0++;
   while(h0 > 0 && iTime(_Symbol, cp.lead, h0 - 1) <= cutoff)
      h0--;

   MqlRates hi[];
   ArraySetAsSeries(hi, true);
   if(CopyRates(_Symbol, cp.lead, h0, p + 1, hi) < p + 1)
      return false;

   double f = cp.beta[0];
   for(int j = 1; j <= q; j++)
      f += cp.beta[j] * LogRet(lo, j);
   for(int m = 1; m <= p; m++)
      f += cp.beta[q + m] * LogRet(hi, m - 1);

   cp.pred = f;
   double thr = InpMinEdgeSigma * cp.sigmaY;
   if(f > thr)
      cp.vote = 1;
   else
      if(f < -thr)
         cp.vote = -1;
   return true;
  }

//+------------------------------------------------------------------+
//| VALID / INVALID decision                                         |
//+------------------------------------------------------------------+
void UpdateValidity(SCausalPair &cp)
  {
   bool live    = cp.liveReady && cp.liveP < cp.alpha;
   bool offline = cp.hasOffline && cp.offlineValid;

   switch(InpStatusSource)
     {
      case STATUS_OFFLINE:
         cp.valid = cp.hasOffline ? offline : live;
         break;
      case STATUS_LIVE:
         cp.valid = live;
         break;
      default:
         cp.valid = cp.hasOffline ? (offline && live) : live;
         break;
     }
  }

//+------------------------------------------------------------------+
//| Combine the pair votes into one BUY / SELL / NONE signal         |
//+------------------------------------------------------------------+
int AggregateSignal()
  {
   g_bulls = 0;
   g_bears = 0;
   for(int i = 0; i < g_pairCount; i++)
     {
      if(!g_pairs[i].liveReady)
         continue;
      if(InpUseCausalityFilter && !g_pairs[i].valid)
         continue;
      if(g_pairs[i].vote > 0)
         g_bulls++;
      if(g_pairs[i].vote < 0)
         g_bears++;
     }
   if(g_bulls >= InpMinVotes && g_bears == 0)
      return 1;
   if(g_bears >= InpMinVotes && g_bulls == 0)
      return -1;
   return 0;
  }

//+------------------------------------------------------------------+
//| Publish filter state for other EAs (terminal global variables)   |
//+------------------------------------------------------------------+
void ExportGlobals(const int signal)
  {
   for(int i = 0; i < g_pairCount; i++)
      GlobalVariableSet("GC_" + _Symbol + "_" + g_pairs[i].leadName + "_" + g_pairs[i].lagName,
                        g_pairs[i].valid ? 1.0 : 0.0);
   GlobalVariableSet("GC_" + _Symbol + "_SIGNAL", (double)signal);
  }

//+------------------------------------------------------------------+
//| Trading                                                          |
//+------------------------------------------------------------------+
double NormalizeLots(const double lots)
  {
   double minLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double stepLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   double l = (stepLot > 0.0) ? MathFloor(lots / stepLot) * stepLot : lots;
   return MathMax(minLot, MathMin(maxLot, l));
  }
  
  
bool GetOurPosition(ulong &ticket, long &type)
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      ulong t = PositionGetTicket(i);
      if(t == 0 || !PositionSelectByTicket(t))
         continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol)
         continue;
      if((ulong)PositionGetInteger(POSITION_MAGIC) != InpMagic)
         continue;
      ticket = t;
      type   = PositionGetInteger(POSITION_TYPE);
      return true;
     }
   return false;
  }

//+------------------------------------------------------------------+
//| Manage Trades                                                    |
//+------------------------------------------------------------------+
void ManageTrades(const int signal, const bool isNewSignal)
  {
   ulong ticket = 0;
   long  type   = -1;
   bool  hasPos = GetOurPosition(ticket, type);

//--- close on an opposite signal
   if(hasPos && InpCloseOnOpposite && signal != 0)
     {
      bool opposite = (type == POSITION_TYPE_BUY && signal < 0) ||
                      (type == POSITION_TYPE_SELL && signal > 0);
      if(opposite && g_trade.PositionClose(ticket))
         hasPos = false;
     }

   if(hasPos || signal == 0 || !isNewSignal)
      return;

   double atr[];
   if(CopyBuffer(g_atrHandle, 0, 1, 1, atr) < 1 || atr[0] <= 0.0)
      return;

   int    digits  = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   double point   = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double minDist = (double)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) * point;
   double slDist  = MathMax(InpSL_ATR * atr[0], minDist + point);
   double tpDist  = MathMax(InpTP_ATR * atr[0], minDist + point);
   double lots    = NormalizeLots(InpLots);

   if(signal > 0)
     {
      double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      g_trade.Buy(lots, _Symbol, ask, NormalizeDouble(ask - slDist, digits),
                  NormalizeDouble(ask + tpDist, digits), "GC BUY");
     }
   else
     {
      double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      g_trade.Sell(lots, _Symbol, bid, NormalizeDouble(bid + slDist, digits),
                   NormalizeDouble(bid - tpDist, digits), "GC SELL");
     }
  }

//+------------------------------------------------------------------+
//| Chart arrows                                                     |
//+------------------------------------------------------------------+
void DrawSignalArrow(const int signal, const datetime t)
  {
   string name = GC_PREFIX + "SIG_" + IntegerToString((long)t);
   double price = iClose(_Symbol, InpSignalTF, 1);
   ENUM_OBJECT type = (signal > 0) ? OBJ_ARROW_BUY : OBJ_ARROW_SELL;
   if(ObjectFind(0, name) >= 0)
      ObjectDelete(0, name);
   if(ObjectCreate(0, name, type, 0, t, price))
     {
      ObjectSetInteger(0, name, OBJPROP_COLOR, signal > 0 ? clrDodgerBlue : clrOrangeRed);
      ObjectSetInteger(0, name, OBJPROP_WIDTH, 2);
      ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
     }
  }

//+------------------------------------------------------------------+
//| Panel                                                            |
//+------------------------------------------------------------------+
int PanelRows()
  {
   return 1 + g_pairCount + 2 + (InpShowSignals ? 1 : 0);
  }

//+------------------------------------------------------------------+
//| Set Lable                                                        |
//+------------------------------------------------------------------+
void SetLabel(const int row, const string text, const color clr)
  {
   string name = GC_PREFIX + "L" + IntegerToString(row);
   if(ObjectFind(0, name) < 0)
     {
      ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
      ObjectSetInteger(0, name, OBJPROP_XDISTANCE, InpPanelX + 10);
      ObjectSetInteger(0, name, OBJPROP_YDISTANCE, InpPanelY + 8 + row * (InpFontSize * 2 + 2));
      ObjectSetString(0, name, OBJPROP_FONT, "Consolas");
      ObjectSetInteger(0, name, OBJPROP_FONTSIZE, InpFontSize);
      ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
     }
   ObjectSetString(0, name, OBJPROP_TEXT, text);
   ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
  }

//+------------------------------------------------------------------+
//| Create Panel                                                     |
//+------------------------------------------------------------------+
void CreatePanel()
  {
   if(!InpShowPanel)
      return;
   string bg = GC_PREFIX + "BG";
   if(ObjectFind(0, bg) < 0)
      ObjectCreate(0, bg, OBJ_RECTANGLE_LABEL, 0, 0, 0);
   ObjectSetInteger(0, bg, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(0, bg, OBJPROP_XDISTANCE, InpPanelX);
   ObjectSetInteger(0, bg, OBJPROP_YDISTANCE, InpPanelY);
   ObjectSetInteger(0, bg, OBJPROP_XSIZE, InpFontSize * 48);
   ObjectSetInteger(0, bg, OBJPROP_YSIZE, PanelRows() * (InpFontSize * 2 + 2) + 16);
   ObjectSetInteger(0, bg, OBJPROP_BGCOLOR, C'18,22,30');
   ObjectSetInteger(0, bg, OBJPROP_BORDER_TYPE, BORDER_FLAT);
   ObjectSetInteger(0, bg, OBJPROP_COLOR, clrDimGray);
   ObjectSetInteger(0, bg, OBJPROP_SELECTABLE, false);
  }

//+------------------------------------------------------------------+
//| Update panel                                                     |
//+------------------------------------------------------------------+
void UpdatePanel(const int signal)
  {
   if(!InpShowPanel)
      return;

   int row = 0;
   SetLabel(row++, "MULTI-TIMEFRAME CAUSALITY", clrWhite);

   for(int i = 0; i < g_pairCount; i++)
     {
      string status;
      color  clr;
      if(!g_pairs[i].liveReady && InpStatusSource != STATUS_OFFLINE)
        {
         status = "WARMUP";
         clr    = clrGray;
        }
      else
        {
         status = g_pairs[i].valid ? "VALID" : "INVALID";
         clr    = g_pairs[i].valid ? clrLimeGreen : clrTomato;
        }
      double pShow = g_pairs[i].liveReady ? g_pairs[i].liveP : g_pairs[i].offlineP;
      double fShow = g_pairs[i].liveReady ? g_pairs[i].liveF : g_pairs[i].offlineF;
      string text = StringFormat("%-3s → %-3s  %-7s p=%.3f F=%6.2f",
                                 g_pairs[i].leadName, g_pairs[i].lagName, status, pShow, fShow);
      if(InpShowSignals && g_pairs[i].liveReady)
         text += StringFormat("  %+.2fbp", g_pairs[i].pred);
      SetLabel(row++, text, clr);
     }

   string src = (InpStatusSource == STATUS_OFFLINE) ? "OFFLINE" :
                (InpStatusSource == STATUS_LIVE) ? "LIVE" : "BOTH";
   SetLabel(row++, StringFormat("Source: %s | File: %s", src, g_fileLoaded ? "loaded" : "fallback"),
            clrSilver);
   SetLabel(row++, StringFormat("Filter: %s | Retest: %d bars", InpUseCausalityFilter ? "ON" : "OFF",
                                InpRetestBars), clrSilver);

   if(InpShowSignals)
     {
      string sigText = (signal > 0) ? "BUY" : (signal < 0) ? "SELL" : "NONE";
      color  sigClr  = (signal > 0) ? clrDodgerBlue : (signal < 0) ? clrOrangeRed : clrGray;
      SetLabel(row++, StringFormat("SIGNAL: %s  (bull %d / bear %d)", sigText, g_bulls, g_bears), sigClr);
     }
   ChartRedraw(0);
  }

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   g_pairCount = 0;
   ArrayResize(g_pairs, 0);

   g_fileLoaded = LoadCausalityFile();
   if(!g_fileLoaded)
      LoadFallbackPairs();
   if(g_pairCount == 0)
     {
      Print("No valid causality pairs configured.");
      return INIT_PARAMETERS_INCORRECT;
     }

   g_atrHandle = iATR(_Symbol, InpSignalTF, InpATRPeriod);
   if(g_atrHandle == INVALID_HANDLE)
     {
      Print("Failed to create ATR handle.");
      return INIT_FAILED;
     }

   g_trade.SetExpertMagicNumber(InpMagic);
   g_trade.SetTypeFillingBySymbol(_Symbol);
   g_trade.SetDeviationInPoints(20);

   for(int i = 0; i < g_pairCount; i++)
      PrintFormat("Pair %s -> %s | p=%d q=%d window=%d alpha=%.3f | offline: %s",
                  g_pairs[i].leadName, g_pairs[i].lagName, g_pairs[i].p, g_pairs[i].q,
                  g_pairs[i].window, g_pairs[i].alpha,
                  g_pairs[i].hasOffline ? (g_pairs[i].offlineValid ? "VALID" : "INVALID") : "n/a");

   CreatePanel();
   UpdatePanel(0);
   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   if(g_atrHandle != INVALID_HANDLE)
      IndicatorRelease(g_atrHandle);
   ObjectsDeleteAll(0, GC_PREFIX);
   ChartRedraw(0);
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   datetime t = iTime(_Symbol, InpSignalTF, 0);
   if(t == 0 || t == g_lastSigBar)
      return;
   g_lastSigBar = t;

   for(int i = 0; i < g_pairCount; i++)
     {
      datetime lb = iTime(_Symbol, g_pairs[i].lag, 0);
      if(lb != g_pairs[i].lastLagBar)
        {
         g_pairs[i].lastLagBar = lb;
         g_pairs[i].barsSinceTest++;
        }
      if(!g_pairs[i].liveReady || g_pairs[i].barsSinceTest >= InpRetestBars)
        {
         if(RunGranger(g_pairs[i]))
            g_pairs[i].barsSinceTest = 0;
        }
      ComputePrediction(g_pairs[i]);
      UpdateValidity(g_pairs[i]);
     }

   int  signal      = AggregateSignal();
   bool isNewSignal = (signal != 0 && signal != g_lastSignal);

   ExportGlobals(signal);

   if(isNewSignal && InpShowSignals)
     {
      DrawSignalArrow(signal, t);
      if(InpAlertOnSignal)
         Alert(StringFormat("%s Granger MTF signal: %s", _Symbol, signal > 0 ? "BUY" : "SELL"));
     }

   if(InpExecuteTrades)
      ManageTrades(signal, isNewSignal);

   g_lastSignal = signal;
   UpdatePanel(signal);
  }
//+------------------------------------------------------------------+