//+------------------------------------------------------------------+
//|                                              Catch22Features.mqh |
//|                                      MMQ — Muhammad Minhas Qamar |
//|                                   www.mql5.com/en/articles/23488 |
//+------------------------------------------------------------------+
#property copyright "MMQ — Muhammad Minhas Qamar"
#property link      "https://www.mql5.com/en/articles/23488"
#property version   "1.00"
#property strict

#include <Catch22\Catch22.mqh>

//+------------------------------------------------------------------+
//| Shared feature builder for the ablation study. Both the Lab      |
//| script (offline training) and the EA (live inference) build      |
//| their feature vectors HERE so the columns are guaranteed         |
//| identical — the single most important correctness constraint of  |
//| a train-offline / trade-live pipeline.                           |
//|                                                                  |
//| Three "arms" select which block of columns is produced:          |
//|   ARM_CLASSIC  : classic indicators only  (baseline control)     |
//|   ARM_CATCH22  : the 22 catch22 features                         |
//|   ARM_COMBINED : classic + catch22                               |
//+------------------------------------------------------------------+

enum ENUM_C22_ARM
  {
   ARM_CLASSIC=0,   // classic indicators only
   ARM_CATCH22,     // catch22 only
   ARM_COMBINED     // both
  };

//--- number of classic indicator features produced by this module
#define C22_NCLASSIC 8

//+------------------------------------------------------------------+
//| CCatch22FeatureBuilder                                           |
//|  Owns the indicator handles and a CCatch22 engine. Call Init()   |
//|  once, then Build() per bar index to fill a feature vector for   |
//|  the chosen arm. Column count is Dim(arm).                       |
//+------------------------------------------------------------------+
class CCatch22FeatureBuilder
  {
private:
   string            m_symbol;
   ENUM_TIMEFRAMES   m_tf;
   int               m_window;     // rolling window for catch22 (bars of returns)
   ENUM_C22_ARM      m_arm;

   //--- classic indicator handles
   int               m_hRSI;
   int               m_hATR;
   int               m_hMAfast;
   int               m_hMAslow;
   int               m_hStd;

   CCatch22          m_c22;

   //--- fill the classic block for the window ENDING at bar 'shift'
   bool              BuildClassic(int shift,double &out[]);
   //--- fill the catch22 block from returns of the window ending at 'shift'
   bool              BuildCatch22(int shift,double &out[]);

public:
                     CCatch22FeatureBuilder(void);
                    ~CCatch22FeatureBuilder(void);

   bool              Init(const string symbol,ENUM_TIMEFRAMES tf,
                          int window,ENUM_C22_ARM arm);
   void              Deinit(void);

   //--- number of feature columns for the current arm
   int               Dim(void) const;
   static int        DimOf(ENUM_C22_ARM arm);

   //--- build the full feature vector for the bar at 'shift'. Returns
   //--- false if the required history is not yet available.
   bool              Build(int shift,double &out[]);

   //--- column name for diagnostics / CSV headers / importance labels
   string            ColumnName(int col) const;
  };

//+------------------------------------------------------------------+
//| Construct with empty handles.                                    |
//+------------------------------------------------------------------+
CCatch22FeatureBuilder::CCatch22FeatureBuilder(void)
  {
   m_hRSI=INVALID_HANDLE;
   m_hATR=INVALID_HANDLE;
   m_hMAfast=INVALID_HANDLE;
   m_hMAslow=INVALID_HANDLE;
   m_hStd=INVALID_HANDLE;
   m_window=128;
   m_arm=ARM_COMBINED;
  }

//+------------------------------------------------------------------+
//| Release handles on destruction.                                  |
//+------------------------------------------------------------------+
CCatch22FeatureBuilder::~CCatch22FeatureBuilder(void)
  {
   Deinit();
  }

//+------------------------------------------------------------------+
//| Number of feature columns for a given arm.                       |
//+------------------------------------------------------------------+
static int CCatch22FeatureBuilder::DimOf(ENUM_C22_ARM arm)
  {
   switch(arm)
     {
      case ARM_CLASSIC:
         return C22_NCLASSIC;
      case ARM_CATCH22:
         return CATCH22_N;
      case ARM_COMBINED:
         return C22_NCLASSIC+CATCH22_N;
     }
   return 0;
  }

