//+------------------------------------------------------------------+
//|                                                        Dump4.mqh |
//|                                      Copyright 2026, Allan Niñal |
//|                                  https://www.allanninal.dev/mql5 |
//+------------------------------------------------------------------+
//| MT4 test harness for an indicator, run as an EA in the Strategy  |
//| Tester (MT4 iCustom takes its inputs at compile time, so each    |
//| product has a small EA that defines IndValue(buf,shift) with its |
//| own iCustom call BEFORE including this file).                    |
//| During the test: on every new bar, records which signal buffers  |
//| are set on the bar that just closed; on every tick, counts       |
//| signals drawn on the live bar (must stay 0).                     |
//| At the end (tester/files):                                       |
//|   <tag>_<SYM>_<TF>.csv          time,open,high,low,close,b<n>... |
//|                                 for every bar (empty = no value) |
//|   repaint_<tag>_<SYM>_<TF>.csv  closed bars checked, signals     |
//|                                 seen live, mismatches with the   |
//|                                 final values, live-bar signals   |
//+------------------------------------------------------------------+
// SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0 (see LICENSE)
#property strict

//--- a test EA may #define DUMP4_BUFFERS / DUMP4_PROBE before the include (a .set value cannot hold the commas)
#ifndef DUMP4_BUFFERS
#define DUMP4_BUFFERS "0,2,3"
#endif
#ifndef DUMP4_PROBE
#define DUMP4_PROBE "2,3"
#endif

input string InpTag     = "default";       // Tag for the output file names
input string InpBuffers = DUMP4_BUFFERS;   // Buffers to dump
input string InpProbe   = DUMP4_PROBE;     // Signal buffers checked for repainting

int      g_bufs[],g_probe[];
datetime g_bar=0;
datetime g_rec_t[];
int      g_rec_i[];                    // the bar's position counted from the oldest bar (stable as bars are added)
int      g_rec_f[];
int      g_rec_n=0,g_live0=0;

//--- DUMP4_LIVE (define before the include): for an indicator that calculates only its last N bars. MT4 runs the
//--- indicator through a fresh full calculation when the test ends, so the final values hold only the last N bars.
//--- Live mode stores every bar's values from the running instance when the bar closes, re-checks the last
//--- DUMP4_RECHECK closed bars on every new bar (a repaint after the close shows there), and dumps the stored values.
#ifndef DUMP4_RECHECK
#define DUMP4_RECHECK 100
#endif
//--- DUMP4_LATE "<buffers>": buffers the indicator may still write up to DUMP4_RECHECK bars into the past (a swing
//--- pivot drawn on an older bar once the swing turns); live mode re-stores them for the last DUMP4_RECHECK bars.
double g_lv[][16];                     // stored values per bar position (oldest = 0), buffers in InpBuffers order
int    g_lf[];                         // probe flags stored at the close
bool   g_lset[],g_lbad[];
int    g_ln=0;                         // positions allocated

void StoreBar(const int s)
  {
   int pos=Bars-1-s;
   if(pos>=g_ln)
     {
      g_ln=pos+1;
      ArrayResize(g_lv,g_ln,100000);
      ArrayResize(g_lf,g_ln,100000);
      ArrayResize(g_lset,g_ln,100000);
      ArrayResize(g_lbad,g_ln,100000);
     }
   for(int k=0; k<ArraySize(g_bufs) && k<16; k++)
      g_lv[pos][k]=IndValue(g_bufs[k],s);
   g_lf[pos]=Flags(s);
   g_lset[pos]=true;
   g_lbad[pos]=false;
  }

void ParseInts(const string text,int &out[])
  {
   string parts[];
   int n=StringSplit(text,',',parts);
   ArrayResize(out,n);
   for(int k=0; k<n; k++)
      out[k]=(int)StringToInteger(parts[k]);
  }

string TfText()
  {
   switch(_Period)
     {
      case PERIOD_M1:  return("M1");
      case PERIOD_M5:  return("M5");
      case PERIOD_M15: return("M15");
      case PERIOD_M30: return("M30");
      case PERIOD_H1:  return("H1");
      case PERIOD_H4:  return("H4");
      case PERIOD_D1:  return("D1");
     }
   return("M"+IntegerToString(_Period));
  }

//--- bit k set = probe buffer k has a value on the bar at `shift`
int Flags(const int shift)
  {
   int f=0;
   for(int k=0; k<ArraySize(g_probe); k++)
      if(IndValue(g_probe[k],shift)!=EMPTY_VALUE)
         f|=(1<<k);
   return(f);
  }

int OnInit()
  {
   ParseInts(InpBuffers,g_bufs);
   ParseInts(InpProbe,g_probe);
   ArrayResize(g_rec_t,0,100000);
   ArrayResize(g_rec_f,0,100000);
   ArrayResize(g_rec_i,0,100000);
   return(INIT_SUCCEEDED);
  }

