//+------------------------------------------------------------------+
//|                                                     DzEngine.mqh |
//|                                      Copyright 2026, Allan Niñal |
//|                                  https://www.allanninal.dev/mql5 |
//+------------------------------------------------------------------+
//| Displacement zone engine. A bar-by-bar state machine: Step(i)    |
//| uses bars 0..i only, and what it decided about a bar never       |
//| changes later. Rules (d = +1 demand, -1 supply):                 |
//|  ATR      Wilder's smoothing of the true range, seeded with the  |
//|           SMA of the first `atr_period` values. The displacement |
//|           test uses the ATR as it was BEFORE the bar (bar i-1).  |
//|  swing    bar p is a swing high when the `swing` bars on its left|
//|           have lower highs and the `swing` bars on its right     |
//|           highs not above it (mirror for lows). Known at p+swing.|
//|  break    the first close beyond the newest swing high (low).    |
//|           That close uses the swing up, with or without a zone.  |
//|  impulse  the break bar must be a displacement candle: range at  |
//|           least disp_mult x ATR, body at least body_pct % of the |
//|           range, closing in the break's direction.               |
//|  base     base_mode 0: the nearest candle of the other colour    |
//|           among the `search` bars before the break bar.          |
//|           base_mode 1: where the move started: the lowest low    |
//|           (demand; supply: highest high, latest bar on a tie) of |
//|           those bars, then the nearest candle of the other       |
//|           colour at or before it, in the same bars. None: no zone|
//|  zone     0 full candle, 1 body, 2 mixed (demand: low to body    |
//|           top, supply: body bottom to high).                     |
//|  states   fresh -> tested (price reaches the near edge, middle   |
//|           or far edge, from the bar after the zone was made) ->  |
//|           broken (a close or a wick beyond the far edge; checked |
//|           first, so a bar that does both only breaks it). Each   |
//|           later re-entry after a bar outside counts a retest.    |
//|  cap      at most `max_live` live zones per side (0 = no limit): |
//|           the oldest live one of that side is dropped.           |
//| An analysis tool: it describes zones, it does not trade.         |
//+------------------------------------------------------------------+
// SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0 (see LICENSE)
#property strict

#ifndef DZENGINE_MQH
#define DZENGINE_MQH

#define DZ_B_DEM_TOP     0
#define DZ_B_DEM_BOT     1
#define DZ_B_SUP_TOP     2
#define DZ_B_SUP_BOT     3
#define DZ_B_BREAK_UP    4     // the swing high broken on this bar (price)
#define DZ_B_BREAK_DN    5     // the swing low broken on this bar (price)
#define DZ_B_TESTED      6     // zones tested for the first time on this bar
#define DZ_B_RETESTS     7     // retests of already tested zones on this bar
#define DZ_B_BROKEN      8     // zones broken on this bar
#define DZ_B_LIVE_DEM    9     // live demand zones after this bar
#define DZ_B_LIVE_SUP    10    // live supply zones after this bar
#define DZ_B_DEM_BASE    11    // bars from the break bar back to the base candle of a new demand zone
#define DZ_B_SUP_BASE    12
#define DZ_B_TREND       13    // validated trend after this bar: +1 up, -1 down
#define DZ_B_COUNT       14

#define DZ_FRESH    0
#define DZ_TESTED   1
#define DZ_BROKEN   2
#define DZ_DROPPED  3


struct SDzZone
  {
   int      dir;
   double   top,bot,mid;
   int      t0;              // base candle
   int      born;            // break bar (the zone exists from the next bar on)
   int      state;
   int      test_bar;        // first test, -1 none
   int      end;             // broken or dropped, -1 live
   int      retests;         // entries counted: 1 = the first test
   int      entry;           // bar of the latest entry (first test or retest), -1 none
   bool     inside;
   double   atr;             // ATR before the break bar
   double   disp;            // break bar range / atr
   int      trend;           // validated trend on the break bar (+1 / -1)
   double   rr;              // reward-to-risk of the zone as a setup (0 when the risk is not above 0)
   bool     ok;              // passes the switched-on filters (always true when both are off)
  };
struct SDzSwing { int i; double p; bool broken; };
struct SDzBreak { int dir; double level; int frm; int at; int zone; };


