Bell-PriceActionWithEma-EA/Experts/MyICT.mq5

//+------------------------------------------------------------------+
//| MyICT.mq5                                                        |
//| Big/Small structure + State machine (NO_TREND → PULLBACK → …)    |
//+------------------------------------------------------------------+
#property copyright "MyICT"
#property version   "1.11"
#property description "ICT MSS: sweep + BOS + FVG → limit @ breaker | R% | stats"

#include <Trade/Trade.mqh>

//+------------------------------------------------------------------+
enum ENUM_ICT_TREND
{
   ICT_TREND_UNKNOWN = 0,
   ICT_TREND_UP      = 1,
   ICT_TREND_DOWN    = 2,
   ICT_TREND_NEUTRAL = 3
};

enum ENUM_ICT_STATE
{
   ICT_STATE_NO_TREND        = 0,
   ICT_STATE_PULLBACK        = 1,
   ICT_STATE_WAITING_TRIGGER = 2,
   ICT_STATE_LIMIT_ORDERED   = 3,
   ICT_STATE_ON_TRADE        = 4,
   ICT_STATE_NONE            = 5
};

//+------------------------------------------------------------------+
input group "══ Swing (nến trước/sau pivot) ══"
input int             InpBigSwingRange    = 24;
input int             InpSmallSwingRange  = 2;
input int             InpSwingLookback    = 400;

input group "══ Discount / Premium (sóng Big) ══"
input double          InpZoneEqPct         = 50.0;   // % từ đáy/đỉnh sóng → equilibrium
input double          InpZoneTolPoints     = 5.0;    // dung sai (point)

input group "══ MSS / Liquidity / Breaker ══"
input int             InpMssLookback       = 50;     // quét sweep + BOS
input int             InpMssMaxRecent      = 10;    // MSS chỉ trên N nến gần nhất
input double          InpSweepTolPoints    = 3.0;    // wick quét liquidity (point)
input double          InpSweepTolAtr       = 0.05;   // + ×ATR
input double          InpMssDispAtrMult    = 0.30;   // nến BOS: body tối thiểu ×ATR
input bool            InpRequireFvg        = true;   // bắt buộc FVG sau BOS
input double          InpBreakerOffsetAtr  = 0.0;    // offset entry breaker (×ATR)
input int             InpLimitExpireBars   = 24;    // hủy limit sau N nến

input group "══ Session (London / New York) ══"
input bool            InpUseSessionFilter  = true;   // chỉ đặt lệnh trong phiên
input bool            InpSessionUseUtc     = false;  // false = giờ server broker
input int             InpLondonStartHour   = 8;      // London [0..23]
input int             InpLondonEndHour     = 17;
input int             InpNewYorkStartHour  = 13;     // New York [0..23]
input int             InpNewYorkEndHour    = 22;
input int             InpSessionAvoidLastMin = 0;  // tránh N phút cuối mỗi phiên (0=tắt)

input group "══ Trigger & quản lý lệnh ══"
input bool            InpTradeEnabled      = true;
input ulong           InpMagic             = 20260620;
input double          InpRiskPercent       = 1.0;    // 1R = % balance
input int             InpATRPeriod         = 14;
input double          InpSlAtrMult         = 0.25;   // SL trên đỉnh sweep / dưới đáy sweep + ATR×
input double          InpTpAtrBuffer       = 0.25;   // TP trước đỉnh/đáy sóng Big −/+ ATR×
input bool            InpUseMinRR          = true;   // lọc R:R tối thiểu
input double          InpMinRR             = 1.5;    // R:R tối thiểu (1:1.5 → 1.5)
input int             InpSlippagePoints    = 30;
input bool            InpOnePosition       = true;

input group "══ Thống kê (góc dưới-trái) ══"
input bool            InpShowStats         = true;
input int             InpStatFontSize      = 9;
input int             InpStatCornerX       = 8;
input int             InpStatCornerY       = 8;
input color           InpStatColor         = clrSilver;

input group "══ Hiển thị chart ══"
input bool            InpDrawSwings       = true;
input bool            InpDrawTrendLines   = true;
input bool            InpDrawZones        = true;
input uchar           InpZoneFillAlpha    = 68;     // 0=đặc, 255=trong suốt (nhỏ=hơn=mờ vừa)
input uchar           InpZoneActiveAlpha  = 50;     // vùng bias active (đậm hơn)
input color           InpClrBigHigh       = clrDodgerBlue;
input color           InpClrBigLow        = clrDeepSkyBlue;
input color           InpClrSmallHigh     = clrOrange;
input color           InpClrSmallLow      = clrGold;
input color           InpClrDiscount      = C'0,110,45';    // xanh đậm (dễ thấy trên nền đen)
input color           InpClrPremium       = C'150,45,55';   // đỏ burgundy
input color           InpClrBreaker       = C'120,60,180';
input color           InpClrFvg           = C'40,140,90';
input color           InpClrSweep         = clrDeepSkyBlue;
input color           InpClrZoneLabel     = clrWhite;
input bool            InpDrawMssSetup     = true;
input color           InpClrUp            = clrLime;
input color           InpClrDown          = clrTomato;
input color           InpClrNeutral       = clrSilver;
input int             InpFontSize         = 9;
input int             InpPanelX           = 12;
input int             InpPanelY           = 24;

input group "══ Debug ══"
input bool            InpDebug            = false;

//+------------------------------------------------------------------+
struct SwingPoint
{
   double   price;
   datetime time;
   int      shift;
};

struct TrendSnapshot
{
   ENUM_ICT_TREND trend;
   SwingPoint     h0, h1, l0, l1;
   bool           hasH0, hasH1, hasL0, hasL1;
};

struct BigWaveZone
{
   bool   valid;
   bool   legExtended;      // kéo thuận chiều Big (phá L0 khi giảm / phá H0 khi tăng)
   bool   legCounterTrend;  // phá ngược Big (phá H0 khi giảm / phá L0 khi tăng)
   double waveHigh;
   double waveLow;
   double equilibrium;
   double discountTop;
   double premiumBottom;
};

struct IctMssSetup
{
   bool     valid;
   bool     isBuy;
   double   liqLevel;
   double   sweepExtreme;
   int      sweepShift;
   double   brokenLevel;
   int      brokenShift;
   double   breakerTop;
   double   breakerBottom;
   double   entry;
   double   sl;
   double   tp;
   bool     hasFvg;
   double   fvgTop;
   double   fvgBottom;
   int      fvgShift;
   int      mssShift;
   string   summary;
};

const string OBJ_CH_PFX  = "MYICTC_";
const string STAT_PREFIX = "MYICTS_";
const string STAT_LINE1  = STAT_PREFIX + "L1";
const string STAT_LINE2  = STAT_PREFIX + "L2";

TrendSnapshot   g_big;
TrendSnapshot   g_small;
BigWaveZone     g_zone;
IctMssSetup     g_setup;
ENUM_ICT_STATE  g_state = ICT_STATE_NO_TREND;
ENUM_ICT_STATE  g_statePrev = ICT_STATE_NO_TREND;
bool            g_biasBuy = false;
datetime        g_lastBar = 0;
datetime        g_lastTriggerBar = 0;
datetime        g_limitPlacedBar = 0;

int             g_hAtr = INVALID_HANDLE;
long            g_statWins  = 0;
long            g_statLoss = 0;
long            g_statTotal = 0;

CTrade          g_trade;

//+------------------------------------------------------------------+
long ActChart() { return ChartID(); }

ENUM_TIMEFRAMES ChartTf() { return (ENUM_TIMEFRAMES)Period(); }

//+------------------------------------------------------------------+
color WithAlpha(const color clr, const uchar alpha)
{
   return (color)((long)clr | ((long)alpha << 24));
}

//+------------------------------------------------------------------+
void Dbg(const string msg)
{
   if(InpDebug)
      Print("[MyICT] ", msg);
}

//+------------------------------------------------------------------+
void DeleteObjectsByPrefix(const string prefix)
{
   const long ch = ActChart();
   for(int i = ObjectsTotal(ch, 0, -1) - 1; i >= 0; i--)
   {
      const string name = ObjectName(ch, i, 0, -1);
      if(StringFind(name, prefix) == 0)
         ObjectDelete(ch, name);
   }
}

//+------------------------------------------------------------------+
int ClampHour(const int h)
{
   return MathMax(0, MathMin(23, h));
}

//+------------------------------------------------------------------+
int SessionMinutesNow()
{
   MqlDateTime tm;
   const datetime t = InpSessionUseUtc ? TimeGMT() : TimeCurrent();
   TimeToStruct(t, tm);
   return tm.hour * 60 + tm.min;
}

//+------------------------------------------------------------------+
bool IsWithinSessionWindow(const int currentMinutes,
                           const int startHour, const int endHour,
                           const int avoidLastMinutes)
{
   const int startMin = ClampHour(startHour) * 60;
   int endMin = ClampHour(endHour) * 60;
   if(endMin <= startMin)
      endMin += 24 * 60;

   int cur = currentMinutes;
   if(endMin > 24 * 60 && cur < startMin)
      cur += 24 * 60;

   if(cur < startMin || cur >= endMin)
      return false;

   const int avoid = MathMax(0, avoidLastMinutes);
   if(avoid > 0 && cur >= endMin - avoid)
      return false;

   return true;
}