//+------------------------------------------------------------------+
//| Dimension for the configured arm.                                |
//+------------------------------------------------------------------+
int CCatch22FeatureBuilder::Dim(void) const
  {
   return DimOf(m_arm);
  }

//+------------------------------------------------------------------+
//| Create indicator handles and store configuration.                |
//+------------------------------------------------------------------+
bool CCatch22FeatureBuilder::Init(const string symbol,ENUM_TIMEFRAMES tf,
                                  int window,ENUM_C22_ARM arm)
  {
   m_symbol=symbol;
   m_tf=tf;
   m_window=window;
   m_arm=arm;

//--- classic indicators are only needed for the classic/combined arms
   if(arm==ARM_CLASSIC || arm==ARM_COMBINED)
     {
      m_hRSI   =iRSI(symbol,tf,14,PRICE_CLOSE);
      m_hATR   =iATR(symbol,tf,14);
      m_hMAfast=iMA(symbol,tf,20,0,MODE_EMA,PRICE_CLOSE);
      m_hMAslow=iMA(symbol,tf,50,0,MODE_EMA,PRICE_CLOSE);
      m_hStd   =iStdDev(symbol,tf,20,0,MODE_SMA,PRICE_CLOSE);
      if(m_hRSI==INVALID_HANDLE || m_hATR==INVALID_HANDLE ||
         m_hMAfast==INVALID_HANDLE || m_hMAslow==INVALID_HANDLE ||
         m_hStd==INVALID_HANDLE)
         return false;
     }
   return true;
  }

//+------------------------------------------------------------------+
//| Release indicator handles.                                       |
//+------------------------------------------------------------------+
void CCatch22FeatureBuilder::Deinit(void)
  {
   if(m_hRSI!=INVALID_HANDLE)
     {
      IndicatorRelease(m_hRSI);
      m_hRSI=INVALID_HANDLE;
     }
   if(m_hATR!=INVALID_HANDLE)
     {
      IndicatorRelease(m_hATR);
      m_hATR=INVALID_HANDLE;
     }
   if(m_hMAfast!=INVALID_HANDLE)
     {
      IndicatorRelease(m_hMAfast);
      m_hMAfast=INVALID_HANDLE;
     }
   if(m_hMAslow!=INVALID_HANDLE)
     {
      IndicatorRelease(m_hMAslow);
      m_hMAslow=INVALID_HANDLE;
     }
   if(m_hStd!=INVALID_HANDLE)
     {
      IndicatorRelease(m_hStd);
      m_hStd=INVALID_HANDLE;
     }
  }

//+------------------------------------------------------------------+
//| Classic indicator block, read at bar 'shift' (already-closed     |
//| bar). Eight interpretable features a discretionary trader would  |
//| have on the chart: RSI, ATR (normalized), MA spread & slopes,    |
//| return, rolling volatility, and price-vs-MA stretch.             |
//+------------------------------------------------------------------+
bool CCatch22FeatureBuilder::BuildClassic(int shift,double &out[])
  {
//--- dynamic, series-ordered buffers so index 0 == the bar at 'shift'
//--- (newest of the copied range) and index 1 == the bar before it.
   double rsi[],atr[],maf[],mas[],std[],close[];
   ArraySetAsSeries(rsi,true);
   ArraySetAsSeries(atr,true);
   ArraySetAsSeries(maf,true);
   ArraySetAsSeries(mas,true);
   ArraySetAsSeries(std,true);
   ArraySetAsSeries(close,true);
   if(CopyBuffer(m_hRSI,0,shift,1,rsi)<1)
      return false;
   if(CopyBuffer(m_hATR,0,shift,1,atr)<1)
      return false;
   if(CopyBuffer(m_hMAfast,0,shift,2,maf)<2)
      return false;
   if(CopyBuffer(m_hMAslow,0,shift,2,mas)<2)
      return false;
   if(CopyBuffer(m_hStd,0,shift,1,std)<1)
      return false;
   if(CopyClose(m_symbol,m_tf,shift,3,close)<3)
      return false;

   double price=close[0];
   double atrn =(price>0.0)?atr[0]/price:0.0;         // ATR as fraction of price
   double ret  =(close[1]>0.0)?MathLog(close[0]/close[1]):0.0;
   double maspread=(price>0.0)?(maf[0]-mas[0])/price:0.0;
   double mafslope=(price>0.0)?(maf[0]-maf[1])/price:0.0;
   double masslope=(price>0.0)?(mas[0]-mas[1])/price:0.0;
   double stretch =(atr[0]>0.0)?(price-maf[0])/atr[0]:0.0; // price-vs-MA in ATRs
   double volrel  =(price>0.0)?std[0]/price:0.0;

   ArrayResize(out,C22_NCLASSIC);
   out[0]=rsi[0]/100.0;   // scale RSI to [0,1]
   out[1]=atrn;
   out[2]=ret;
   out[3]=maspread;
   out[4]=mafslope;
   out[5]=masslope;
   out[6]=stretch;
   out[7]=volrel;
   return true;
  }

