//+------------------------------------------------------------------+
//|                                                  SmcEngine.mqh   |
//|                                      Copyright 2026, Allan Niñal |
//|                                  https://www.allanninal.dev/mql5 |
//+------------------------------------------------------------------+
//| Smart-money zone engine: swings, BOS/CHoCH, order blocks, fair   |
//| value gaps, liquidity sweeps, mitigation. A bar-by-bar state     |
//| machine: Step(i) uses bars 0..i only, so what it decided about   |
//| a bar never changes later. A zone's creation bar and its         |
//| mitigation bar are set once. Concepts: swing points, liquidity   |
//| sweeps, structure breaks, order block, fair value gap.           |
//+------------------------------------------------------------------+
// SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0 (see LICENSE)
#property strict

#define B_OB_BULL_TOP   0
#define B_OB_BULL_BOT   1
#define B_OB_BEAR_TOP   2
#define B_OB_BEAR_BOT   3
#define B_FVG_BULL_TOP  4
#define B_FVG_BULL_BOT  5
#define B_FVG_BEAR_TOP  6
#define B_FVG_BEAR_BOT  7
#define B_STRUCT        8     // +1 BOS up, -1 BOS down, +2 CHoCH up, -2 CHoCH down
#define B_LEVEL         9     // the broken swing's price
#define B_SWEEP_BULL    10    // swing low taken, bar closed back above
#define B_SWEEP_BEAR    11
#define B_MITIGATED     12    // zones mitigated on this bar
#define B_TOUCHED       13    // live zones touched for the first time on this bar
#define B_ACTIVE_BULL   14    // live bullish zones after this bar
#define B_ACTIVE_BEAR   15
#define B_COUNT         16

#define ZK_OB   0
#define ZK_FVG  1

struct SSmcZone  { int kind; int dir; double top; double bot; int t0; int born; int end; int touches; bool inside; };
struct SSmcSwing { int i; double p; int side; bool swept; bool broken; };
struct SSmcBreak { int dir; bool choch; double level; int frm; int at; };
struct SSmcSweep { int dir; double level; int frm; int at; };