//+------------------------------------------------------------------+
bool IsLondonSession()
{
   return IsWithinSessionWindow(SessionMinutesNow(),
                                InpLondonStartHour, InpLondonEndHour,
                                InpSessionAvoidLastMin);
}

//+------------------------------------------------------------------+
bool IsNewYorkSession()
{
   return IsWithinSessionWindow(SessionMinutesNow(),
                                InpNewYorkStartHour, InpNewYorkEndHour,
                                InpSessionAvoidLastMin);
}

//+------------------------------------------------------------------+
bool IsTradeSessionAllowed()
{
   if(!InpUseSessionFilter)
      return true;
   return (IsLondonSession() || IsNewYorkSession());
}

//+------------------------------------------------------------------+
string SessionStatusText()
{
   if(!InpUseSessionFilter)
      return "Session: OFF (filter tắt)";

   const string tz = InpSessionUseUtc ? "UTC" : "Server";
   string s = StringFormat("Session [%s]: ", tz);
   if(IsLondonSession() && IsNewYorkSession())
      s += "London + NY";
   else if(IsLondonSession())
      s += "London";
   else if(IsNewYorkSession())
      s += "New York";
   else
      s += "CLOSED";
   return s;
}

//+------------------------------------------------------------------+
double GetAtr(const string sym, const ENUM_TIMEFRAMES tf, const int shift)
{
   if(g_hAtr == INVALID_HANDLE)
      return 0.0;
   double b[];
   ArraySetAsSeries(b, true);
   if(CopyBuffer(g_hAtr, 0, shift, 1, b) < 1)
      return 0.0;
   return b[0];
}

//+------------------------------------------------------------------+
double SweepTolerance(const string sym, const double atr)
{
   const double pt = SymbolInfoDouble(sym, SYMBOL_POINT);
   return MathMax(pt * InpSweepTolPoints, atr * InpSweepTolAtr);
}

//+------------------------------------------------------------------+
double BosTolerance(const string sym, const double atr)
{
   const double pt = SymbolInfoDouble(sym, SYMBOL_POINT);
   return MathMax(pt * 2.0, atr * 0.02);
}

//+------------------------------------------------------------------+
bool FindBearishFvg(const string sym, const ENUM_TIMEFRAMES tf,
                    const int shiftFrom, const int shiftTo,
                    double &fTop, double &fBot, int &fShift)
{
   const double pt = SymbolInfoDouble(sym, SYMBOL_POINT);
   const int lo = MathMin(shiftFrom, shiftTo);
   const int hi = MathMax(shiftFrom, shiftTo);

   for(int i = lo; i <= hi; i++)
   {
      if(i + 2 >= Bars(sym, tf))
         continue;
      const double gapLo = iLow(sym, tf, i);
      const double gapHi = iHigh(sym, tf, i + 2);
      if(gapLo > gapHi + pt)
      {
         fTop = gapLo;
         fBot = gapHi;
         fShift = i;
         return true;
      }
   }
   return false;
}

//+------------------------------------------------------------------+
bool FindBullishFvg(const string sym, const ENUM_TIMEFRAMES tf,
                    const int shiftFrom, const int shiftTo,
                    double &fTop, double &fBot, int &fShift)
{
   const double pt = SymbolInfoDouble(sym, SYMBOL_POINT);
   const int lo = MathMin(shiftFrom, shiftTo);
   const int hi = MathMax(shiftFrom, shiftTo);

   for(int i = lo; i <= hi; i++)
   {
      if(i + 2 >= Bars(sym, tf))
         continue;
      const double gapHi = iHigh(sym, tf, i);
      const double gapLo = iLow(sym, tf, i + 2);
      if(gapLo > gapHi + pt)
      {
         fTop = gapLo;
         fBot = gapHi;
         fShift = i;
         return true;
      }
   }
   return false;
}

//+------------------------------------------------------------------+
bool WasLiquiditySweepHigh(const string sym, const ENUM_TIMEFRAMES tf,
                           const int shift, const double liq,
                           const double sweepTol, double &sweepHigh)
{
   const double h = iHigh(sym, tf, shift);
   const double c = iClose(sym, tf, shift);
   if(h <= liq + sweepTol || c >= liq)
      return false;
   sweepHigh = h;
   return true;
}

//+------------------------------------------------------------------+
bool WasLiquiditySweepLow(const string sym, const ENUM_TIMEFRAMES tf,
                          const int shift, const double liq,
                          const double sweepTol, double &sweepLow)
{
   const double l = iLow(sym, tf, shift);
   const double c = iClose(sym, tf, shift);
   if(l >= liq - sweepTol || c <= liq)
      return false;
   sweepLow = l;
   return true;
}

//+------------------------------------------------------------------+
void BreakerFromShift(const string sym, const ENUM_TIMEFRAMES tf,
                      const int shift, const bool isBuy,
                      double &top, double &bottom)
{
   const double o = iOpen(sym, tf, shift);
   const double c = iClose(sym, tf, shift);
   const double h = iHigh(sym, tf, shift);
   const double l = iLow(sym, tf, shift);
   top    = MathMax(o, c);
   bottom = MathMin(o, c);
   if(top <= bottom + _Point)
   {
      top    = h;
      bottom = l;
   }
}

//+------------------------------------------------------------------+
bool DetectBearishMssSetup(const string sym, const ENUM_TIMEFRAMES tf,
                           IctMssSetup &out)
{
   ZeroMemory(out);
   if(!g_small.hasL0 || !g_small.hasH0 || !g_zone.valid)
      return false;

   const double atr = GetAtr(sym, tf, 1);
   if(atr <= 0.0)
      return false;

   const double sweepTol = SweepTolerance(sym, atr);
   const double bosTol   = BosTolerance(sym, atr);
   const double liq = g_small.hasH1
                      ? MathMax(g_small.h0.price, g_small.h1.price)
                      : g_small.h0.price;
   const double broken = g_small.l0.price;
   const int brShift = MathMax(1, g_small.l0.shift);
   const int maxMss = MathMax(2, InpMssMaxRecent);

   for(int mssSh = 2; mssSh <= maxMss; mssSh++)
   {
      const double cMss = iClose(sym, tf, mssSh);
      if(cMss >= broken - bosTol)
         continue;

      const double body = MathAbs(iClose(sym, tf, mssSh) - iOpen(sym, tf, mssSh));
      if(body < atr * InpMssDispAtrMult)
         continue;

      int sweepSh = -1;
      double sweepHi = 0.0;
      for(int sw = mssSh + 1; sw <= InpMssLookback; sw++)
      {
         double sh = 0.0;
         if(WasLiquiditySweepHigh(sym, tf, sw, liq, sweepTol, sh))
         {
            sweepSh = sw;
            sweepHi = sh;
            break;
         }
      }
      if(sweepSh < 0)
         continue;

      double fTop = 0.0, fBot = 0.0;
      int fSh = -1;
      const bool hasFvg = FindBearishFvg(sym, tf, mssSh, sweepSh + 2, fTop, fBot, fSh);
      if(InpRequireFvg && !hasFvg)
         continue;

      double brTop = 0.0, brBot = 0.0;
      BreakerFromShift(sym, tf, brShift, false, brTop, brBot);
      const double entry = brTop + atr * InpBreakerOffsetAtr;

      const double slBuf = atr * InpSlAtrMult;
      const double tpBuf = atr * InpTpAtrBuffer;
      const double sl = sweepHi + slBuf;
      const double tp = g_zone.waveLow + tpBuf;

      out.valid = true;
      out.isBuy = false;
      out.liqLevel = liq;
      out.sweepExtreme = sweepHi;
      out.sweepShift = sweepSh;
      out.brokenLevel = broken;
      out.brokenShift = brShift;
      out.breakerTop = brTop;
      out.breakerBottom = brBot;
      out.entry = entry;
      out.sl = sl;
      out.tp = tp;
      out.hasFvg = hasFvg;
      out.fvgTop = fTop;
      out.fvgBottom = fBot;
      out.fvgShift = fSh;
      out.mssShift = mssSh;
      out.summary = StringFormat("SELL MSS | sweep H%.5f → BOS L%.5f | breaker %.5f",
                                 sweepHi, broken, entry);
      return true;
   }
   return false;
}