void OnTick()
  {
   if(Flags(0)!=0)
      g_live0++;
   if(Time[0]==g_bar)
      return;
   g_bar=Time[0];
   if(Bars<3)
      return;
   ArrayResize(g_rec_t,g_rec_n+1,100000);
   ArrayResize(g_rec_f,g_rec_n+1,100000);
   ArrayResize(g_rec_i,g_rec_n+1,100000);
   g_rec_t[g_rec_n]=Time[1];
   g_rec_i[g_rec_n]=Bars-2;
   g_rec_f[g_rec_n]=Flags(1);
   g_rec_n++;
#ifdef DUMP4_LIVE
   if(g_ln==0)
      for(int s=Bars-1; s>=1; s--)
         StoreBar(s);                  // the bars already closed at the first new bar
   else
      StoreBar(1);
#ifdef DUMP4_LATE
   int late[];
   ParseInts(DUMP4_LATE,late);
   for(int s=2; s<=DUMP4_RECHECK && s<Bars; s++)
     {
      int pos=Bars-1-s;
      if(pos<g_ln && g_lset[pos])
         for(int k=0; k<ArraySize(g_bufs) && k<16; k++)
            for(int j=0; j<ArraySize(late); j++)
               if(g_bufs[k]==late[j])
                  g_lv[pos][k]=IndValue(g_bufs[k],s);
     }
#endif
   for(int s=2; s<=DUMP4_RECHECK && s<Bars; s++)
     {
      int pos=Bars-1-s;
      if(pos<g_ln && g_lset[pos] && Flags(s)!=g_lf[pos])
         g_lbad[pos]=true;
     }
#endif
  }

//--- the dump and the repaint check, once (from OnTester, or OnDeinit outside the tester)
bool g_done=false;
void Finish()
  {
   if(g_done)
      return;
   g_done=true;
   string name=InpTag+"_"+_Symbol+"_"+TfText()+".csv";
   int h=FileOpen(name,FILE_WRITE|FILE_TXT|FILE_ANSI);
   if(h==INVALID_HANDLE)
     {
      Print("Dump4: cannot write ",name," error ",GetLastError());
      return;
     }
   string head="time,open,high,low,close";
   for(int k=0; k<ArraySize(g_bufs); k++)
      head+=",b"+IntegerToString(g_bufs[k]);
   FileWriteString(h,head+"\n");
   for(int s=Bars-1; s>=0; s--)
     {
      string row=TimeToString(Time[s],TIME_DATE|TIME_MINUTES)+","+DoubleToString(Open[s],_Digits)+","+
                 DoubleToString(High[s],_Digits)+","+DoubleToString(Low[s],_Digits)+","+DoubleToString(Close[s],_Digits);
      for(int k=0; k<ArraySize(g_bufs); k++)
        {
#ifdef DUMP4_LIVE
         int pos=Bars-1-s;
         double v=(pos<g_ln && g_lset[pos] && k<16 ? g_lv[pos][k] : EMPTY_VALUE);
#else
         double v=IndValue(g_bufs[k],s);
#endif
         row+=","+(v==EMPTY_VALUE ? "" : StringFormat("%.16g",v));
        }
      FileWriteString(h,row+"\n");
     }
   FileClose(h);
   //--- repainting: the signals recorded when each bar closed against the final values
   int bad=0,sig=0,lost=0;
#ifdef DUMP4_LIVE
   for(int r=0; r<g_rec_n; r++)
      if(g_rec_f[r]!=0)
         sig++;
   for(int pos=0; pos<g_ln; pos++)
      if(g_lbad[pos])
         bad++;
#else
   for(int r=0; r<g_rec_n; r++)
     {
      int s=Bars-1-g_rec_i[r];
      if(s<1 || s>=Bars || Time[s]!=g_rec_t[r])
        {
         lost++;                       // the bar could not be found again: counts as a failure
         continue;
        }
      if(g_rec_f[r]!=0)
         sig++;
      if(Flags(s)!=g_rec_f[r])
         bad++;
     }
#endif
   h=FileOpen("repaint_"+name,FILE_WRITE|FILE_TXT|FILE_ANSI);
   if(h!=INVALID_HANDLE)
     {
      FileWriteString(h,StringFormat("closed_bars_checked,%d\nsignals_seen_live,%d\nmismatches,%d\nlive_bar_signals,%d\nbars,%d\nnot_found,%d\n",
                                     g_rec_n-lost,sig,bad,g_live0,Bars,lost));
      FileClose(h);
     }
   PrintFormat("Dump4 %s: %d bars dumped; %d closed bars checked (%d not found), %d signals, %d mismatches, %d live-bar signals",
               name,Bars,g_rec_n-lost,lost,sig,bad,g_live0);
  }

double OnTester()
  {
   Finish();
   return(0.0);
  }

void OnDeinit(const int reason)
  {
   Finish();
  }
//+------------------------------------------------------------------+