class CSmcEngine
  {
public:
   //--- settings
   int      swing, atr_period, ob_mit, fvg_mit, sweep_look, s_start, s_end;
   double   fvg_min, sweep_min;
   bool     use_session;
   //--- results
   SSmcZone  zones[];
   SSmcBreak breaks[];
   SSmcSweep sweeps[];
   int       nz, nb, ns;
   int       done;                       // last bar processed, -1 = none
private:
   SSmcSwing m_sw[];
   int       m_nsw;
   int       m_last[2];                  // newest swing per side: [0] highs, [1] lows
   int       m_trend;
   int       m_live[];
   int       m_nlive;
   double    m_atr, m_atr_sum;
   int       m_active[2];                // live zones: [0] bullish, [1] bearish

   double Far(const double &h[],const double &l[],const int i,const int d)  { return(d>0 ? l[i] : h[i]); }
   double Near(const double &h[],const double &l[],const int i,const int d) { return(d>0 ? h[i] : l[i]); }
   bool   Against(const double &o[],const double &c[],const int i,const int d) { return(d>0 ? c[i]<o[i] : c[i]>o[i]); }
   bool   InSession(const datetime t)
     {
      if(!use_session || s_start==s_end)
         return(true);
      MqlDateTime dt;
      TimeToStruct(t,dt);
      return(s_start<s_end ? (dt.hour>=s_start && dt.hour<s_end) : (dt.hour>=s_start || dt.hour<s_end));
     }
   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   Mitigates(const SSmcZone &z,const int mode,const double h,const double l,const double c)
     {
      double mid=(z.top+z.bot)/2.0;
      double tol=MathAbs(mid)*1e-10;      // a wick exactly on the midpoint counts ((top+bot)/2 can be 1 ulp off)
      if(z.dir>0)
         return(mode==0 ? l<=z.top : mode==1 ? l<=mid+tol : mode==2 ? l<=z.bot : c<z.bot);
      return(mode==0 ? h>=z.bot : mode==1 ? h>=mid-tol : mode==2 ? h>=z.top : c>z.top);
     }
   int    AddZone(const int kind,const int dir,const double top,const double bot,const int t0,const int born)
     {
      if(nz>=ArraySize(zones))
         ArrayResize(zones,nz+256);
      zones[nz].kind=kind;
      zones[nz].dir=dir;
      zones[nz].top=top;
      zones[nz].bot=bot;
      zones[nz].t0=t0;
      zones[nz].born=born;
      zones[nz].end=-1;
      zones[nz].touches=0;
      zones[nz].inside=false;
      if(m_nlive>=ArraySize(m_live))
         ArrayResize(m_live,m_nlive+256);
      m_live[m_nlive++]=nz;
      m_active[dir>0 ? 0 : 1]++;
      return(nz++);
     }

public:
   void Reset(void)
     {
      ArrayResize(zones,0,1024);
      ArrayResize(breaks,0,256);
      ArrayResize(sweeps,0,256);
      ArrayResize(m_sw,0,1024);
      ArrayResize(m_live,0,256);
      nz=nb=ns=m_nsw=m_nlive=0;
      m_last[0]=m_last[1]=-1;
      m_trend=0;
      m_atr=EMPTY_VALUE;
      m_atr_sum=0;
      m_active[0]=m_active[1]=0;
      done=-1;
     }

   //--- process closed bar i (bars 0..i are known); out[] gets the 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;
      //--- ATR: Wilder's smoothing of the true range, seeded with the SMA of the first atr_period values
      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;
      double a=m_atr;
      if(i>=atr_period-1 && a>0)
        {
         bool sess=InSession(t[i]);
         //--- 1. zones made before this bar: mitigated or touched
         int n_mit=0,n_touch=0,keep=0;
         for(int q=0; q<m_nlive; q++)
           {
            int z=m_live[q];
            if(zones[z].born>=i)
              {
               m_live[keep++]=z;
               continue;
              }
            if(Mitigates(zones[z],zones[z].kind==ZK_OB ? ob_mit : fvg_mit,h[i],l[i],c[i]))
              {
               zones[z].end=i;
               n_mit++;
               m_active[zones[z].dir>0 ? 0 : 1]--;
               continue;
              }
            bool in=(zones[z].dir>0 ? l[i]<=zones[z].top : h[i]>=zones[z].bot);
            if(in && !zones[z].inside)
              {
               zones[z].touches++;
               n_touch++;
              }
            zones[z].inside=in;
            m_live[keep++]=z;
           }
         m_nlive=keep;
         out[B_MITIGATED]=n_mit;
         out[B_TOUCHED]=n_touch;
         //--- 2. liquidity sweeps: a wick beyond an untouched swing that closes back inside
         for(int d=1; d>=-1; d-=2)
           {
            int best=-1;
            for(int k=m_nsw-1; k>=0; k--)
              {
               if(i-m_sw[k].i>sweep_look)
                  break;
               if(m_sw[k].side!=-d || m_sw[k].swept)
                  continue;
               if(Far(h,l,i,d)*d<(m_sw[k].p-d*sweep_min*a)*d)
                 {
                  m_sw[k].swept=true;
                  if(c[i]*d>m_sw[k].p*d && (best<0 || m_sw[k].p*d<m_sw[best].p*d))
                     best=k;
                 }
              }
            if(best>=0 && sess)
              {
               out[d>0 ? B_SWEEP_BULL : B_SWEEP_BEAR]=m_sw[best].p;
               if(ns>=ArraySize(sweeps))
                  ArrayResize(sweeps,ns+128);
               sweeps[ns].dir=d;
               sweeps[ns].level=m_sw[best].p;
               sweeps[ns].frm=m_sw[best].i;
               sweeps[ns].at=i;
               ns++;
              }
           }
         //--- 3. fair value gap ending at this bar
         if(i>=2 && sess)
            for(int d=1; d>=-1; d-=2)
              {
               double gap_far=Near(h,l,i-2,d),gap_near=Far(h,l,i,d);
               if((gap_near-gap_far)*d>=fvg_min*a)
                 {
                  double top=MathMax(gap_far,gap_near),bot=MathMin(gap_far,gap_near);
                  AddZone(ZK_FVG,d,top,bot,i-1,i);
                  out[d>0 ? B_FVG_BULL_TOP : B_FVG_BEAR_TOP]=top;
                  out[d>0 ? B_FVG_BULL_BOT : B_FVG_BEAR_BOT]=bot;
                 }
              }
         //--- 4. structure break and its order block
         for(int d=1; d>=-1; d-=2)
           {
            int s=m_last[d>0 ? 0 : 1];
            if(s<0 || m_sw[s].broken || c[i]*d<=m_sw[s].p*d)
               continue;
            m_sw[s].broken=true;
            bool choch=(m_trend==-d);
            m_trend=d;
            int org=m_sw[s].i;
            for(int j=m_sw[s].i; j<=i; j++)
               if(Far(h,l,j,d)*d<Far(h,l,org,d)*d)
                  org=j;
            int ob=-1;
            if(Against(o,c,org,d))
              {
               ob=org;
               while(ob+1<i && Against(o,c,ob+1,d))
                  ob++;
              }
            else
               for(int j=org-1; j>=MathMax(0,org-3); j--)
                  if(Against(o,c,j,d))
                    {
                     ob=j;
                     break;
                    }
            if(ob<0)
               ob=org;
            double top=(d>0 ? h[ob] : MathMax(h[ob],h[org]));
            double bot=(d>0 ? MathMin(l[ob],l[org]) : l[ob]);
            if(sess)
              {
               AddZone(ZK_OB,d,top,bot,MathMin(ob,org),i);
               out[d>0 ? B_OB_BULL_TOP : B_OB_BEAR_TOP]=top;
               out[d>0 ? B_OB_BULL_BOT : B_OB_BEAR_BOT]=bot;
              }
            out[B_STRUCT]=d*(choch ? 2 : 1);
            out[B_LEVEL]=m_sw[s].p;
            if(nb>=ArraySize(breaks))
               ArrayResize(breaks,nb+128);
            breaks[nb].dir=d;
            breaks[nb].choch=choch;
            breaks[nb].level=m_sw[s].p;
            breaks[nb].frm=m_sw[s].i;
            breaks[nb].at=i;
            nb++;
           }
         out[B_ACTIVE_BULL]=m_active[0];
         out[B_ACTIVE_BEAR]=m_active[1];
        }
      //--- 5. 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))
              {
               if(m_nsw>=ArraySize(m_sw))
                  ArrayResize(m_sw,m_nsw+256);
               m_sw[m_nsw].i=p;
               m_sw[m_nsw].p=(side>0 ? h[p] : l[p]);
               m_sw[m_nsw].side=side;
               m_sw[m_nsw].swept=false;
               m_sw[m_nsw].broken=false;
               m_last[side>0 ? 0 : 1]=m_nsw;
               m_nsw++;
              }
     }
  };
//+------------------------------------------------------------------+