//+------------------------------------------------------------------+
bool DetectBullishMssSetup(const string sym, const ENUM_TIMEFRAMES tf,
                           IctMssSetup &out)
{
   ZeroMemory(out);
   if(!g_small.hasH0 || !g_small.hasL0 || !g_zone.valid)
      return false;

   const double atr = GetAtr(sym, tf, 1);
   if(atr <= 0.0)
      return false;

   const double sweepTol = SweepTolerance(sym, atr);
   const double bosTol   = BosTolerance(sym, atr);
   const double liq = g_small.hasL1
                      ? MathMin(g_small.l0.price, g_small.l1.price)
                      : g_small.l0.price;
   const double broken = g_small.h0.price;
   const int brShift = MathMax(1, g_small.h0.shift);
   const int maxMss = MathMax(2, InpMssMaxRecent);

   for(int mssSh = 2; mssSh <= maxMss; mssSh++)
   {
      const double cMss = iClose(sym, tf, mssSh);
      if(cMss <= broken + bosTol)
         continue;

      const double body = MathAbs(iClose(sym, tf, mssSh) - iOpen(sym, tf, mssSh));
      if(body < atr * InpMssDispAtrMult)
         continue;

      int sweepSh = -1;
      double sweepLo = 0.0;
      for(int sw = mssSh + 1; sw <= InpMssLookback; sw++)
      {
         double slv = 0.0;
         if(WasLiquiditySweepLow(sym, tf, sw, liq, sweepTol, slv))
         {
            sweepSh = sw;
            sweepLo = slv;
            break;
         }
      }
      if(sweepSh < 0)
         continue;

      double fTop = 0.0, fBot = 0.0;
      int fSh = -1;
      const bool hasFvg = FindBullishFvg(sym, tf, mssSh, sweepSh + 2, fTop, fBot, fSh);
      if(InpRequireFvg && !hasFvg)
         continue;

      double brTop = 0.0, brBot = 0.0;
      BreakerFromShift(sym, tf, brShift, true, brTop, brBot);
      const double entry = brBot - atr * InpBreakerOffsetAtr;

      const double slBuf = atr * InpSlAtrMult;
      const double tpBuf = atr * InpTpAtrBuffer;
      const double sl = sweepLo - slBuf;
      const double tp = g_zone.waveHigh - tpBuf;

      out.valid = true;
      out.isBuy = true;
      out.liqLevel = liq;
      out.sweepExtreme = sweepLo;
      out.sweepShift = sweepSh;
      out.brokenLevel = broken;
      out.brokenShift = brShift;
      out.breakerTop = brTop;
      out.breakerBottom = brBot;
      out.entry = entry;
      out.sl = sl;
      out.tp = tp;
      out.hasFvg = hasFvg;
      out.fvgTop = fTop;
      out.fvgBottom = fBot;
      out.fvgShift = fSh;
      out.mssShift = mssSh;
      out.summary = StringFormat("BUY MSS | sweep L%.5f → BOS H%.5f | breaker %.5f",
                                 sweepLo, broken, entry);
      return true;
   }
   return false;
}

//+------------------------------------------------------------------+
bool DetectMssSetup(const string sym, const ENUM_TIMEFRAMES tf, IctMssSetup &out)
{
   if(g_biasBuy)
      return DetectBullishMssSetup(sym, tf, out);
   return DetectBearishMssSetup(sym, tf, out);
}

//+------------------------------------------------------------------+
bool MssSetupReady()
{
   return g_setup.valid;
}

//+------------------------------------------------------------------+
double NormalizeVolume(const string sym, double v)
{
   const double step = SymbolInfoDouble(sym, SYMBOL_VOLUME_STEP);
   const double vmin = SymbolInfoDouble(sym, SYMBOL_VOLUME_MIN);
   const double vmax = SymbolInfoDouble(sym, SYMBOL_VOLUME_MAX);
   if(step <= 0.0)
      return 0.0;
   v = MathFloor(v / step) * step;
   if(v < vmin - 1e-12)
      return 0.0;
   if(v > vmax)
      v = vmax;
   return NormalizeDouble(v, 8);
}

//+------------------------------------------------------------------+
double VolumeForRisk(const string sym, const bool isBuy,
                     const double entry, const double sl)
{
   const double pt = SymbolInfoDouble(sym, SYMBOL_POINT);
   if(MathAbs(entry - sl) < pt)
      return 0.0;
   const double riskMoney = AccountInfoDouble(ACCOUNT_BALANCE) * (InpRiskPercent / 100.0);
   double profit = 0.0;
   if(!OrderCalcProfit(isBuy ? ORDER_TYPE_BUY : ORDER_TYPE_SELL,
                       sym, 1.0, entry, sl, profit))
      return 0.0;
   const double lossPerLot = MathAbs(profit);
   if(lossPerLot < DBL_EPSILON)
      return 0.0;
   return riskMoney / lossPerLot;
}

//+------------------------------------------------------------------+
double CalcRiskReward(const bool isBuy, const double entry,
                    const double sl, const double tp)
{
   const double risk = isBuy ? (entry - sl) : (sl - entry);
   const double reward = isBuy ? (tp - entry) : (entry - tp);
   if(risk <= _Point || reward <= 0.0)
      return 0.0;
   return reward / risk;
}

//+------------------------------------------------------------------+
bool IsRiskRewardOk(const bool isBuy, const double entry,
                    const double sl, const double tp, double &outRR)
{
   outRR = CalcRiskReward(isBuy, entry, sl, tp);
   if(!InpUseMinRR)
      return true;
   const double minRR = MathMax(0.1, InpMinRR);
   return (outRR >= minRR - 1e-8);
}

//+------------------------------------------------------------------+
bool StopsValid(const string sym, const bool isBuy,
                const double entry, const double sl, const double tp)
{
   const double pt = SymbolInfoDouble(sym, SYMBOL_POINT);
   const int stops = (int)SymbolInfoInteger(sym, SYMBOL_TRADE_STOPS_LEVEL);
   const int freeze = (int)SymbolInfoInteger(sym, SYMBOL_TRADE_FREEZE_LEVEL);
   const double md = MathMax(stops, freeze) * pt;
   if(md <= 0.0)
      return true;
   if(isBuy)
   {
      if(entry - sl < md - pt) return false;
      if(tp - entry < md - pt) return false;
   }
   else
   {
      if(sl - entry < md - pt) return false;
      if(entry - tp < md - pt) return false;
   }
   return true;
}

//+------------------------------------------------------------------+
void CancelMyPendingLimits(const string sym)
{
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      const ulong ticket = OrderGetTicket(i);
      if(ticket == 0 || !OrderSelect(ticket))
         continue;
      if(OrderGetString(ORDER_SYMBOL) != sym)
         continue;
      if((ulong)OrderGetInteger(ORDER_MAGIC) != InpMagic)
         continue;
      const ENUM_ORDER_TYPE t = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
      if(t == ORDER_TYPE_BUY_LIMIT || t == ORDER_TYPE_SELL_LIMIT)
         g_trade.OrderDelete(ticket);
   }
}

//+------------------------------------------------------------------+
void ManagePendingLimits(const string sym, const ENUM_TIMEFRAMES tf)
{
   if(!HasMyPendingLimit(sym))
      return;

   if(InpUseSessionFilter && !IsTradeSessionAllowed())
   {
      CancelMyPendingLimits(sym);
      if(g_state == ICT_STATE_LIMIT_ORDERED)
         g_state = ICT_STATE_WAITING_TRIGGER;
      Dbg("Hủy limit — ngoài phiên London/NY");
      return;
   }

   const datetime t0 = iTime(sym, tf, 0);
   if(t0 == 0 || g_limitPlacedBar == 0)
      return;

   const int barsWait = iBarShift(sym, tf, g_limitPlacedBar, true);
   if(barsWait >= InpLimitExpireBars)
   {
      CancelMyPendingLimits(sym);
      g_state = ICT_STATE_WAITING_TRIGGER;
      Dbg("Hủy limit — hết hạn " + IntegerToString(InpLimitExpireBars) + " nến");
      return;
   }

   if(!g_setup.valid)
      return;

   const double live = g_setup.isBuy
                       ? MathMin(iLow(sym, tf, 0), iLow(sym, tf, 1))
                       : MathMax(iHigh(sym, tf, 0), iHigh(sym, tf, 1));

   if(!g_setup.isBuy && live > g_setup.sweepExtreme + SweepTolerance(sym, GetAtr(sym, tf, 1)))
   {
      CancelMyPendingLimits(sym);
      g_state = ICT_STATE_WAITING_TRIGGER;
      Dbg("Hủy SELL limit — phá lại trên sweep");
   }
   else if(g_setup.isBuy && live < g_setup.sweepExtreme - SweepTolerance(sym, GetAtr(sym, tf, 1)))
   {
      CancelMyPendingLimits(sym);
      g_state = ICT_STATE_WAITING_TRIGGER;
      Dbg("Hủy BUY limit — phá lại dưới sweep");
   }
}