//+------------------------------------------------------------------+
//| catch22 block: build a window of log returns ending at bar       |
//| 'shift' and run the CCatch22 engine over it.                     |
//+------------------------------------------------------------------+
bool CCatch22FeatureBuilder::BuildCatch22(int shift,double &out[])
  {
   int need=m_window+1;
   double close[];
   if(CopyClose(m_symbol,m_tf,shift,need,close)<need)
      return false;
   ArraySetAsSeries(close,false);        // oldest -> newest

   double ret[];
   ArrayResize(ret,m_window);
   for(int i=0;i<m_window;i++)
     {
      if(close[i]<=0.0 || close[i+1]<=0.0)
        {
         ret[i]=0.0;
         continue;
        }
      ret[i]=MathLog(close[i+1]/close[i]);
     }

   double feats[];
   if(!m_c22.Compute(ret,m_window,feats))
     {
      //--- degenerate window: emit zeros so the row is still usable
      ArrayResize(out,CATCH22_N);
      ArrayInitialize(out,0.0);
      return true;
     }
   ArrayResize(out,CATCH22_N);
   for(int i=0;i<CATCH22_N;i++)
      out[i]=feats[i];
   return true;
  }

//+------------------------------------------------------------------+
//| Build the full feature vector for the configured arm.            |
//+------------------------------------------------------------------+
bool CCatch22FeatureBuilder::Build(int shift,double &out[])
  {
   double cls[],c22[];
   if(m_arm==ARM_CLASSIC)
     {
      if(!BuildClassic(shift,out))
         return false;
      return true;
     }
   if(m_arm==ARM_CATCH22)
     {
      if(!BuildCatch22(shift,out))
         return false;
      return true;
     }
//--- combined: classic block first, then catch22
   if(!BuildClassic(shift,cls))
      return false;
   if(!BuildCatch22(shift,c22))
      return false;
   ArrayResize(out,C22_NCLASSIC+CATCH22_N);
   for(int i=0;i<C22_NCLASSIC;i++)
      out[i]=cls[i];
   for(int i=0;i<CATCH22_N;i++)
      out[C22_NCLASSIC+i]=c22[i];
   return true;
  }

//+------------------------------------------------------------------+
//| Human-readable column name for a feature index in the current    |
//| arm (used for CSV headers and feature-importance reports).       |
//+------------------------------------------------------------------+
string CCatch22FeatureBuilder::ColumnName(int col) const
  {
   string classic[C22_NCLASSIC]=
     {
      "RSI14","ATR_norm","logret","MA_spread","MAfast_slope",
      "MAslow_slope","price_stretch_ATR","vol_rel"
     };

   if(m_arm==ARM_CLASSIC)
      return (col>=0 && col<C22_NCLASSIC)?classic[col]:"?";
   if(m_arm==ARM_CATCH22)
      return CCatch22::Name(col);
//--- combined
   if(col<C22_NCLASSIC)
      return classic[col];
   return CCatch22::Name(col-C22_NCLASSIC);
  }
//+------------------------------------------------------------------+