class CDzEngine
  {
public:
   //--- settings
   int      swing,atr_period,search,zone_mode,test_mode,break_mode,max_live,base_mode;
   double   disp_mult,body_pct,min_rr;
   bool     trend_only;
   //--- results
   SDzZone  zones[];
   SDzBreak breaks[];
   int      nz,nb;
   int      done;                       // last bar processed, -1 = none
private:
   SDzSwing m_sw[2];                    // newest swing: [0] high, [1] low
   int      m_live[];
   int      m_nlive;
   double   m_atr,m_atr_sum;
   int      m_active[2];
   int      m_tr;                       // validated trend: +1 up, -1 down
   double   m_vlow,m_vhigh,m_H,m_P,m_L,m_Q;

   bool IsSwing(const double &h[],const double &l[],const int p,const int side)
     {
      for(int k=1; k<=swing; k++)
        {
         if(side>0 && (h[p-k]>=h[p] || h[p+k]>h[p]))
            return(false);
         if(side<0 && (l[p-k]<=l[p] || l[p+k]<l[p]))
            return(false);
        }
      return(true);
     }
   bool Reaches(const SDzZone &z,const double h,const double l)
     {
      double tol=MathAbs(z.mid)*1e-10;  // a wick exactly on the middle counts ((top+bot)/2 can be 1 ulp off)
      if(z.dir>0)
         return(test_mode==0 ? l<=z.top : test_mode==1 ? l<=z.mid+tol : l<=z.bot);
      return(test_mode==0 ? h>=z.bot : test_mode==1 ? h>=z.mid-tol : h>=z.top);
     }
   bool Breaks(const SDzZone &z,const double h,const double l,const double c)
     {
      if(z.dir>0)
         return(break_mode==0 ? c<z.bot : l<z.bot);
      return(break_mode==0 ? c>z.top : h>z.top);
     }
   //--- validated market structure after closed bar i
   void TrendStep(const int i,const double &h[],const double &l[],const double &c[])
     {
      if(i==0)
        {
         m_tr=1; m_vlow=l[0]; m_vhigh=DBL_MAX; m_H=h[0]; m_P=DBL_MAX; m_L=l[0]; m_Q=-DBL_MAX;
         return;
        }
      if(m_tr>0)
        {
         if(c[i]<m_vlow)
           { m_tr=-1; m_vhigh=m_H; m_L=l[i]; m_Q=-DBL_MAX; }
         else
            if(c[i]>m_H && m_P<DBL_MAX)
              { m_vlow=m_P; m_H=h[i]; m_P=DBL_MAX; }
            else
               if(h[i]>m_H)
                 { m_H=h[i]; m_P=DBL_MAX; }
               else
                  m_P=MathMin(m_P,l[i]);
        }
      else
        {
         if(c[i]>m_vhigh)
           { m_tr=1; m_vlow=m_L; m_H=h[i]; m_P=DBL_MAX; }
         else
            if(c[i]<m_L && m_Q>-DBL_MAX)
              { m_vhigh=m_Q; m_L=l[i]; m_Q=-DBL_MAX; }
            else
               if(l[i]<m_L)
                 { m_L=l[i]; m_Q=-DBL_MAX; }
               else
                  m_Q=MathMax(m_Q,h[i]);
        }
     }
   void Drop(const int side,const int i)
     {
      for(int q=0; q<m_nlive; q++)
        {
         int z=m_live[q];
         if((zones[z].dir>0 ? 0 : 1)!=side)
            continue;
         zones[z].state=DZ_DROPPED;
         zones[z].end=i;
         for(int k=q; k<m_nlive-1; k++)
            m_live[k]=m_live[k+1];
         m_nlive--;
         m_active[side]--;
         return;
        }
     }
   int AddZone(const int dir,const double top,const double bot,const int t0,const int born,const double atr,const double disp)
     {
      if(nz>=ArraySize(zones))
         ArrayResize(zones,nz+256);
      zones[nz].dir=dir;
      zones[nz].top=top;
      zones[nz].bot=bot;
      zones[nz].mid=(top+bot)/2.0;
      zones[nz].t0=t0;
      zones[nz].born=born;
      zones[nz].state=DZ_FRESH;
      zones[nz].test_bar=-1;
      zones[nz].end=-1;
      zones[nz].retests=0;
      zones[nz].entry=-1;
      zones[nz].inside=false;
      zones[nz].atr=atr;
      zones[nz].disp=disp;
      zones[nz].trend=m_tr;
      zones[nz].rr=0;
      zones[nz].ok=true;
      if(m_nlive>=ArraySize(m_live))
         ArrayResize(m_live,m_nlive+256);
      m_live[m_nlive++]=nz;
      int side=(dir>0 ? 0 : 1);
      m_active[side]++;
      if(max_live>0 && m_active[side]>max_live)
         Drop(side,born);
      return(nz++);
     }

public:
   void Defaults(void)
     {
      swing=3; atr_period=14; search=12; zone_mode=0; test_mode=0; break_mode=0; max_live=12; base_mode=0;
      disp_mult=1.0; body_pct=55.0; trend_only=false; min_rr=0.0;
     }
   void Reset(void)
     {
      ArrayResize(zones,0,1024);
      ArrayResize(breaks,0,256);
      ArrayResize(m_live,0,256);
      nz=nb=m_nlive=0;
      for(int s=0; s<2; s++)
        {
         m_sw[s].i=-1;
         m_sw[s].p=0;
         m_sw[s].broken=true;
        }
      m_atr=EMPTY_VALUE;
      m_atr_sum=0;
      m_active[0]=m_active[1]=0;
      m_tr=1; m_vlow=0; m_vhigh=DBL_MAX; m_H=0; m_P=DBL_MAX; m_L=0; m_Q=-DBL_MAX;
      done=-1;
     }
   //--- live zones of one side that pass the filters (all live zones when both are off)
   int    Live(const int dir) const
     {
      int n=0;
      for(int q=0; q<m_nlive; q++)
         if(zones[m_live[q]].ok && (zones[m_live[q]].dir>0)==(dir>0))
            n++;
      return(n);
     }
   int    Trend(void) const { return(m_tr); }
   //--- the validated low (uptrend) or validated high (downtrend)
   double ValidLevel(void) const { return(m_tr>0 ? m_vlow : m_vhigh); }
   double Atr(void) const { return(m_atr); }

   //--- process closed bar i (bars 0..i are known); out[] gets the DZ_B_* values for it
   void Step(const int i,const datetime &t[],const double &o[],const double &h[],const double &l[],const double &c[],double &out[])
     {
      ArrayInitialize(out,EMPTY_VALUE);
      done=i;
      TrendStep(i,h,l,c);
      out[DZ_B_TREND]=m_tr;
      double prev=m_atr;
      double tr=(i==0 ? h[i]-l[i] : MathMax(h[i]-l[i],MathMax(MathAbs(h[i]-c[i-1]),MathAbs(l[i]-c[i-1]))));
      if(i<atr_period-1)
         m_atr_sum+=tr;
      else
         if(i==atr_period-1)
           {
            m_atr_sum+=tr;
            m_atr=m_atr_sum/atr_period;
           }
         else
            m_atr=(m_atr*(atr_period-1)+tr)/atr_period;
      if(prev!=EMPTY_VALUE && prev>0)
        {
         //--- 1. zones made before this bar: reaction window, broken, tested, retested
         int n_test=0,n_re=0,n_brk=0,keep=0;
         for(int q=0; q<m_nlive; q++)
           {
            int z=m_live[q];
            bool reach=Reaches(zones[z],h[i],l[i]);
            if(Breaks(zones[z],h[i],l[i],c[i]))
              {
               if(zones[z].state==DZ_FRESH)
                 {
                  zones[z].test_bar=i;
                 }
               zones[z].state=DZ_BROKEN;
               zones[z].end=i;
               if(zones[z].ok)
                  n_brk++;
               m_active[zones[z].dir>0 ? 0 : 1]--;
               continue;
              }
            if(reach)
              {
               if(zones[z].state==DZ_FRESH)
                 {
                  zones[z].state=DZ_TESTED;
                  zones[z].test_bar=i;
                  zones[z].retests=1;
                  zones[z].entry=i;
                  if(zones[z].ok)
                     n_test++;
                 }
               else
                  if(!zones[z].inside)
                    {
                     zones[z].retests++;
                     zones[z].entry=i;
                     if(zones[z].ok)
                        n_re++;
                    }
              }
            zones[z].inside=reach;
            m_live[keep++]=z;
           }
         m_nlive=keep;
         out[DZ_B_TESTED]=n_test;
         out[DZ_B_RETESTS]=n_re;
         out[DZ_B_BROKEN]=n_brk;
         //--- 2. a break of the newest swing, and its zone
         for(int d=1; d>=-1; d-=2)
           {
            int s=(d>0 ? 0 : 1);
            if(m_sw[s].broken || c[i]*d<=m_sw[s].p*d)
               continue;
            m_sw[s].broken=true;
            out[d>0 ? DZ_B_BREAK_UP : DZ_B_BREAK_DN]=m_sw[s].p;
            double rng=h[i]-l[i],body=MathAbs(c[i]-o[i]);
            //--- a body of exactly body_pct % (common with decimal prices) counts: 1e-9 of the range absorbs the last-bit
            //--- difference between compilers in body_pct/100*rng
            bool impulse=(rng>0 && rng>=disp_mult*prev && body>=body_pct/100.0*rng-rng*1e-9 && (c[i]-o[i])*d>0);
            int base=-1,lo_j=MathMax(0,i-search),from_j=i-1;
            if(impulse && base_mode==1)
               for(int j=i-2; j>=lo_j; j--)                // the move's start: the lowest low (highest high), latest on a tie
                  if(d>0 ? l[j]<l[from_j] : h[j]>h[from_j])
                     from_j=j;
            if(impulse)
               for(int j=from_j; j>=lo_j; j--)
                  if((c[j]-o[j])*d<0)
                    {
                     base=j;
                     break;
                    }
            int zi=-1;
            if(base>=0)
              {
               double bt=MathMax(o[base],c[base]),bb=MathMin(o[base],c[base]);
               double top=(zone_mode==1 ? bt : (zone_mode==2 && d>0 ? bt : h[base]));
               double bot=(zone_mode==1 ? bb : (zone_mode==2 && d<0 ? bb : l[base]));
               double ht=top-bot;
               if(ht>0)
                 {
                  zi=AddZone(d,top,bot,base,i,prev,rng/prev);
                  //--- reward-to-risk: entry at the near edge, stop beyond the far edge, target = the move's extreme
                  double entry=(d>0 ? top : bot),stop=(d>0 ? bot-0.1*m_atr : top+0.1*m_atr),tgt=(d>0 ? h[base] : l[base]);
                  for(int j=base+1; j<=i; j++)
                     tgt=(d>0 ? MathMax(tgt,h[j]) : MathMin(tgt,l[j]));
                  double risk=d*(entry-stop),reward=d*(tgt-entry);
                  zones[zi].rr=(risk>0 ? reward/risk : 0.0);
                  zones[zi].ok=!((trend_only && m_tr!=d) || (min_rr>0 && zones[zi].rr<min_rr));
                  if(zones[zi].ok)
                    {
                     out[d>0 ? DZ_B_DEM_TOP : DZ_B_SUP_TOP]=top;
                     out[d>0 ? DZ_B_DEM_BOT : DZ_B_SUP_BOT]=bot;
                     out[d>0 ? DZ_B_DEM_BASE : DZ_B_SUP_BASE]=i-base;
                    }
                 }
              }
            if(nb>=ArraySize(breaks))
               ArrayResize(breaks,nb+128);
            breaks[nb].dir=d;
            breaks[nb].level=m_sw[s].p;
            breaks[nb].frm=m_sw[s].i;
            breaks[nb].at=i;
            breaks[nb].zone=zi;
            nb++;
           }
         out[DZ_B_LIVE_DEM]=Live(1);
         out[DZ_B_LIVE_SUP]=Live(-1);
        }
      //--- 3. the swing `swing` bars back is known from the next bar on
      int p=i-swing;
      if(p>=swing)
         for(int side=1; side>=-1; side-=2)
            if(IsSwing(h,l,p,side))
              {
               int s=(side>0 ? 0 : 1);
               m_sw[s].i=p;
               m_sw[s].p=(side>0 ? h[p] : l[p]);
               m_sw[s].broken=false;
              }
     }

  };

#endif
//+------------------------------------------------------------------+