//+------------------------------------------------------------------+
bool TryPlaceMssLimit(const string sym, const ENUM_TIMEFRAMES tf)
{
   if(!InpTradeEnabled)
      return false;
   if(!IsTradeSessionAllowed())
   {
      Dbg("MSS skip: ngoài phiên London/NY");
      return false;
   }
   if(g_state != ICT_STATE_WAITING_TRIGGER)
      return false;
   if(InpOnePosition && HasMyPosition(sym))
      return false;
   if(HasMyPendingLimit(sym))
      return false;

   const datetime tBar = iTime(sym, tf, 1);
   if(tBar == 0 || tBar == g_lastTriggerBar)
      return false;

   const double refClose = iClose(sym, tf, 1);
   if(g_biasBuy)
   {
      if(!PriceInDiscount(refClose))
         return false;
   }
   else
   {
      if(!PriceInPremium(refClose))
         return false;
   }

   IctMssSetup setup;
   if(!DetectMssSetup(sym, tf, setup))
   {
      g_setup.valid = false;
      return false;
   }
   g_setup = setup;

   const int dig = (int)SymbolInfoInteger(sym, SYMBOL_DIGITS);
   const double entry = NormalizeDouble(setup.entry, dig);
   const double sl    = NormalizeDouble(setup.sl, dig);
   const double tp    = NormalizeDouble(setup.tp, dig);

   MqlTick tk;
   if(!SymbolInfoTick(sym, tk))
      return false;

   if(setup.isBuy)
   {
      if(tp <= entry || sl >= entry || entry >= tk.ask - _Point)
      {
         Dbg("MSS Buy skip: entry/TP/SL");
         return false;
      }
   }
   else
   {
      if(tp >= entry || sl <= entry || entry <= tk.bid + _Point)
      {
         Dbg("MSS Sell skip: entry/TP/SL");
         return false;
      }
   }

   if(!StopsValid(sym, setup.isBuy, entry, sl, tp))
   {
      Dbg("MSS skip: STOPS_LEVEL");
      return false;
   }

   double rr = 0.0;
   if(!IsRiskRewardOk(setup.isBuy, entry, sl, tp, rr))
   {
      Dbg(StringFormat("MSS skip: R:R %.2f < 1:%.2f", rr, InpMinRR));
      return false;
   }

   double vol = NormalizeVolume(sym, VolumeForRisk(sym, setup.isBuy, entry, sl));
   if(vol <= 0.0)
   {
      Dbg("MSS skip: volume=0");
      return false;
   }

   g_trade.SetExpertMagicNumber(InpMagic);
   g_trade.SetDeviationInPoints(InpSlippagePoints);
   SetTradeFilling();

   const datetime exp = tBar + (datetime)(PeriodSeconds(tf) * MathMax(1, InpLimitExpireBars));
   const string cmt = setup.isBuy ? "MyICT_BUY_BB" : "MyICT_SELL_BB";
   const bool ok = setup.isBuy
                   ? g_trade.BuyLimit(vol, entry, sym, sl, tp, ORDER_TIME_SPECIFIED, exp, cmt)
                   : g_trade.SellLimit(vol, entry, sym, sl, tp, ORDER_TIME_SPECIFIED, exp, cmt);

   if(!ok)
   {
      Print("[MyICT] MSS limit fail ", g_trade.ResultRetcode(), " ", g_trade.ResultComment());
      return false;
   }

   g_lastTriggerBar = tBar;
   g_limitPlacedBar = tBar;
   g_state = ICT_STATE_LIMIT_ORDERED;
   PrintFormat("[MyICT] %s | vol=%.2f entry=%.5f SL=%.5f TP=%.5f R:R=1:%.2f | %s",
               cmt, vol, entry, sl, tp, rr, setup.summary);
   return true;
}

//+------------------------------------------------------------------+
string TrendText(const ENUM_ICT_TREND t)
{
   switch(t)
   {
      case ICT_TREND_UP:      return "UP (HH+HL)";
      case ICT_TREND_DOWN:    return "DOWN (LH+LL)";
      case ICT_TREND_NEUTRAL: return "NEUTRAL";
      default:                return "—";
   }
}

//+------------------------------------------------------------------+
string StateText(const ENUM_ICT_STATE s)
{
   switch(s)
   {
      case ICT_STATE_NO_TREND:        return "NO_TREND";
      case ICT_STATE_PULLBACK:        return "PULLBACK";
      case ICT_STATE_WAITING_TRIGGER: return "WAITING_TRIGGER";
      case ICT_STATE_LIMIT_ORDERED:   return "LIMIT_ORDERED";
      case ICT_STATE_ON_TRADE:        return "ON_TRADE";
      case ICT_STATE_NONE:            return "NONE";
      default:                        return "?";
   }
}

//+------------------------------------------------------------------+
color StateColor(const ENUM_ICT_STATE s)
{
   switch(s)
   {
      case ICT_STATE_WAITING_TRIGGER: return clrGold;
      case ICT_STATE_LIMIT_ORDERED:   return clrOrange;
      case ICT_STATE_ON_TRADE:        return clrLime;
      case ICT_STATE_PULLBACK:        return clrAqua;
      case ICT_STATE_NONE:            return clrGray;
      default:                        return InpClrNeutral;
   }
}

//+------------------------------------------------------------------+
bool IsSwingHigh(const string sym, const ENUM_TIMEFRAMES tf,
                 const int shift, const int swingRange)
{
   const int str = MathMax(1, swingRange);
   const double h = iHigh(sym, tf, shift);
   for(int k = 1; k <= str; k++)
   {
      if(shift + k >= Bars(sym, tf) || shift - k < 0)
         return false;
      if(h <= iHigh(sym, tf, shift + k) || h <= iHigh(sym, tf, shift - k))
         return false;
   }
   return true;
}

//+------------------------------------------------------------------+
bool IsSwingLow(const string sym, const ENUM_TIMEFRAMES tf,
                const int shift, const int swingRange)
{
   const int str = MathMax(1, swingRange);
   const double l = iLow(sym, tf, shift);
   for(int k = 1; k <= str; k++)
   {
      if(shift + k >= Bars(sym, tf) || shift - k < 0)
         return false;
      if(l >= iLow(sym, tf, shift + k) || l >= iLow(sym, tf, shift - k))
         return false;
   }
   return true;
}

//+------------------------------------------------------------------+
void SortSwingsByTime(SwingPoint &pts[], const int count)
{
   for(int i = 0; i < count - 1; i++)
      for(int j = i + 1; j < count; j++)
         if(pts[j].time < pts[i].time)
         {
            const SwingPoint t = pts[i];
            pts[i] = pts[j];
            pts[j] = t;
         }
}

//+------------------------------------------------------------------+
void CollectSwings(const string sym, const ENUM_TIMEFRAMES tf,
                   const int swingRange, SwingPoint &highs[], SwingPoint &lows[])
{
   ArrayResize(highs, 0);
   ArrayResize(lows, 0);

   const int str  = MathMax(1, swingRange);
   const int bars = Bars(sym, tf);
   const int last = MathMin(InpSwingLookback, bars - str - 1);
   if(last < str + 5)
      return;

   int nH = 0, nL = 0;

   for(int sh = last; sh >= 1; sh--)
   {
      if(IsSwingHigh(sym, tf, sh, swingRange))
      {
         ArrayResize(highs, nH + 1);
         highs[nH].price = iHigh(sym, tf, sh);
         highs[nH].time  = iTime(sym, tf, sh);
         highs[nH].shift = sh;
         nH++;
      }
      if(IsSwingLow(sym, tf, sh, swingRange))
      {
         ArrayResize(lows, nL + 1);
         lows[nL].price = iLow(sym, tf, sh);
         lows[nL].time  = iTime(sym, tf, sh);
         lows[nL].shift = sh;
         nL++;
      }
   }

   SortSwingsByTime(highs, nH);
   SortSwingsByTime(lows, nL);
}

//+------------------------------------------------------------------+
void PickLastTwo(const SwingPoint &pts[], const int count,
                 SwingPoint &s0, SwingPoint &s1, bool &has0, bool &has1)
{
   has0 = has1 = false;
   if(count < 1) return;
   s0 = pts[count - 1];
   has0 = true;
   if(count < 2) return;
   s1 = pts[count - 2];
   has1 = true;
}

//+------------------------------------------------------------------+
ENUM_ICT_TREND ClassifyTrend(const bool hasH0, const bool hasH1,
                             const bool hasL0, const bool hasL1,
                             const SwingPoint &h0, const SwingPoint &h1,
                             const SwingPoint &l0, const SwingPoint &l1)
{
   if(!hasH0 || !hasH1 || !hasL0 || !hasL1)
      return ICT_TREND_UNKNOWN;
   if(h0.price > h1.price && l0.price > l1.price)
      return ICT_TREND_UP;
   if(h0.price < h1.price && l0.price < l1.price)
      return ICT_TREND_DOWN;
   return ICT_TREND_NEUTRAL;
}

//+------------------------------------------------------------------+
bool AnalyzeLayer(const string sym, const ENUM_TIMEFRAMES tf,
                  const int swingRange, TrendSnapshot &out)
{
   ZeroMemory(out);
   out.trend = ICT_TREND_UNKNOWN;

   SwingPoint highs[], lows[];
   CollectSwings(sym, tf, swingRange, highs, lows);
   PickLastTwo(highs, ArraySize(highs), out.h0, out.h1, out.hasH0, out.hasH1);
   PickLastTwo(lows, ArraySize(lows), out.l0, out.l1, out.hasL0, out.hasL1);
   out.trend = ClassifyTrend(out.hasH0, out.hasH1, out.hasL0, out.hasL1,
                             out.h0, out.h1, out.l0, out.l1);
   return true;
}

//+------------------------------------------------------------------+
bool BigTrendIsClear()
{
   return (g_big.trend == ICT_TREND_UP || g_big.trend == ICT_TREND_DOWN);
}

//+------------------------------------------------------------------+
bool BigIsBearish()
{
   if(g_big.trend == ICT_TREND_DOWN)
      return true;
   return (g_big.hasH0 && g_big.hasH1 && g_big.h0.price < g_big.h1.price);
}

//+------------------------------------------------------------------+
bool BigIsBullish()
{
   if(g_big.trend == ICT_TREND_UP)
      return true;
   return (g_big.hasH0 && g_big.hasH1 && g_big.h0.price > g_big.h1.price);
}

//+------------------------------------------------------------------+
bool IsPullbackStructure()
{
   if(!BigTrendIsClear())
      return false;
   if(g_big.trend == ICT_TREND_UP && g_small.trend == ICT_TREND_DOWN)
   {
      g_biasBuy = true;
      return true;
   }
   if(g_big.trend == ICT_TREND_DOWN && g_small.trend == ICT_TREND_UP)
   {
      g_biasBuy = false;
      return true;
   }
   return false;
}

//+------------------------------------------------------------------+
double ExtremeLowBetween(const string sym, const ENUM_TIMEFRAMES tf,
                           const int shiftFrom, const int shiftTo)
{
   double mn = DBL_MAX;
   const int lo = MathMin(shiftFrom, shiftTo);
   const int hi = MathMax(shiftFrom, shiftTo);
   for(int sh = lo; sh <= hi; sh++)
   {
      const double l = iLow(sym, tf, sh);
      if(l < mn)
         mn = l;
   }
   return (mn == DBL_MAX ? 0.0 : mn);
}

//+------------------------------------------------------------------+
double ExtremeHighBetween(const string sym, const ENUM_TIMEFRAMES tf,
                            const int shiftFrom, const int shiftTo)
{
   double mx = 0.0;
   const int lo = MathMin(shiftFrom, shiftTo);
   const int hi = MathMax(shiftFrom, shiftTo);
   for(int sh = lo; sh <= hi; sh++)
   {
      const double h = iHigh(sym, tf, sh);
      if(h > mx)
         mx = h;
   }
   return mx;
}

//+------------------------------------------------------------------+
void CalcBigWaveZone(const string sym, const ENUM_TIMEFRAMES tf)
{
   ZeroMemory(g_zone);
   if(!g_big.hasH0 || !g_big.hasL0)
      return;

   g_zone.legExtended = false;
   g_zone.legCounterTrend = false;
   g_zone.waveHigh = g_big.h0.price;
   g_zone.waveLow  = g_big.l0.price;

   const double atr = GetAtr(sym, tf, 1);
   const double pt  = SymbolInfoDouble(sym, SYMBOL_POINT);
   const double tol = MathMax(pt * 5.0, (atr > 0.0 ? atr * 0.05 : pt * 10.0));

   const int shH0 = MathMax(0, g_big.h0.shift);
   const int shL0 = MathMax(0, g_big.l0.shift);
   const int shNow = 0;

   const double liveLow  = MathMin(iLow(sym, tf, 0),  iLow(sym, tf, 1));
   const double liveHigh = MathMax(iHigh(sym, tf, 0), iHigh(sym, tf, 1));

   // Big GIẢM — thuận: phá dưới L0 → H0 → đáy mới
   if(BigIsBearish() && liveLow < g_big.l0.price - tol)
   {
      double extLow = ExtremeLowBetween(sym, tf, shH0, shNow);
      if(extLow <= 0.0)
         extLow = liveLow;
      else
         extLow = MathMin(extLow, liveLow);

      g_zone.waveHigh = g_big.h0.price;
      g_zone.waveLow  = extLow;
      g_zone.legExtended = (extLow < g_big.l0.price - tol * 0.5);
   }
   // Big GIẢM — ngược: phá trên H0 → L0 → đỉnh cao nhất (chưa có Big H0 mới)
   else if(BigIsBearish() && liveHigh > g_big.h0.price + tol)
   {
      double extHigh = ExtremeHighBetween(sym, tf, shL0, shNow);
      if(extHigh <= 0.0)
         extHigh = liveHigh;
      else
         extHigh = MathMax(extHigh, liveHigh);

      g_zone.waveLow  = g_big.l0.price;
      g_zone.waveHigh = extHigh;
      g_zone.legCounterTrend = (extHigh > g_big.h0.price + tol * 0.5);
   }
   // Big TĂNG — thuận: phá trên H0 → L0 → đỉnh mới
   else if(BigIsBullish() && liveHigh > g_big.h0.price + tol)
   {
      double extHigh = ExtremeHighBetween(sym, tf, shL0, shNow);
      if(extHigh <= 0.0)
         extHigh = liveHigh;
      else
         extHigh = MathMax(extHigh, liveHigh);

      g_zone.waveLow  = g_big.l0.price;
      g_zone.waveHigh = extHigh;
      g_zone.legExtended = (extHigh > g_big.h0.price + tol * 0.5);
   }
   // Big TĂNG — ngược: phá dưới L0 → H0 → đáy thấp nhất
   else if(BigIsBullish() && liveLow < g_big.l0.price - tol)
   {
      double extLow = ExtremeLowBetween(sym, tf, shH0, shNow);
      if(extLow <= 0.0)
         extLow = liveLow;
      else
         extLow = MathMin(extLow, liveLow);

      g_zone.waveHigh = g_big.h0.price;
      g_zone.waveLow  = extLow;
      g_zone.legCounterTrend = (extLow < g_big.l0.price - tol * 0.5);
   }

   if(g_zone.waveHigh < g_zone.waveLow)
   {
      const double t = g_zone.waveHigh;
      g_zone.waveHigh = g_zone.waveLow;
      g_zone.waveLow  = t;
   }

   const double range = g_zone.waveHigh - g_zone.waveLow;
   if(range <= _Point * 2)
      return;

   const double pct = MathMax(1.0, MathMin(99.0, InpZoneEqPct)) / 100.0;
   g_zone.equilibrium   = g_zone.waveLow + range * pct;
   g_zone.discountTop   = g_zone.equilibrium;
   g_zone.premiumBottom = g_zone.equilibrium;
   g_zone.valid = true;

   if((g_zone.legExtended || g_zone.legCounterTrend) && InpDebug)
      Dbg(StringFormat("Zone %s | H=%.5f L=%.5f Eq=%.5f",
           g_zone.legCounterTrend ? "phá cấu trúc Big" : "kéo thuận chiều",
           g_zone.waveHigh, g_zone.waveLow, g_zone.equilibrium));
}

//+------------------------------------------------------------------+
bool PriceInDiscount(const double price)
{
   if(!g_zone.valid)
      return false;
   const double tol = InpZoneTolPoints * _Point;
   return (price <= g_zone.discountTop + tol);
}

//+------------------------------------------------------------------+
bool PriceInPremium(const double price)
{
   if(!g_zone.valid)
      return false;
   const double tol = InpZoneTolPoints * _Point;
   return (price >= g_zone.premiumBottom - tol);
}

//+------------------------------------------------------------------+
bool HasMyPosition(const string sym)
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(!PositionSelectByTicket(PositionGetTicket(i)))
         continue;
      if(PositionGetString(POSITION_SYMBOL) != sym)
         continue;
      if((ulong)PositionGetInteger(POSITION_MAGIC) != InpMagic)
         continue;
      return true;
   }
   return false;
}

//+------------------------------------------------------------------+
bool HasMyPendingLimit(const string sym)
{
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      const ulong ticket = OrderGetTicket(i);
      if(ticket == 0 || !OrderSelect(ticket))
         continue;
      if(OrderGetString(ORDER_SYMBOL) != sym)
         continue;
      if((ulong)OrderGetInteger(ORDER_MAGIC) != InpMagic)
         continue;
      const ENUM_ORDER_TYPE t = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
      if(t == ORDER_TYPE_BUY_LIMIT || t == ORDER_TYPE_SELL_LIMIT)
         return true;
   }
   return false;
}

//+------------------------------------------------------------------+
void SetTradeFilling()
{
   const long fm = SymbolInfoInteger(_Symbol, SYMBOL_FILLING_MODE);
   if((fm & SYMBOL_FILLING_IOC) != 0)
      g_trade.SetTypeFilling(ORDER_FILLING_IOC);
   else if((fm & SYMBOL_FILLING_FOK) != 0)
      g_trade.SetTypeFilling(ORDER_FILLING_FOK);
   else
      g_trade.SetTypeFilling(ORDER_FILLING_RETURN);
}

//+------------------------------------------------------------------+
ENUM_ICT_STATE ComputeStructureState(const string sym, const ENUM_TIMEFRAMES tf)
{
   if(!BigTrendIsClear())
      return ICT_STATE_NO_TREND;

   if(!IsPullbackStructure())
      return ICT_STATE_NO_TREND;

   CalcBigWaveZone(sym, tf);

   const double refPrice = g_biasBuy
                           ? MathMin(iClose(sym, tf, 0), iClose(sym, tf, 1))
                           : MathMax(iClose(sym, tf, 0), iClose(sym, tf, 1));

   if(g_biasBuy)
   {
      if(PriceInDiscount(refPrice))
         return ICT_STATE_WAITING_TRIGGER;
      return ICT_STATE_PULLBACK;
   }

   if(PriceInPremium(refPrice))
      return ICT_STATE_WAITING_TRIGGER;
   return ICT_STATE_PULLBACK;
}

//+------------------------------------------------------------------+
void UpdateStateMachine(const string sym, const ENUM_TIMEFRAMES tf)
{
   g_statePrev = g_state;

   if(HasMyPosition(sym))
   {
      g_state = ICT_STATE_ON_TRADE;
      return;
   }

   ManagePendingLimits(sym, tf);

   if(HasMyPendingLimit(sym))
   {
      g_state = ICT_STATE_LIMIT_ORDERED;
      return;
   }

   if(g_statePrev == ICT_STATE_ON_TRADE || g_statePrev == ICT_STATE_LIMIT_ORDERED)
   {
      g_state = ICT_STATE_NONE;
      Dbg("NONE — lệnh đã đóng (SL/TP hoặc hủy)");
      return;
   }

   if(g_statePrev == ICT_STATE_NONE)
   {
      // một nến NONE rồi quay lại đánh giá cấu trúc
   }

   g_state = ComputeStructureState(sym, tf);

   if(g_state == ICT_STATE_WAITING_TRIGGER)
      TryPlaceMssLimit(sym, tf);

   if(g_state != g_statePrev && InpDebug)
      Dbg(StringFormat("State %s → %s", StateText(g_statePrev), StateText(g_state)));
}

//+------------------------------------------------------------------+
void DrawArrowTag(const string tag, const datetime t, const double price,
                  const bool isHigh, const string label, const color clr,
                  const int width)
{
   const long ch = ActChart();
   const string arr = OBJ_CH_PFX + tag + "_AR";
   const string txt = OBJ_CH_PFX + tag + "_TX";

   if(ObjectFind(ch, arr) < 0)
      ObjectCreate(ch, arr, OBJ_ARROW, 0, t, price);
   ObjectMove(ch, arr, 0, t, price);
   ObjectSetInteger(ch, arr, OBJPROP_ARROWCODE, isHigh ? 217 : 218);
   ObjectSetInteger(ch, arr, OBJPROP_ANCHOR, isHigh ? ANCHOR_BOTTOM : ANCHOR_TOP);
   ObjectSetInteger(ch, arr, OBJPROP_COLOR, clr);
   ObjectSetInteger(ch, arr, OBJPROP_WIDTH, width);
   ObjectSetInteger(ch, arr, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(ch, arr, OBJPROP_HIDDEN, true);

   const int dig = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   const double pt = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   const double yOff = pt * (isHigh ? (width > 1 ? 150 : 90) : (width > 1 ? -150 : -90));

   if(ObjectFind(ch, txt) < 0)
      ObjectCreate(ch, txt, OBJ_TEXT, 0, t, NormalizeDouble(price + yOff, dig));
   ObjectMove(ch, txt, 0, t, NormalizeDouble(price + yOff, dig));
   ObjectSetString(ch, txt, OBJPROP_TEXT, label);
   ObjectSetInteger(ch, txt, OBJPROP_COLOR, clr);
   ObjectSetInteger(ch, txt, OBJPROP_FONTSIZE, InpFontSize);
   ObjectSetString(ch, txt, OBJPROP_FONT, "Arial Bold");
   ObjectSetInteger(ch, txt, OBJPROP_ANCHOR, isHigh ? ANCHOR_LOWER : ANCHOR_UPPER);
   ObjectSetInteger(ch, txt, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(ch, txt, OBJPROP_HIDDEN, true);
}

//+------------------------------------------------------------------+
void DrawSegLine(const string name, const datetime t1, const double p1,
                 const datetime t2, const double p2, const color clr, const int width)
{
   const long ch = ActChart();
   const int dig = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);

   if(ObjectFind(ch, name) < 0)
      ObjectCreate(ch, name, OBJ_TREND, 0, t1, p1, t2, p2);
   ObjectMove(ch, name, 0, t1, NormalizeDouble(p1, dig));
   ObjectMove(ch, name, 1, t2, NormalizeDouble(p2, dig));
   ObjectSetInteger(ch, name, OBJPROP_COLOR, clr);
   ObjectSetInteger(ch, name, OBJPROP_STYLE, width > 1 ? STYLE_SOLID : STYLE_DOT);
   ObjectSetInteger(ch, name, OBJPROP_WIDTH, width);
   ObjectSetInteger(ch, name, OBJPROP_RAY_RIGHT, false);
   ObjectSetInteger(ch, name, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(ch, name, OBJPROP_HIDDEN, true);
}

//+------------------------------------------------------------------+
void DrawZoneRect(const string name, const datetime t1, const datetime t2,
                  const double pTop, const double pBot, const color clr,
                  const uchar fillAlpha, const string tip)
{
   const long ch = ActChart();
   const int dig = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   const double y1 = NormalizeDouble(MathMax(pTop, pBot), dig);
   const double y2 = NormalizeDouble(MathMin(pTop, pBot), dig);

   if(ObjectFind(ch, name) < 0)
      ObjectCreate(ch, name, OBJ_RECTANGLE, 0, t1, y1, t2, y2);
   ObjectMove(ch, name, 0, t1, y1);
   ObjectMove(ch, name, 1, t2, y2);
   ObjectSetInteger(ch, name, OBJPROP_COLOR, WithAlpha(clr, fillAlpha));
   ObjectSetInteger(ch, name, OBJPROP_STYLE, STYLE_SOLID);
   ObjectSetInteger(ch, name, OBJPROP_WIDTH, 1);
   ObjectSetInteger(ch, name, OBJPROP_FILL, true);
   ObjectSetInteger(ch, name, OBJPROP_BACK, true);
   ObjectSetInteger(ch, name, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(ch, name, OBJPROP_HIDDEN, true);
   ObjectSetString(ch, name, OBJPROP_TOOLTIP, tip);
}

//+------------------------------------------------------------------+
void DrawZoneTag(const string name, const datetime t, const double price,
                 const string text, const color clr)
{
   const long ch = ActChart();
   const int dig = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);

   if(ObjectFind(ch, name) < 0)
      ObjectCreate(ch, name, OBJ_TEXT, 0, t, NormalizeDouble(price, dig));
   ObjectMove(ch, name, 0, t, NormalizeDouble(price, dig));
   ObjectSetString(ch, name, OBJPROP_TEXT, text);
   ObjectSetInteger(ch, name, OBJPROP_COLOR, clr);
   ObjectSetInteger(ch, name, OBJPROP_FONTSIZE, MathMax(7, InpFontSize - 1));
   ObjectSetString(ch, name, OBJPROP_FONT, "Arial");
   ObjectSetInteger(ch, name, OBJPROP_ANCHOR, ANCHOR_LEFT);
   ObjectSetInteger(ch, name, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(ch, name, OBJPROP_HIDDEN, true);
   ObjectSetInteger(ch, name, OBJPROP_BACK, false);
}

//+------------------------------------------------------------------+
void DrawLayer(const string tag, const TrendSnapshot &snap,
               const color clrHi, const color clrLo, const int lineWidth)
{
   if(!InpDrawSwings)
      return;

   if(snap.hasH0)
      DrawArrowTag(tag + "_H0", snap.h0.time, snap.h0.price, true, tag + " H0", clrHi, lineWidth);
   if(snap.hasH1)
      DrawArrowTag(tag + "_H1", snap.h1.time, snap.h1.price, true, tag + " H1", clrHi, lineWidth);
   if(snap.hasL0)
      DrawArrowTag(tag + "_L0", snap.l0.time, snap.l0.price, false, tag + " L0", clrLo, lineWidth);
   if(snap.hasL1)
      DrawArrowTag(tag + "_L1", snap.l1.time, snap.l1.price, false, tag + " L1", clrLo, lineWidth);

   if(!InpDrawTrendLines)
      return;
   if(snap.hasH0 && snap.hasH1)
      DrawSegLine(OBJ_CH_PFX + tag + "_LNH", snap.h1.time, snap.h1.price,
                  snap.h0.time, snap.h0.price, clrHi, lineWidth);
   if(snap.hasL0 && snap.hasL1)
      DrawSegLine(OBJ_CH_PFX + tag + "_LNL", snap.l1.time, snap.l1.price,
                  snap.l0.time, snap.l0.price, clrLo, lineWidth);
}

//+------------------------------------------------------------------+
void DrawZones(const string sym, const ENUM_TIMEFRAMES tf)
{
   if(!InpDrawZones || !g_zone.valid)
      return;

   const datetime t2 = iTime(sym, tf, 0) + (datetime)PeriodSeconds(tf);
   datetime t1 = iTime(sym, tf, MathMin(60, Bars(sym, tf) - 1));
   if(g_zone.legCounterTrend)
   {
      if(BigIsBearish() && g_big.hasL0)
         t1 = g_big.l0.time;
      else if(BigIsBullish() && g_big.hasH0)
         t1 = g_big.h0.time;
   }
   else if(g_zone.legExtended)
   {
      if(BigIsBearish() && g_big.hasH0)
         t1 = g_big.h0.time;
      else if(BigIsBullish() && g_big.hasL0)
         t1 = g_big.l0.time;
   }
   if(t1 == 0 || t2 == 0)
      return;

   const bool activePullback = (g_state == ICT_STATE_PULLBACK
                              || g_state == ICT_STATE_WAITING_TRIGGER);
   const uchar discAlpha = (activePullback && g_biasBuy)
                           ? InpZoneActiveAlpha : InpZoneFillAlpha;
   const uchar premAlpha = (activePullback && !g_biasBuy)
                           ? InpZoneActiveAlpha : InpZoneFillAlpha;

   string extTip = "";
   if(g_zone.legCounterTrend)
      extTip = " (phá cấu trúc Big — L0↔đỉnh/đáy mới)";
   else if(g_zone.legExtended)
      extTip = " (kéo thuận chiều Big)";
   DrawZoneRect(OBJ_CH_PFX + "Z_DISC", t1, t2,
                g_zone.discountTop, g_zone.waveLow,
                InpClrDiscount, discAlpha,
                "Discount — nửa dưới sóng Big" + extTip);

   DrawZoneRect(OBJ_CH_PFX + "Z_PREM", t1, t2,
                g_zone.waveHigh, g_zone.premiumBottom,
                InpClrPremium, premAlpha,
                "Premium — nửa trên sóng Big" + extTip);

   DrawSegLine(OBJ_CH_PFX + "Z_EQ", t1, g_zone.equilibrium, t2, g_zone.equilibrium,
               clrGold, 1);
   ObjectSetInteger(ActChart(), OBJ_CH_PFX + "Z_EQ", OBJPROP_STYLE, STYLE_DOT);
   ObjectSetInteger(ActChart(), OBJ_CH_PFX + "Z_EQ", OBJPROP_WIDTH, 2);

   const double midDisc = (g_zone.waveLow + g_zone.discountTop) * 0.5;
   const double midPrem = (g_zone.premiumBottom + g_zone.waveHigh) * 0.5;
   DrawZoneTag(OBJ_CH_PFX + "LBL_DISC", t2, midDisc, " DISCOUNT ", InpClrZoneLabel);
   DrawZoneTag(OBJ_CH_PFX + "LBL_PREM", t2, midPrem, " PREMIUM ", InpClrZoneLabel);
}

//+------------------------------------------------------------------+
void DrawMssSetup(const string sym, const ENUM_TIMEFRAMES tf)
{
   if(!InpDrawMssSetup || !g_setup.valid)
      return;

   const int dig = (int)SymbolInfoInteger(sym, SYMBOL_DIGITS);
   const datetime tBr = iTime(sym, tf, g_setup.brokenShift);
   const datetime tSw = iTime(sym, tf, g_setup.sweepShift);
   const datetime tEnd = iTime(sym, tf, 0) + (datetime)PeriodSeconds(tf);

   DrawSegLine(OBJ_CH_PFX + "MSS_LIQ", tSw, g_setup.liqLevel, tEnd, g_setup.liqLevel,
               InpClrSweep, 1);
   ObjectSetInteger(ActChart(), OBJ_CH_PFX + "MSS_LIQ", OBJPROP_STYLE, STYLE_DASH);

   DrawZoneRect(OBJ_CH_PFX + "MSS_BRK", tBr, tEnd,
                g_setup.breakerTop, g_setup.breakerBottom,
                InpClrBreaker, 90,
                "Breaker block — limit entry");

   DrawSegLine(OBJ_CH_PFX + "MSS_ENT", tBr, g_setup.entry, tEnd, g_setup.entry,
               clrWhite, 2);

   if(g_setup.hasFvg && g_setup.fvgShift > 0)
   {
      const datetime tF = iTime(sym, tf, g_setup.fvgShift);
      DrawZoneRect(OBJ_CH_PFX + "MSS_FVG", tF, tEnd,
                   g_setup.fvgTop, g_setup.fvgBottom,
                   InpClrFvg, 110, "FVG");
   }

   DrawZoneTag(OBJ_CH_PFX + "MSS_LBL", tEnd, g_setup.entry,
               g_setup.isBuy ? " BUY LMT " : " SELL LMT ", InpClrBreaker);
}

//+------------------------------------------------------------------+
string LayerBlock(const string title, const int swingRange, const TrendSnapshot &snap)
{
   string s = StringFormat("%s (sw %d): %s", title, swingRange, TrendText(snap.trend));
   if(snap.hasH0 && snap.hasH1 && snap.hasL0 && snap.hasL1)
      s += StringFormat("\n  H0=%.2f H1=%.2f L0=%.2f L1=%.2f",
                        snap.h0.price, snap.h1.price, snap.l0.price, snap.l1.price);
   return s;
}

//+------------------------------------------------------------------+
string StateBlock()
{
   string s = StringFormat("STATE: %s", StateText(g_state));
   if(g_state == ICT_STATE_PULLBACK || g_state == ICT_STATE_WAITING_TRIGGER)
      s += StringFormat(" | Bias %s", g_biasBuy ? "BUY" : "SELL");
   if(g_zone.valid)
   {
      s += StringFormat("\n  Zone H=%.2f L=%.2f Eq=%.2f (%.0f%%)",
                        g_zone.waveHigh, g_zone.waveLow, g_zone.equilibrium, InpZoneEqPct);
      if(g_zone.legCounterTrend)
         s += " [P/D phá Big H0/L0]";
      else if(g_zone.legExtended)
         s += " [P/D kéo thuận chiều]";
      else
         s += " [H0-L0]";
      s += StringFormat(" | %s", g_biasBuy ? "Discount" : "Premium");
   }
   if(g_setup.valid)
   {
      s += "\n  " + g_setup.summary;
      double rr = CalcRiskReward(g_setup.isBuy, g_setup.entry, g_setup.sl, g_setup.tp);
      if(rr > 0.0)
      {
         s += StringFormat(" | R:R=1:%.2f", rr);
         if(InpUseMinRR && rr < InpMinRR - 1e-8)
            s += StringFormat(" (< 1:%.1f)", InpMinRR);
      }
   }
   s += "\n  " + SessionStatusText();
   return s;
}

//+------------------------------------------------------------------+
void DrawPanel(const string body)
{
   const long ch = ActChart();
   const string name = OBJ_CH_PFX + "PANEL";

   if(ObjectFind(ch, name) < 0)
      ObjectCreate(ch, name, OBJ_LABEL, 0, 0, 0);

   ObjectSetInteger(ch, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(ch, name, OBJPROP_ANCHOR, ANCHOR_LEFT_UPPER);
   ObjectSetInteger(ch, name, OBJPROP_XDISTANCE, InpPanelX);
   ObjectSetInteger(ch, name, OBJPROP_YDISTANCE, InpPanelY);
   ObjectSetInteger(ch, name, OBJPROP_FONTSIZE, MathMax(8, InpFontSize + 1));
   ObjectSetString(ch, name, OBJPROP_FONT, "Consolas");
   ObjectSetInteger(ch, name, OBJPROP_COLOR, StateColor(g_state));
   ObjectSetInteger(ch, name, OBJPROP_SELECTABLE, false);
   ObjectSetString(ch, name, OBJPROP_TEXT, body);
}

//+------------------------------------------------------------------+
void StatsEnsureLabel(const long ch, const string name, const int yDist)
{
   if(ObjectFind(ch, name) < 0)
      ObjectCreate(ch, name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(ch, name, OBJPROP_CORNER, CORNER_LEFT_LOWER);
   ObjectSetInteger(ch, name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);
   ObjectSetInteger(ch, name, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(ch, name, OBJPROP_XDISTANCE, InpStatCornerX);
   ObjectSetInteger(ch, name, OBJPROP_YDISTANCE, MathMax(0, yDist));
   ObjectSetInteger(ch, name, OBJPROP_FONTSIZE, MathMax(7, InpStatFontSize));
   ObjectSetString(ch, name, OBJPROP_FONT, "Consolas");
   ObjectSetInteger(ch, name, OBJPROP_COLOR, InpStatColor);
}

//+------------------------------------------------------------------+
void StatsUpdate()
{
   if(!InpShowStats)
   {
      ObjectDelete(ActChart(), STAT_LINE1);
      ObjectDelete(ActChart(), STAT_LINE2);
      return;
   }

   const long ch = ActChart();
   const int gap = (int)(MathMax(7, InpStatFontSize) * 2.2) + 12;
   StatsEnsureLabel(ch, STAT_LINE1, InpStatCornerY);
   StatsEnsureLabel(ch, STAT_LINE2, InpStatCornerY + gap);

   const long closed = g_statWins + g_statLoss;
   const double wr = (closed > 0) ? 100.0 * (double)g_statWins / (double)closed : 0.0;

   const string l1 = StringFormat("MyICT | 1R=%.1f%% | SL/TP ATR×", InpRiskPercent);
   string l2;
   if(closed > 0)
      l2 = StringFormat("Đóng %I64d | Thắng %I64d | Thua %I64d | Winrate %.1f%%",
                        g_statTotal, g_statWins, g_statLoss, wr);
   else
      l2 = StringFormat("Đóng %I64d | Thắng %I64d | Thua %I64d | Winrate: —",
                        g_statTotal, g_statWins, g_statLoss);

   ObjectSetString(ch, STAT_LINE1, OBJPROP_TEXT, l1);
   ObjectSetString(ch, STAT_LINE2, OBJPROP_TEXT, l2);
}

//+------------------------------------------------------------------+
void StatsCountExitDeal(const ulong dealTicket)
{
   if(dealTicket == 0 || !HistoryDealSelect(dealTicket))
      return;
   if(HistoryDealGetString(dealTicket, DEAL_SYMBOL) != _Symbol)
      return;
   if((ulong)HistoryDealGetInteger(dealTicket, DEAL_MAGIC) != InpMagic)
      return;
   if(HistoryDealGetInteger(dealTicket, DEAL_ENTRY) != DEAL_ENTRY_OUT)
      return;

   g_statTotal++;
   const ENUM_DEAL_REASON dr = (ENUM_DEAL_REASON)HistoryDealGetInteger(dealTicket, DEAL_REASON);
   if(dr == DEAL_REASON_TP)
      g_statWins++;
   else if(dr == DEAL_REASON_SL)
      g_statLoss++;
   else
   {
      const double net = HistoryDealGetDouble(dealTicket, DEAL_PROFIT)
                       + HistoryDealGetDouble(dealTicket, DEAL_SWAP)
                       + HistoryDealGetDouble(dealTicket, DEAL_COMMISSION);
      if(net > 0.0) g_statWins++;
      else if(net < 0.0) g_statLoss++;
   }
}

//+------------------------------------------------------------------+
void StatsRebuildFromHistory()
{
   g_statWins = g_statLoss = g_statTotal = 0;
   if(!HistorySelect(0, TimeCurrent()))
      return;
   const int n = HistoryDealsTotal();
   for(int i = 0; i < n; i++)
      StatsCountExitDeal(HistoryDealGetTicket(i));
}

//+------------------------------------------------------------------+
void RedrawChart(const string sym, const ENUM_TIMEFRAMES tf)
{
   DeleteObjectsByPrefix(OBJ_CH_PFX);

   string panel = StringFormat("MyICT | %s %s\n", sym, EnumToString(tf));
   panel += StateBlock() + "\n";
   if(InpUseSessionFilter && !IsTradeSessionAllowed())
      panel += "  >> Session CLOSED — không đặt lệnh mới\n";
   if(g_state == ICT_STATE_WAITING_TRIGGER && g_setup.valid)
   {
      const double rrPrev = CalcRiskReward(g_setup.isBuy, g_setup.entry, g_setup.sl, g_setup.tp);
      if(InpUseMinRR && rrPrev > 0.0 && rrPrev < InpMinRR - 1e-8)
         panel += StringFormat("  >> MSS OK nhưng R:R 1:%.2f < 1:%.1f — bỏ qua\n", rrPrev, InpMinRR);
      else
         panel += "  >> MSS setup OK — chờ limit breaker\n";
   }
   else if(g_state == ICT_STATE_LIMIT_ORDERED)
      panel += "  >> Limit breaker đang chờ khớp\n";
   panel += LayerBlock("BigTrend", InpBigSwingRange, g_big) + "\n";
   panel += LayerBlock("SmallTrend", InpSmallSwingRange, g_small);

   DrawPanel(panel);
   DrawLayer("BIG", g_big, InpClrBigHigh, InpClrBigLow, 2);
   DrawLayer("SML", g_small, InpClrSmallHigh, InpClrSmallLow, 1);
   DrawZones(sym, tf);

   if(g_state == ICT_STATE_LIMIT_ORDERED)
   {
      // giữ setup đã đặt limit
   }
   else if(g_state == ICT_STATE_WAITING_TRIGGER || g_state == ICT_STATE_PULLBACK)
   {
      IctMssSetup tmp;
      if(DetectMssSetup(sym, tf, tmp))
         g_setup = tmp;
      else if(g_state != ICT_STATE_WAITING_TRIGGER)
         g_setup.valid = false;
   }
   else
      g_setup.valid = false;

   DrawMssSetup(sym, tf);
   StatsUpdate();
   ChartRedraw(ActChart());
}

//+------------------------------------------------------------------+
void OnNewBar(const string sym)
{
   const ENUM_TIMEFRAMES tf = ChartTf();

   AnalyzeLayer(sym, tf, InpBigSwingRange, g_big);
   AnalyzeLayer(sym, tf, InpSmallSwingRange, g_small);

   if(g_big.hasH0 && g_big.hasL0)
      CalcBigWaveZone(sym, tf);

   UpdateStateMachine(sym, tf);
   RedrawChart(sym, tf);

   Comment(StringFormat("MyICT | %s\n%s\nBig: %s | Small: %s",
                        StateText(g_state),
                        g_biasBuy && (g_state == ICT_STATE_PULLBACK || g_state == ICT_STATE_WAITING_TRIGGER)
                           ? "Bias BUY" : (!g_biasBuy && IsPullbackStructure() ? "Bias SELL" : ""),
                        TrendText(g_big.trend),
                        TrendText(g_small.trend)));
}

//+------------------------------------------------------------------+
int OnInit()
{
   g_lastBar = 0;
   g_lastTriggerBar = 0;
   g_limitPlacedBar = 0;
   ZeroMemory(g_setup);
   g_state = ICT_STATE_NO_TREND;
   g_statePrev = ICT_STATE_NO_TREND;

   g_hAtr = iATR(_Symbol, ChartTf(), InpATRPeriod);
   if(g_hAtr == INVALID_HANDLE)
   {
      Print("[MyICT] Không tạo ATR");
      return INIT_FAILED;
   }

   g_trade.SetExpertMagicNumber(InpMagic);
   g_trade.SetDeviationInPoints(InpSlippagePoints);
   SetTradeFilling();

   StatsRebuildFromHistory();
   OnNewBar(_Symbol);
   Print("[MyICT] Init state=", StateText(g_state));
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   DeleteObjectsByPrefix(OBJ_CH_PFX);
   ObjectDelete(ActChart(), STAT_LINE1);
   ObjectDelete(ActChart(), STAT_LINE2);
   if(g_hAtr != INVALID_HANDLE)
      IndicatorRelease(g_hAtr);
   Comment("");
}

//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
{
   if(trans.type != TRADE_TRANSACTION_DEAL_ADD)
      return;

   const ulong deal = trans.deal;
   if(deal == 0 || !HistoryDealSelect(deal))
      return;
   if(HistoryDealGetString(deal, DEAL_SYMBOL) != _Symbol)
      return;
   if((ulong)HistoryDealGetInteger(deal, DEAL_MAGIC) != InpMagic)
      return;

   const long entry = HistoryDealGetInteger(deal, DEAL_ENTRY);
   if(entry != DEAL_ENTRY_OUT)
      return;

   StatsCountExitDeal(deal);
   g_state = ICT_STATE_NONE;
   Dbg("OnTradeTransaction → NONE (đóng lệnh)");
   RedrawChart(_Symbol, ChartTf());
}

//+------------------------------------------------------------------+
void RefreshZoneDraw(const string sym, const ENUM_TIMEFRAMES tf)
{
   if(!g_big.hasH0 || !g_big.hasL0)
      return;
   CalcBigWaveZone(sym, tf);
   if(InpDrawZones && g_zone.valid)
   {
      DrawZones(sym, tf);
      ChartRedraw(ActChart());
   }
}

//+------------------------------------------------------------------+
void OnTick()
{
   const string sym = _Symbol;
   const ENUM_TIMEFRAMES tf = ChartTf();
   const datetime t0 = iTime(sym, tf, 0);
   if(t0 == 0)
      return;

   if(t0 != g_lastBar)
   {
      g_lastBar = t0;
      OnNewBar(sym);
      return;
   }

   RefreshZoneDraw(sym, tf);
   ManagePendingLimits(sym, tf);
}

//+------------------------------------------------------------------+
ENUM_ICT_STATE GetIctState()     { return g_state; }
ENUM_ICT_TREND GetBigTrend()     { return g_big.trend; }
ENUM_ICT_TREND GetSmallTrend()   { return g_small.trend; }