//+------------------------------------------------------------------+
//|                                              MarketReplay.mq5    |
//|   v9.10 - Tick engine | Pending orders | Speed slider | Trades   |
//|   Virtual microsecond clock (0.1 ms grid), tick-by-tick SL/TP,   |
//|   fire-on-press UI, right-click Limit/Stop orders, floating table |
//+------------------------------------------------------------------+
#property copyright "Grok Replay"
#property version   "9.10"
#property strict
#property description "Tick-level Market Replay with Limit/Stop orders, speed slider, calendar range picker and Trades window"

//=== ENUM ==========================================================
enum ENUM_TRADE_MODE
{
   MODE_SINGLE     = 0,   // Single Trade  |  تک‌معامله
   MODE_MARTINGALE = 1    // Martingale Basket  |  سبد مارتینگل
};

//=== INPUTS (Bilingual) ============================================
input group "══════  [1] ACCOUNT & TRADE MODE  |  حساب و حالت معامله  ══════"
input double           InpBalance         = 500.0;           // Starting Balance  |  موجودی اولیه
input ENUM_TRADE_MODE  InpTradeMode       = MODE_MARTINGALE; // Trade Mode  |  حالت معامله
input double           InpLot             = 0.02;            // Initial Lot (editable in panel)  |  لات اولیه (در پنل قابل تغییر است)
input double           InpLotMin          = 0.01;            // Minimum Lot  |  حداقل لات
input double           InpLotMax          = 100.0;           // Maximum Lot  |  حداکثر لات
input double           InpLotStep         = 0.01;            // Lot Step  |  گام تغییر لات

input group "══════  [2] INSTRUMENT & COSTS  |  مشخصات نماد و هزینه‌ها  ══════"
input double           InpPoint           = 0.01;            // Point Size (Gold = 0.01)  |  اندازه‌ی یک پوینت (طلا = 0.01)
input double           InpContractSize    = 100.0;           // Contract Size (Gold = 100)  |  اندازه‌ی قرارداد (طلا = 100)
input int              InpSpreadPts       = 26;              // Fixed Spread in points (0 = none)  |  اسپرد ثابت به پوینت (صفر = بدون اسپرد)

input group "══════  [3] LEVERAGE & MARGIN  |  لوریج و مارجین  ══════"
input int              InpLeverage        = 500;             // Leverage 1:X (editable in panel)  |  لوریج ۱:X (در پنل قابل تغییر است)
input double           InpStopOutPct      = 50.0;            // Stop-out Margin Level %  |  سطح استاپ‌اوت (درصد)
input bool             InpAutoReset       = true;            // Auto-reset Balance on Stop-out  |  ریست خودکار بالانس هنگام استاپ‌اوت

input group "══════  [4] SINGLE TRADE MODE  |  حالت تک‌معامله  ══════"
input int              InpSLpts           = 150;             // Stop Loss in points  |  حد ضرر (پوینت)
input int              InpTPpts           = 300;             // Take Profit in points  |  حد سود (پوینت)
input bool             InpTrailing        = true;            // Enable Trailing Stop  |  فعال‌سازی تریلینگ استاپ
input int              InpTrailStart      = 170;             // Trailing Start in points of profit  |  شروع تریلینگ (پوینت سود)
input int              InpTrailStep       = 50;              // Trailing Step in points  |  فاصله‌ی تریلینگ از قیمت (پوینت)

input group "══════  [5] MARTINGALE BASKET MODE  |  حالت سبد مارتینگل  ══════"
input int              InpMartTPpts       = 300;             // Basket Take Profit in points  |  حد سود سبد (پوینت از میانگین ورود)
input int              InpMartTrailStart  = 170;             // Basket Trailing Start in points  |  شروع تریلینگ سبد (پوینت)
input int              InpMartTrailStep   = 50;              // Basket Trailing Step in points  |  فاصله‌ی تریلینگ سبد (پوینت)
input double           InpMartMultiplier  = 1.0;             // Lot Multiplier after a Loss  |  ضریب افزایش لات پس از ضرر
input int              InpMartMaxLevels   = 40;              // Maximum Martingale Levels  |  بیشترین سطح مارتینگل

input group "══════  [6] TICK ENGINE & SPEED  |  موتور تیک و سرعت  ══════"
input ENUM_TIMEFRAMES  InpBaseTF          = PERIOD_M1;       // Base Data Timeframe (finest)  |  تایم‌فریم پایه‌ی داده (ریزترین)
input int              InpMinTicks        = 8;               // Minimum Ticks per Bar  |  کمترین تعداد تیک در هر کندل
input int              InpMaxTicks        = 1200;            // Maximum Ticks per Bar  |  بیشترین تعداد تیک در هر کندل
input double           InpPathNoise       = 0.5;             // Intrabar Path Noise 0..1  |  نویز مسیر قیمت داخل کندل (۰ تا ۱)
input int              InpUiMs            = 40;              // Panel Refresh in ms  |  بازه‌ی به‌روزرسانی پنل (میلی‌ثانیه)
input bool             InpFireOnPress     = true;            // Fire Buttons on Mouse-Down  |  اجرای دکمه‌ها هنگام فشردن ماوس

input group "══════  [7] CHART LINES  |  خطوط روی چارت  ══════"
input color            InpColEntry        = clrDodgerBlue;   // Entry / Pending Line Colour  |  رنگ خط ورود و سفارش‌های Pending
input color            InpColSL           = clrRed;          // Stop Loss Line Colour  |  رنگ خط حد ضرر
input color            InpColTP           = clrLimeGreen;    // Take Profit Line Colour  |  رنگ خط حد سود

input group "══════  [8] DATA & HISTORY  |  داده و تاریخچه  ══════"
input int              InpHistoryBars     = 30000;           // Base Bars Shown before Start  |  تعداد کندل پایه پیش از نقطه‌ی شروع
input int              InpBarsToSave      = 300000;          // Max Bars to Save per Timeframe  |  حداکثر کندل ذخیره برای هر تایم‌فریم
input int              InpBarsToLoad      = 150000;          // Max Bars to Load per Timeframe  |  حداکثر کندل بارگذاری برای هر تایم‌فریم
input bool             InpResaveOnInit    = true;            // Re-export History on Every Start  |  ذخیره‌ی دوباره‌ی تاریخچه در هر اجرا

//=== Types =========================================================
struct Pos
{
   ulong    ticket;
   int      dir;          // +1 BUY, -1 SELL
   double   lots, open, sl, tp;
   datetime time;
   bool     open_;
   int      level;
};

struct Ord               // pending order
{
   ulong    ticket;
   int      type;         // 1 BuyLimit, 2 SellLimit, 3 BuyStop, 4 SellStop
   double   price, lots;
   datetime time;
   bool     live;
};

struct HEv               // trade-history mark queued for drawing
{
   ulong    ticket;
   int      kind;         // 0 open, 1 close
   int      dir;
   datetime t, t0;
   double   price, p0, profit;
   int      part;         // 0 = normal event, >0 = partial-close sequence number
   double   lots;         // closed volume (partial close marks)
};

//=== Globals =======================================================
string   baseSym, customSym, folderName;
string   P = "RP_";
long     panelChart = 0;
bool     ready = false;

ENUM_TIMEFRAMES usedTF    = PERIOD_M1;
ENUM_TIMEFRAMES currentTF = PERIOD_M5;

bool     playing   = false;
double   speedMult = 1.0;
double   lotSize   = 0.10;
bool     editing = false;
int      leverage = 500, slPts = 0, tpPts = 0;
double   resetBal = 10000.0;
bool     trailOn = true;
int      trStart = 170, trStep = 50;
int      dragKind = 0; ulong dragTicket = 0; double dragPrice = 0, dragPrice0 = 0; string dragName = "";
bool     modOpen = false; ulong modTicket = 0; int modX = 0, modY = 0;
const int MOD_W = 300, MOD_H = 150;
bool     volOpen = false; ulong volTicket = 0; int volX = 0, volY = 0;   // Volume (partial close) popup
HEv      hev[]; string hDrawn[]; datetime curTime = 0;
int      partSeq = 0;
int      cur = 0, total = 0, endBar = 0;
double   bal = 0, eq = 0;
MqlRates rates[];                 // base series (replayed)
MqlRates cser[];                  // coarser TF series concatenated (history stitching)
int      cOff[8], cCnt[8]; ENUM_TIMEFRAMES cTF[8]; int cK = 0;
int      digitsN = 2;
double   spreadPx = 0;

// --- tick engine
double   barDurUs  = 60e6;
double   tkOff[];
double   tkBid[];
double   wkb[];
int      tkN = 0, tkIdx = 0;
double   barClockUs = 0;
ulong    lastUs = 0;
ulong    lastUiUs = 0;
double   curBid = 0, curAsk = 0;
MqlTick  outTk[];
int      outN = 0;
ulong    rngS = 88172645463325252;
const double BUDGET_US = 8000.0;

// --- UI flags
bool     uiForce = false, linesDirty = true, btnDirty = true, needCompact = false, ordCompact = false;
bool     mouseDown = false, rightDown = false;
string   lastMsg = "";
string   pendLog = "";
string   pressId = ""; ulong pressMs = 0;

// --- registry of clickable panel buttons
string   rId[48]; int rX[48], rY[48], rW[48], rH[48]; int rN = 0;
int      panW = 480, panH = 400;

// --- label cache (avoid redundant ObjectSet calls)
string   lcT[40]; color lcC[40];
const int K_BAL=0,K_EQ=1,K_FLO=2,K_POS=3,K_TD=4,K_YD=5,K_WK=6,K_MO=7,K_LOTS=8,K_MODE=9,K_INFO=10,K_INFO2=11,
          K_MSG=12,K_SELL=13,K_BUY=14,K_SPEED=15,K_SPR=16,K_MG=17,K_FM=18,K_ML=19,K_LI=20;

// --- speed slider
const double SPD_MIN=0.1, SPD_MAX=1000.0;
const int    SL_TH=14, SL_H=24;
int      slX=0, slY=0, slW=262;
bool     sliderDrag = false;

// --- calendar popup
const int CAL_HDR=32, CAL_WK=22, CAL_CW=36, CAL_CH=28;
bool     calOpen=false; int calTarget=0, calYear=2026, calMon=1;
int      calX=0, calY=0, calW=7*36+16, calH=32+22+6*28+36;
int      dateRowY=0, fromFieldX=0, toFieldX=0;
datetime calDate[42]; bool calOn[42];
datetime selFrom=0, selTo=0, dataFirst=0, dataLast=0; bool selDirty=false;
string   MonName[12]={"January","February","March","April","May","June","July","August","September","October","November","December"};

// --- right-click context menu
bool     ctxOpen=false; double ctxPrice=0; int ctxX=0, ctxY=0, ctxN=0;
string   ctxId[4]; int ctxRY[4];
const int CTX_W=250, CTX_ROW=26;

// --- Trades window
bool     trOpen=false; int trX=60, trY=120, trW=700, trH=250, trTop=0;
bool     trDrag=false, trSize=false, trSizeDirty=false; int trDX=0, trDY=0; ulong trSizeUs=0;
const int TR_TITLE=24, TR_HEAD=28, TR_FOOT=36, TR_ROWH=22, TR_MAXROWS=40;
string   twN[600]; int twOX[600], twOY[600]; int twCnt=0;
string   twC[500]; color twCC[500];
int      twKind[800], twIdx[800], twRows=0, twVis=0;

// --- stats
double   dayProfit = 0, ydayProfit = 0, weekProfit = 0, monthProfit = 0;
double   dayLots = 0, weekLots = 0, monthLots = 0;
datetime lastDay = 0, lastWeek = 0, lastMonth = 0;
double   closedToday = 0;

// --- positions & orders
Pos      pos[];
Ord      ords[];
int      openCnt = 0, ordLive = 0;
ulong    nextT = 1;

// --- martingale
int      martLevel = 0;
int      martDir = 0;
double   basketAvg = 0, basketLots = 0, basketSL = 0, basketTP = 0;
int      bDir = 0;
bool     basketTrailActive = false;

//+------------------------------------------------------------------+
//| Helpers                                                          |
//+------------------------------------------------------------------+
string CleanBase(string sym)
{
   while(StringFind(sym,"REPLAY_")==0) sym = StringSubstr(sym,7);
   StringReplace(sym,"+",""); StringReplace(sym,".","");
   int len=StringLen(sym);
   if(len>0){ string last=StringSubstr(sym,len-1,1);
      if(last=="m"||last=="c"||last=="p") sym=StringSubstr(sym,0,len-1); }
   if(StringLen(sym)<3) sym="XAUUSD";
   return sym;
}
string TFName(ENUM_TIMEFRAMES tf)
{
   if(tf==PERIOD_M1)  return "M1";  if(tf==PERIOD_M5)  return "M5";
   if(tf==PERIOD_M15) return "M15"; if(tf==PERIOD_M30) return "M30";
   if(tf==PERIOD_H1)  return "H1";  if(tf==PERIOD_H4)  return "H4";
   if(tf==PERIOD_D1)  return "D1";  if(tf==PERIOD_W1)  return "W1";  return "M5";
}
string StatePath(){ return folderName+"\\state.bin"; }

double Rnd()
{
   rngS ^= rngS >> 12;
   rngS ^= rngS << 25;
   rngS ^= rngS >> 27;
   ulong r = rngS * 2685821657736338717;
   return (double)(r >> 11) * (1.0/9007199254740992.0);
}
void SeedRng(ulong s)
{
   rngS = s * 6364136223846793005 + 1442695040888963407;
   if(rngS==0) rngS = 88172645463325252;
   for(int i=0;i<4;i++) Rnd();
}
string Px(const double v){ return DoubleToString(v,digitsN); }
double CalcProfit(const int dir,const double open,const double lots,const double price)
{
   double m = (dir>0) ? (price-open) : (open-price);
   return NormalizeDouble(m * lots * InpContractSize, 2);
}

// MT5-style money text: 10 000.00
string Money(const double v)
{
   string s=DoubleToString(MathAbs(v),2);
   int dot=StringFind(s,".");
   string ip=StringSubstr(s,0,dot), fp=StringSubstr(s,dot);
   string o="";
   int L=StringLen(ip);
   for(int i=0;i<L;i++){ if(i>0 && (L-i)%3==0) o+=" "; o+=StringSubstr(ip,i,1); }
   return (v<0?"-":"")+o+fp;
}
string MoneyS(const double v){ return (v>0?"+":"")+Money(v); }
color PnlCol(const double v){ return (v>0.004)?C'90,225,130':((v<-0.004)?C'255,100,100':clrWhite); }

//+------------------------------------------------------------------+
//| Init / Deinit                                                    |
//+------------------------------------------------------------------+
int OnInit()
{
   panelChart = ChartID();
   baseSym    = CleanBase(_Symbol);
   customSym  = "REPLAY_"+baseSym;
   folderName = "Custom_"+baseSym;
   digitsN    = (int)MathRound(-MathLog10(MathMax(InpPoint,1e-8)));
   if(digitsN<0) digitsN=0; if(digitsN>8) digitsN=8;
   spreadPx   = InpSpreadPts*InpPoint;
   lotSize    = MathMax(InpLotMin,MathMin(InpLotMax,InpLot));
   leverage   = MathMax(1,InpLeverage);
   resetBal   = InpBalance;
   slPts      = InpSLpts;
   tpPts      = (InpTradeMode==MODE_SINGLE)?InpTPpts:InpMartTPpts;
   trailOn    = (InpTradeMode==MODE_SINGLE)?InpTrailing:(InpMartTrailStart>0);
   trStart    = (InpTradeMode==MODE_SINGLE)?InpTrailStart:InpMartTrailStart;
   trStep     = (InpTradeMode==MODE_SINGLE)?InpTrailStep:InpMartTrailStep;
   ready=false;

   Print("=== MarketReplay v9.10 | Mode: ",(InpTradeMode==MODE_SINGLE?"Single":"Martingale")," ===");
   FolderCreate(folderName,0);

   // --- Stage 1: broker symbol -> export all TFs, create custom symbol, switch chart
   if(_Symbol!=customSym)
   {
      SaveSource();
      if(!SetupCustom()){ Alert("Symbol error | خطا سمبل"); return INIT_FAILED; }
      if(!ChartSetSymbolPeriod(panelChart,customSym,_Period))
         Alert("Open a chart of ",customSym," and attach the EA there | چارت ",customSym," را باز و اکسپرت را روی آن بگذارید");
      return INIT_SUCCEEDED;
   }

   // --- Stage 2: running on REPLAY_ symbol
   if(!SetupCustom()){ Alert("Symbol error | خطا سمبل"); return INIT_FAILED; }
   ArrayResize(tkOff,InpMaxTicks+16);
   ArrayResize(tkBid,InpMaxTicks+16);
   ArrayResize(wkb,InpMaxTicks+16);
   ArrayResize(outTk,256);
   if(!LoadBase()){ Alert("No data | داده‌ای یافت نشد"); return INIT_FAILED; }
   barDurUs  = (double)PeriodSeconds(usedTF)*1e6;
   dataFirst = DayStart(rates[0].time); dataLast = DayStart(rates[total-1].time);
   currentTF = (ENUM_TIMEFRAMES)_Period;

   ChartSetInteger(panelChart,CHART_MODE,CHART_CANDLES);
   ChartSetInteger(panelChart,CHART_SHOW_GRID,false);
   ChartSetInteger(panelChart,CHART_AUTOSCROLL,true);
   ChartSetInteger(panelChart,CHART_SHIFT,true);
   ChartSetInteger(panelChart,CHART_SHOW_BID_LINE,true);
   ChartSetInteger(panelChart,CHART_SHOW_ASK_LINE,true);
   ChartSetInteger(panelChart,CHART_COLOR_BID,clrDodgerBlue);
   ChartSetInteger(panelChart,CHART_COLOR_ASK,clrRed);
   ChartSetInteger(panelChart,CHART_SHOW_OBJECT_DESCR,true);
   ChartSetInteger(panelChart,CHART_CONTEXT_MENU,false);         // our own right-click menu
   ChartSetInteger(panelChart,CHART_EVENT_MOUSE_MOVE,true);

   if(!TryRestoreState())
   {
      bal=InpBalance; eq=bal;
      ResetTradeState(true);
      endBar=total-1;
      StartAt(MathMax(1,total/5));
      selFrom=DayStart(rates[cur].time); selTo=dataLast; selDirty=false;
   }
   if(selFrom<=0) selFrom=DayStart(rates[MathMin(cur,total-1)].time);
   if(selTo<=0)   selTo=dataLast;

   BuildPanel();
   if(trOpen){ BuildTrades(); }
   ready=true;
   btnDirty=true; linesDirty=true;
   lastUs=GetMicrosecondCount();
   EventSetMillisecondTimer(playing?1:10);
   UpdateUI();
   Print("Ready | آماده | Bars: ",total," | Base TF: ",TFName(usedTF)," | Ticks/bar up to ",InpMaxTicks);
   return INIT_SUCCEEDED;
}

void OnDeinit(const int reason)
{
   EventKillTimer();
   if(ready && reason==REASON_CHARTCHANGE) SaveState();
   if(reason!=REASON_CHARTCHANGE)
   {
      ChartSetInteger(panelChart,CHART_CONTEXT_MENU,true);
      ChartSetInteger(panelChart,CHART_EVENT_MOUSE_MOVE,false);
      ObjectsDeleteAll(panelChart,"RPH_");
   }
   ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,true);
   ObjectsDeleteAll(panelChart,P);
   ready=false;
}

//+------------------------------------------------------------------+
//| Timer: the heart of the replay                                   |
//+------------------------------------------------------------------+
void OnTimer()
{
   if(!ready) return;
   ulong nowUs = GetMicrosecondCount();
   if(playing)
   {
      double dt = (double)(nowUs - lastUs);
      lastUs = nowUs;
      if(dt > 1000000.0) dt = 1000000.0;
      Advance(dt * speedMult);
   }
   else lastUs = nowUs;

   if(trSizeDirty && (nowUs-trSizeUs)>=60000)
   {
      trSizeUs=nowUs; trSizeDirty=false;
      BuildTrades(); RefreshTrades(); ChartRedraw(panelChart);
   }
   if(uiForce || (nowUs - lastUiUs) >= (ulong)InpUiMs*1000)
   {
      lastUiUs = nowUs;
      UpdateUI();
   }
}

//+------------------------------------------------------------------+
//| Advance the virtual clock by addUs and emit every due tick       |
//+------------------------------------------------------------------+
void Advance(const double addUs)
{
   if(tkN<=0) return;
   ulong t0 = GetMicrosecondCount();
   barClockUs += addUs;
   outN = 0;

   while(true)
   {
      while(tkIdx<tkN && tkOff[tkIdx]<=barClockUs)
      {
         EmitTick(tkIdx);
         tkIdx++;
         if(outN>=256) FlushTicks();
      }
      if(tkIdx>=tkN && barClockUs>=barDurUs)
      {
         if(cur>=endBar)
         {
            playing=false; btnDirty=true; barClockUs=barDurUs;
            EventSetMillisecondTimer(10);
            break;
         }
         barClockUs -= barDurUs;          // carry remainder => zero drift
         cur++;
         UpdateStatsPeriod(rates[cur].time);
         BuildBarTicks(cur);
         tkIdx = 0;
         if((double)(GetMicrosecondCount()-t0) > BUDGET_US) break;   // keep UI responsive
         continue;
      }
      break;
   }
   FlushTicks();
}

void EmitTick(const int i)
{
   curBid = tkBid[i];
   curAsk = curBid + spreadPx;
   ulong msc = (ulong)rates[cur].time*1000 + (ulong)(tkOff[i]/1000.0);

   MqlTick t;
   t.time        = (datetime)(msc/1000);
   curTime       = t.time;
   t.time_msc    = (long)msc;
   t.bid         = curBid;
   t.ask         = curAsk;
   t.last        = 0;
   t.volume      = 0;
   t.volume_real = 0;
   t.flags       = TICK_FLAG_BID|TICK_FLAG_ASK;
   outTk[outN++] = t;

   if(openCnt>0 || ordLive>0) ManageTick(curBid,curAsk);       // SL/TP/trailing on EVERY tick
}
void FlushTicks()
{
   if(outN>0){ CustomTicksAdd(customSym,outTk,(uint)outN); outN=0; }
}
void BuildBarTicks(const int idx)
{
   double o=rates[idx].open, h=rates[idx].high, l=rates[idx].low, c=rates[idx].close;
   if(h<MathMax(o,c)) h=MathMax(o,c);
   if(l>MathMin(o,c)) l=MathMin(o,c);

   int minT=MathMax(4,InpMinTicks);
   int maxT=MathMax(minT,InpMaxTicks);
   int n=(int)rates[idx].tick_volume;
   if(n<minT) n=minT;
   if(n>maxT) n=maxT;

   double rng=h-l;
   SeedRng((ulong)rates[idx].time);

   if(rng<=0.0)
   {
      n=2;
      tkBid[0]=NormalizeDouble(o,digitsN);
      tkBid[1]=NormalizeDouble(c,digitsN);
      tkOff[0]=0; tkOff[1]=MathFloor(barDurUs*0.5/100.0)*100.0;
      tkN=2; return;
   }

   double wp[4];
   wp[0]=o;
   if(c>=o){ wp[1]=l; wp[2]=h; } else { wp[1]=h; wp[2]=l; }
   wp[3]=c;

   // distribute ticks over the 3 legs proportionally to their length
   int rem=n-1, m[3]; double len[3]; double S=0; int big=0;
   for(int k=0;k<3;k++){ len[k]=MathAbs(wp[k+1]-wp[k]); S+=len[k]; if(len[k]>len[big]) big=k; }
   int extra=rem-3, used=0;
   for(int k=0;k<3;k++){ m[k]=1+(int)MathFloor(extra*len[k]/S); used+=m[k]; }
   m[big]+=rem-used;

   tkBid[0]=NormalizeDouble(o,digitsN);
   int w=1;
   for(int k=0;k<3;k++)
   {
      int mk=m[k]; double p0=wp[k], p1=wp[k+1];
      double sigma=InpPathNoise*rng/MathSqrt((double)mk);
      double acc=0;
      for(int s=1;s<=mk;s++){ acc+=(Rnd()*2.0-1.0)*1.7320508*sigma; wkb[s]=acc; }
      double wm=wkb[mk];
      for(int s=1;s<=mk;s++)
      {
         double px;
         if(s==mk) px=p1;                                  // legs end exactly on O/H/L/C
         else
         {
            px=p0+(p1-p0)*s/mk+(wkb[s]-wm*s/mk);           // Brownian bridge
            if(px>h) px=h;
            if(px<l) px=l;
         }
         tkBid[w++]=NormalizeDouble(px,digitsN);
      }
   }

   // Poisson (exponential) inter-arrival times, snapped to 100us
   tkOff[0]=0;
   double cum=0;
   for(int i=1;i<=n;i++)
   {
      double u=Rnd(); if(u<1e-12) u=1e-12;
      cum+=-MathLog(u);
      if(i<n) tkOff[i]=cum;
   }
   double scale=barDurUs*0.999/cum;
   for(int i=1;i<n;i++) tkOff[i]=MathFloor(tkOff[i]*scale/100.0)*100.0;
   tkN=n;
}

//+------------------------------------------------------------------+
//| Per-tick trade management                                        |
//+------------------------------------------------------------------+
void ManageTick(const double bid,const double ask)
{
   const double pt=InpPoint;
   if(ordLive>0) CheckOrders(bid,ask);
   if(openCnt>0 && StopOutHit()){ DoStopOut(); return; }

   if(InpTradeMode==MODE_SINGLE)
   {
      for(int i=ArraySize(pos)-1;i>=0;i--)
      {
         if(!pos[i].open_) continue;
         if(pos[i].dir>0)
         {
            if(pos[i].sl>0 && bid<=pos[i].sl){ ClosePos(i,bid); continue; }
            if(pos[i].tp>0 && bid>=pos[i].tp){ ClosePos(i,pos[i].tp); continue; }
            if(trailOn && trStart>0 && (bid-pos[i].open)/pt>=trStart)
            {
               double ns=NormalizeDouble(bid-trStep*pt,digitsN);
               if(ns>pos[i].sl){ pos[i].sl=ns; linesDirty=true; }
            }
         }
         else
         {
            if(pos[i].sl>0 && ask>=pos[i].sl){ ClosePos(i,ask); continue; }
            if(pos[i].tp>0 && ask<=pos[i].tp){ ClosePos(i,pos[i].tp); continue; }
            if(trailOn && trStart>0 && (pos[i].open-ask)/pt>=trStart)
            {
               double ns=NormalizeDouble(ask+trStep*pt,digitsN);
               if(pos[i].sl==0 || ns<pos[i].sl){ pos[i].sl=ns; linesDirty=true; }
            }
         }
      }
      return;
   }

   // ===== Martingale basket =====
   if(basketLots<=0 || bDir==0) return;
   if(bDir>0)
   {
      if(bid>=basketTP){ CloseBasket(basketTP); return; }
      if(trailOn && trStart>0)
      {
         double pts=(bid-basketAvg)/pt;
         if(!basketTrailActive && pts>=trStart)
         { basketTrailActive=true; basketSL=NormalizeDouble(bid-trStep*pt,digitsN); linesDirty=true; }
         if(basketTrailActive)
         {
            double ns=NormalizeDouble(bid-trStep*pt,digitsN);
            if(ns>basketSL){ basketSL=ns; linesDirty=true; }
            if(bid<=basketSL){ CloseBasket(bid); return; }
         }
      }
   }
   else
   {
      if(ask<=basketTP){ CloseBasket(basketTP); return; }
      if(trailOn && trStart>0)
      {
         double pts=(basketAvg-ask)/pt;
         if(!basketTrailActive && pts>=trStart)
         { basketTrailActive=true; basketSL=NormalizeDouble(ask+trStep*pt,digitsN); linesDirty=true; }
         if(basketTrailActive)
         {
            double ns=NormalizeDouble(ask+trStep*pt,digitsN);
            if(ns<basketSL || basketSL==0){ basketSL=ns; linesDirty=true; }
            if(ask>=basketSL){ CloseBasket(ask); return; }
         }
      }
   }
}

string OrdTypeName(const int t)
{
   if(t==1) return "buy limit";  if(t==2) return "sell limit";
   if(t==3) return "buy stop";   return "sell stop";
}

// pending orders trigger on Ask (buy) / Bid (sell), exactly like a real server
void CheckOrders(const double bid,const double ask)
{
   for(int i=0;i<ArraySize(ords);i++)
   {
      if(!ords[i].live) continue;
      int t=ords[i].type; double pr=ords[i].price; double fp=pr; bool hit=false;
      if(t==1 && ask<=pr){ hit=true; fp=MathMin(pr,ask); }
      else if(t==3 && ask>=pr){ hit=true; fp=ask; }
      else if(t==2 && bid>=pr){ hit=true; fp=MathMax(pr,bid); }
      else if(t==4 && bid<=pr){ hit=true; fp=bid; }
      if(!hit) continue;
      ords[i].live=false; ordLive--; ordCompact=true; linesDirty=true;
      int dir=(t==1||t==3)?1:-1;
      if(!OpenPos(dir,fp,ords[i].lots,ords[i].ticket))
         pendLog+=StringFormat("Pending #%I64u cancelled (blocked)\n",ords[i].ticket);
      else
         pendLog+=StringFormat("Pending #%I64u %s filled @ %s\n",ords[i].ticket,OrdTypeName(t),Px(fp));
   }
}

void ClosePos(const int i,const double price)
{
   double pr=CalcProfit(pos[i].dir,pos[i].open,pos[i].lots,price);
   bal+=pr; dayProfit+=pr; weekProfit+=pr; monthProfit+=pr; closedToday+=pr;
   AddHevClose(pos[i],price,pr);
   pos[i].open_=false; openCnt--;
   needCompact=true; linesDirty=true;
   pendLog+=StringFormat("Closed #%I64u %s @ %s P/L=%+.2f\n",pos[i].ticket,(pos[i].dir>0?"BUY":"SELL"),Px(price),pr);
}
void CloseBasket(const double price)
{
   double totalPr=0;
   for(int i=0;i<ArraySize(pos);i++)
   {
      if(!pos[i].open_) continue;
      double pp=CalcProfit(pos[i].dir,pos[i].open,pos[i].lots,price);
      totalPr+=pp;
      AddHevClose(pos[i],price,pp);
      pos[i].open_=false;
   }
   openCnt=0; needCompact=true; linesDirty=true;
   bal+=totalPr; dayProfit+=totalPr; weekProfit+=totalPr; monthProfit+=totalPr; closedToday+=totalPr;

   if(totalPr<0) martLevel=MathMin(martLevel+1,InpMartMaxLevels);
   else { martLevel=0; martDir=0; }

   basketAvg=0; basketLots=0; basketSL=0; basketTP=0; bDir=0; basketTrailActive=false;
   pendLog+=StringFormat("Basket closed @ %s P/L=%+.2f | Next level=%d\n",Px(price),totalPr,martLevel);
}
void CalcBasketAvg()
{
   basketAvg=0; basketLots=0; bDir=0;
   double sum=0;
   for(int i=0;i<ArraySize(pos);i++)
   {
      if(!pos[i].open_) continue;
      if(bDir==0) bDir=pos[i].dir;
      sum+=pos[i].open*pos[i].lots;
      basketLots+=pos[i].lots;
   }
   if(basketLots>0)
   {
      basketAvg=NormalizeDouble(sum/basketLots,digitsN);
      basketTP=NormalizeDouble(basketAvg+bDir*tpPts*InpPoint,digitsN);
   }
   else { basketSL=0; basketTP=0; basketTrailActive=false; }
}

//+------------------------------------------------------------------+
//| Leverage / margin / stop-out / balance control                   |
//+------------------------------------------------------------------+
void Account(double &flo,double &used)
{
   flo=0; used=0;
   for(int i=0;i<ArraySize(pos);i++)
   {
      if(!pos[i].open_) continue;
      flo+=CalcProfit(pos[i].dir,pos[i].open,pos[i].lots,pos[i].dir>0?curBid:curAsk);
      used+=pos[i].lots*InpContractSize*pos[i].open/leverage;
   }
}

double FreeMargin()
{
   double f,u; Account(f,u);
   return bal+f-u;
}

// largest lot (on lot-step grid) that the free margin can afford at this price
double MaxLotFor(const double freeM,const double price)
{
   if(freeM<=0 || price<=0) return 0.0;
   double lot=freeM*leverage/(InpContractSize*price);
   double st=MathMax(InpLotStep,0.0001);
   lot=MathFloor(lot/st+1e-9)*st;
   lot=MathMin(lot,InpLotMax);
   if(lot<InpLotMin) return 0.0;
   return NormalizeDouble(lot,2);
}

bool StopOutHit()
{
   double f,u; Account(f,u);
   if(u<=0) return false;
   return ((bal+f)/u*100.0 < InpStopOutPct);
}

void DoStopOut()
{
   double f,u; Account(f,u);
   pendLog+=StringFormat("STOP OUT: margin level %.1f%% < %.0f%% | equity %s\n",(bal+f)/u*100.0,InpStopOutPct,Money(bal+f));
   CloseAll();
   for(int i=0;i<ArraySize(ords);i++) CancelOrder(i);
   martLevel=0; martDir=0;
   if(InpAutoReset)
   {
      bal=resetBal;
      lastMsg="STOP OUT - balance reset to "+Money(resetBal)+" | بالانس ریست شد";
   }
   else
   {
      lastMsg="STOP OUT - use Reset balance or + Deposit | مارجین کال";
      playing=false; btnDirty=true; EventSetMillisecondTimer(10);
   }
   uiForce=true;
}

void ResetBalance()
{
   CloseAll();
   for(int i=0;i<ArraySize(ords);i++) CancelOrder(i);
   martLevel=0; martDir=0;
   bal=resetBal;
   dayProfit=0; ydayProfit=0; weekProfit=0; monthProfit=0;
   dayLots=0; weekLots=0; monthLots=0; closedToday=0;
   lastMsg="Balance reset to "+Money(resetBal)+" | بالانس ریست شد";
   uiForce=true; linesDirty=true;
}

void Deposit()
{
   bal+=resetBal;
   lastMsg="Deposited "+Money(resetBal)+" | واریز شد";
   uiForce=true;
}

void ApplyLevText()
{
   string t=ObjectGetString(panelChart,P+"LEV",OBJPROP_TEXT);
   StringReplace(t,"1:",""); StringReplace(t," ","");
   long v=StringToInteger(t);
   if(v<1) v=leverage;
   if(v>5000) v=5000;
   leverage=(int)v;
   ObjectSetString(panelChart,P+"LEV",OBJPROP_TEXT,IntegerToString(leverage));
   lastMsg="Leverage set to 1:"+IntegerToString(leverage);
   uiForce=true;
}

void ApplySLTPText()
{
   long s=StringToInteger(ObjectGetString(panelChart,P+"SLP",OBJPROP_TEXT));
   long t=StringToInteger(ObjectGetString(panelChart,P+"TPP",OBJPROP_TEXT));
   if(s<0) s=0; if(t<0) t=0;
   slPts=(int)s; tpPts=(int)t;
   ObjectSetString(panelChart,P+"SLP",OBJPROP_TEXT,IntegerToString(slPts));
   ObjectSetString(panelChart,P+"TPP",OBJPROP_TEXT,IntegerToString(tpPts));
   lastMsg=StringFormat("SL=%d  TP=%d points (new trades)",slPts,tpPts);
   uiForce=true;
}

void ApplyBalText()
{
   string t=ObjectGetString(panelChart,P+"BALV",OBJPROP_TEXT);
   StringReplace(t,",","."); StringReplace(t," ","");
   double v=StringToDouble(t);
   if(v<=0) v=resetBal;
   resetBal=NormalizeDouble(v,2);
   ObjectSetString(panelChart,P+"BALV",OBJPROP_TEXT,DoubleToString(resetBal,2));
   uiForce=true;
}

void ApplySLTPOpen()
{
   if(InpTradeMode==MODE_SINGLE)
   {
      for(int i=0;i<ArraySize(pos);i++)
      {
         if(!pos[i].open_) continue;
         pos[i].sl=slPts>0?NormalizeDouble(pos[i].open-pos[i].dir*slPts*InpPoint,digitsN):0;
         pos[i].tp=tpPts>0?NormalizeDouble(pos[i].open+pos[i].dir*tpPts*InpPoint,digitsN):0;
      }
   }
   else { double sl=basketSL; bool ta=basketTrailActive; CalcBasketAvg(); basketSL=sl; basketTrailActive=ta; }
   linesDirty=true; uiForce=true;
   lastMsg="SL/TP applied to open positions | اعمال شد";
}

bool IsEditName(const string n)
{
   return (n==P+"LOT"||n==P+"LEV"||n==P+"SLP"||n==P+"TPP"||n==P+"BALV"||n==P+"TRS"||n==P+"TRP"||n==P+"MOD_SL"||n==P+"MOD_TP"||n==P+"VOL_V");
}

//+------------------------------------------------------------------+
//| BUY / SELL / pending - hot path, no UI work                      |
//+------------------------------------------------------------------+
bool OpenPos(const int dir,const double price,const double baseLots,const ulong useTicket)
{
   double lots=baseLots; int level=0;

   if(InpTradeMode==MODE_MARTINGALE)
   {
      if(openCnt>0 && martDir!=0 && martDir!=dir)
      { lastMsg="Opposite blocked - close basket first | جهت مخالف ممکن نیست، ابتدا سبد را ببندید"; uiForce=true; return false; }
      if(openCnt==0 && martDir!=dir) martLevel=0;
      martDir=dir;
      level=martLevel;
      int lv=MathMin(martLevel,InpMartMaxLevels);
      lots=NormalizeDouble(baseLots*MathPow(InpMartMultiplier,lv),2);
   }

   double need=lots*InpContractSize*price/leverage;
   double fm=FreeMargin();
   if(need>fm+1e-9)
   {
      lastMsg=StringFormat("Not enough margin: need %s, free %s | مارجین کافی نیست",Money(need),Money(fm));
      uiForce=true; return false;
   }

   Pos p;
   p.ticket=(useTicket>0)?useTicket:nextT++;
   p.dir=dir; p.lots=lots; p.open=price;
   p.time=rates[cur].time; p.open_=true; p.level=level;
   if(InpTradeMode==MODE_SINGLE)
   {
      p.sl=slPts>0 ? NormalizeDouble(price-dir*slPts*InpPoint,digitsN) : 0;
      p.tp=tpPts>0 ? NormalizeDouble(price+dir*tpPts*InpPoint,digitsN) : 0;
   }
   else { p.sl=0; p.tp=0; }

   int n=ArraySize(pos);
   ArrayResize(pos,n+1,64);
   pos[n]=p;
   openCnt++;
   AddHevOpen(p);

   dayLots+=lots; weekLots+=lots; monthLots+=lots;
   if(InpTradeMode==MODE_MARTINGALE){ CalcBasketAvg(); basketTrailActive=false; basketSL=0; }

   linesDirty=true; uiForce=true;
   lastMsg="";
   pendLog+=StringFormat("%s #%I64u Lot=%.2f @ %s\n",(dir>0?"BUY":"SELL"),p.ticket,lots,Px(price));
   return true;
}

void OpenTrade(const int dir)
{
   if(curBid<=0) return;
   OpenPos(dir,(dir>0)?curAsk:curBid,lotSize,0);
}

void PlaceOrder(const int type,const double price0)
{
   double price=NormalizeDouble(price0,digitsN);
   bool ok=false;
   if(type==1)      ok=(price<curAsk);
   else if(type==2) ok=(price>curBid);
   else if(type==3) ok=(price>curAsk);
   else if(type==4) ok=(price<curBid);
   if(!ok){ lastMsg="Invalid price for "+OrdTypeName(type)+" | قیمت نامعتبر"; uiForce=true; return; }

   Ord o;
   o.ticket=nextT++; o.type=type; o.price=price; o.lots=lotSize;
   o.time=rates[cur].time; o.live=true;
   int n=ArraySize(ords);
   ArrayResize(ords,n+1,16);
   ords[n]=o;
   ordLive++;
   linesDirty=true; uiForce=true;
   lastMsg=StringFormat("Placed %s %.2f @ %s",OrdTypeName(type),lotSize,Px(price));
   pendLog+=StringFormat("Order #%I64u %s %.2f @ %s\n",o.ticket,OrdTypeName(type),lotSize,Px(price));
}

void CancelOrder(const int i)
{
   if(i<0 || i>=ArraySize(ords) || !ords[i].live) return;
   ords[i].live=false; ordLive--; ordCompact=true; linesDirty=true; uiForce=true;
   pendLog+=StringFormat("Order #%I64u deleted\n",ords[i].ticket);
}

void CloseAll()
{
   if(openCnt<=0) return;
   if(InpTradeMode==MODE_SINGLE)
   {
      for(int i=ArraySize(pos)-1;i>=0;i--)
         if(pos[i].open_) ClosePos(i,pos[i].dir>0?curBid:curAsk);
   }
   else CloseBasket(bDir>0?curBid:curAsk);
   uiForce=true;
}

void SetLot(double v)
{
   v=MathMax(InpLotMin,MathMin(InpLotMax,v));
   double st=MathMax(InpLotStep,0.0001);
   v=NormalizeDouble(MathRound(v/st)*st,2);
   if(v<InpLotMin) v=InpLotMin;
   lotSize=v;
   ObjectSetString(panelChart,P+"LOT",OBJPROP_TEXT,DoubleToString(v,2));
   uiForce=true;
}

void ApplyLotText()
{
   string t=ObjectGetString(panelChart,P+"LOT",OBJPROP_TEXT);
   StringReplace(t,",","."); StringTrimLeft(t); StringTrimRight(t);
   double v=StringToDouble(t);
   if(v<=0) v=lotSize;
   SetLot(v);
}

//+------------------------------------------------------------------+
//| Events - everything fires on mouse-DOWN                          |
//+------------------------------------------------------------------+
string HitPanel(const int x,const int y)
{
   for(int i=0;i<rN;i++)
      if(x>=rX[i] && x<rX[i]+rW[i] && y>=rY[i] && y<rY[i]+rH[i]) return rId[i];
   return "";
}

bool InCal(const int x,const int y)
{
   return calOpen && x>=calX && x<calX+calW && y>=calY && y<calY+calH;
}
string HitCal(const int x,const int y)
{
   if(x>=calX+6 && x<calX+34 && y>=calY+4 && y<calY+28) return "CAL_PREV";
   if(x>=calX+calW-34 && x<calX+calW-6 && y>=calY+4 && y<calY+28) return "CAL_NEXT";
   int gx=calX+8, gy=calY+CAL_HDR+CAL_WK;
   if(x>=gx && x<gx+7*CAL_CW && y>=gy && y<gy+6*CAL_CH)
      return "CAL_D"+IntegerToString(((y-gy)/CAL_CH)*7+(x-gx)/CAL_CW);
   if(x>=gx && x<gx+210 && y>=gy+6*CAL_CH+4 && y<gy+6*CAL_CH+28) return "CAL_TODAY";
   return "";
}
void MarkPressed(const string id){ pressId=id; pressMs=GetTickCount64(); }

bool InTrades(const int x,const int y)
{
   return trOpen && x>=trX && x<trX+trW && y>=trY && y<trY+trH;
}

//--- speed slider ---------------------------------------------------
double SpeedFromPos(const double p)
{
   double s=SPD_MIN*MathPow(SPD_MAX/SPD_MIN,p);
   if(MathAbs(MathLog10(s))<0.025) return 1.0;           // snap to Live
   if(s>=10) return MathRound(s);
   if(s>=1)  return MathRound(s*10.0)/10.0;
   return MathRound(s*100.0)/100.0;
}
double PosFromSpeed(const double s)
{
   double p=MathLog10(MathMax(s,SPD_MIN)/SPD_MIN)/MathLog10(SPD_MAX/SPD_MIN);
   return MathMax(0.0,MathMin(1.0,p));
}
string SpeedTxt(const double s)
{
   if(s==1.0) return "Live 1x";
   if(s>=10)  return DoubleToString(s,0)+"x";
   if(s>=1)   return DoubleToString(s,1)+"x";
   return DoubleToString(s,2)+"x";
}
void PlaceThumb()
{
   double p=PosFromSpeed(speedMult);
   ObjectSetInteger(panelChart,P+"SL_TH",OBJPROP_XDISTANCE,slX+(int)MathRound(p*(slW-SL_TH)));
}
void SetSpeed(const double s)
{
   speedMult=MathMax(SPD_MIN,MathMin(SPD_MAX,s));
   PlaceThumb(); btnDirty=true; uiForce=true;
}
void SliderAt(const int x)
{
   double p=(double)(x-slX-SL_TH/2)/(double)(slW-SL_TH);
   SetSpeed(SpeedFromPos(MathMax(0.0,MathMin(1.0,p))));
}
void SpeedStep(const int dir)
{
   double p=PosFromSpeed(speedMult)+dir*0.03;
   SetSpeed(SpeedFromPos(MathMax(0.0,MathMin(1.0,p))));
}

//--- right-click context menu (Limit / Stop orders) ------------------
void CloseCtx()
{
   if(!ctxOpen) return;
   ObjectsDeleteAll(panelChart,P+"CTX_");
   ctxOpen=false;
   ChartRedraw(panelChart);
}

string HitCtx(const int x,const int y)
{
   if(!ctxOpen) return "";
   for(int i=0;i<ctxN;i++)
      if(x>=ctxX+3 && x<ctxX+CTX_W-3 && y>=ctxRY[i] && y<ctxRY[i]+CTX_ROW-2) return ctxId[i];
   return "";
}

void OpenCtx(const int x,const int y)
{
   if(curBid<=0) return;
   int sub=0; datetime t=0; double price=0;
   if(!ChartXYToTimePrice(panelChart,x,y,sub,t,price) || sub!=0) return;
   price=NormalizeDouble(price,digitsN);
   CloseCtx(); CloseCal();
   ctxPrice=price; ctxN=0;
   if(price<curBid)      { ctxId[0]="CTX_BL";  ctxId[1]="CTX_SS"; ctxN=2; }
   else if(price>curAsk) { ctxId[0]="CTX_SLM"; ctxId[1]="CTX_BS"; ctxN=2; }
   else { lastMsg="Too close to market price | قیمت خیلی نزدیک بازار است"; uiForce=true; return; }

   int w=CTX_W, h=CTX_ROW*(ctxN+1)+6;
   int cw=(int)ChartGetInteger(panelChart,CHART_WIDTH_IN_PIXELS);
   int ch=(int)ChartGetInteger(panelChart,CHART_HEIGHT_IN_PIXELS);
   ctxX=MathMax(2,MathMin(x,cw-w-4)); ctxY=MathMax(2,MathMin(y,ch-h-4));
   Rect("CTX_BG",ctxX,ctxY,w,h,C'30,36,54',C'0,150,255',2999);
   RawBtn(P+"CTX_H",StringFormat("Order @ %s   |   Lot %.2f",Px(price),lotSize),ctxX+3,ctxY+3,w-6,CTX_ROW-2,
          C'0,92,170',clrWhite,C'0,92,170',9,3000);
   for(int i=0;i<ctxN;i++)
   {
      ctxRY[i]=ctxY+3+CTX_ROW*(i+1);
      bool buy=(ctxId[i]=="CTX_BL"||ctxId[i]=="CTX_BS");
      string nm=(ctxId[i]=="CTX_BL")?"Buy Limit":(ctxId[i]=="CTX_SS")?"Sell Stop":(ctxId[i]=="CTX_SLM")?"Sell Limit":"Buy Stop";
      color bg=buy?clrForestGreen:clrFireBrick;
      RawBtn(P+ctxId[i],nm+"   "+DoubleToString(lotSize,2)+" @ "+Px(price),ctxX+3,ctxRY[i],w-6,CTX_ROW-2,
             bg,clrWhite,Lighten(bg,55),9,3000);
   }
   ctxOpen=true;
   ChartRedraw(panelChart);
}

void RightClickAt(const int x,const int y)
{
   if(x>=4 && x<4+panW && y>=4 && y<4+panH) return;      // not over the panel
   if(InTrades(x,y)) return;
   OpenCtx(x,y);
}

//--- Trades window interaction ---------------------------------------
void CloseRow(const int row)
{
   if(row<0 || row>=twRows) return;
   if(twKind[row]==0)
   {
      int i=twIdx[row];
      if(i>=0 && i<ArraySize(pos) && pos[i].open_)
      {
         if(InpTradeMode==MODE_SINGLE) ClosePos(i,pos[i].dir>0?curBid:curAsk);
         else CloseBasket(bDir>0?curBid:curAsk);
      }
   }
   else CancelOrder(twIdx[row]);
   uiForce=true;
}

void MoveTrades()
{
   for(int i=0;i<twCnt;i++)
   {
      ObjectSetInteger(panelChart,twN[i],OBJPROP_XDISTANCE,trX+twOX[i]);
      ObjectSetInteger(panelChart,twN[i],OBJPROP_YDISTANCE,trY+twOY[i]);
   }
}

void HandleTrades(const int x,const int y)
{
   if(y<trY+TR_TITLE)
   {
      if(x>=trX+trW-28){ Act("TW_CLOSE"); return; }
      trDrag=true; trDX=x-trX; trDY=y-trY;
      ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,false);
      return;
   }
   if(y>=trY+trH-TR_FOOT)
   {
      if(x>=trX+trW-22){ trSize=true; ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,false); return; }
      if(x>=trX+trW-78 && x<trX+trW-52){ trTop=MathMax(0,trTop-1); RefreshTrades(); ChartRedraw(panelChart); return; }
      if(x>=trX+trW-52 && x<trX+trW-26){ trTop++; RefreshTrades(); ChartRedraw(panelChart); return; }
      return;
   }
   int rowsTop=trY+TR_TITLE+TR_HEAD;
   if(y>=rowsTop && x>=trX+trW-30)
   {
      int r=(y-rowsTop)/TR_ROWH;
      if(r>=0 && r<twVis) CloseRow(trTop+r);
      return;
   }
   if(y>=rowsTop)
   {
      int r=(y-rowsTop)/TR_ROWH;
      if(r<0 || r>=twVis || trTop+r>=twRows) return;
      double tw=(double)(trW-2-30), acc=1.0;
      for(int c=0;c<10;c++)
      {
         double l=acc; acc+=twFr[c]*tw;
         if((c==6||c==7) && x>=trX+(int)l && x<trX+(int)acc)
         { if(twKind[trTop+r]==0) OpenMod(twIdx[trTop+r]); return; }
         if(c==4 && x>=trX+(int)l && x<trX+(int)acc)
         { if(twKind[trTop+r]==0) OpenVol(twIdx[trTop+r]); return; }
      }
   }
}

//+------------------------------------------------------------------+
//| Trade history marks: MT5-style arrows + dotted entry->exit lines |
//+------------------------------------------------------------------+
void AddHevOpen(const Pos &p)
{
   int n=ArraySize(hev);
   if(n>3000) return;
   ArrayResize(hev,n+1,32);
   hev[n].ticket=p.ticket; hev[n].kind=0; hev[n].dir=p.dir;
   hev[n].t=p.time; hev[n].price=p.open; hev[n].t0=p.time; hev[n].p0=p.open; hev[n].profit=0;
   hev[n].part=0; hev[n].lots=p.lots;
}

void AddHevClose(const Pos &p,const double price,const double profit)
{
   int n=ArraySize(hev);
   if(n>3000) return;
   ArrayResize(hev,n+1,32);
   hev[n].ticket=p.ticket; hev[n].kind=1; hev[n].dir=p.dir;
   hev[n].t=(curTime>0)?curTime:p.time; hev[n].price=price;
   hev[n].t0=p.time; hev[n].p0=p.open; hev[n].profit=profit;
   hev[n].part=0; hev[n].lots=p.lots;
}

// partial close: same exit mark + dotted line as a full close, but a unique object name per event
void AddHevPartial(const Pos &p,const double closedLots,const double price,const double profit)
{
   int n=ArraySize(hev);
   if(n>3000) return;
   ArrayResize(hev,n+1,32);
   hev[n].ticket=p.ticket; hev[n].kind=1; hev[n].dir=p.dir;
   hev[n].t=(curTime>0)?curTime:p.time; hev[n].price=price;
   hev[n].t0=p.time; hev[n].p0=p.open; hev[n].profit=profit;
   hev[n].part=++partSeq; hev[n].lots=closedLots;
}

void ProcessHistory()
{
   int n=ArraySize(hev);
   if(n<=0) return;
   for(int k=0;k<n;k++)
   {
      string base="RPH_"+IntegerToString((long)hev[k].ticket)+(hev[k].part>0?"p"+IntegerToString(hev[k].part):"");
      bool buy=(hev[k].dir>0);
      color col=buy?clrDodgerBlue:clrRed;
      if(hev[k].kind==0)
      {
         string nm=base+"_in";
         if(ObjectCreate(panelChart,nm,buy?OBJ_ARROW_BUY:OBJ_ARROW_SELL,0,hev[k].t,hev[k].price))
         {
            ObjectSetInteger(panelChart,nm,OBJPROP_COLOR,col);
            ObjectSetInteger(panelChart,nm,OBJPROP_SELECTABLE,false);
            ObjectSetString(panelChart,nm,OBJPROP_TOOLTIP,"#"+IntegerToString((long)hev[k].ticket)+(buy?" buy @ ":" sell @ ")+Px(hev[k].price));
         }
      }
      else
      {
         string nx=base+"_out", nl=base+"_ln";
         color pc=(hev[k].profit>=0)?clrLimeGreen:clrOrangeRed;
         if(ObjectCreate(panelChart,nx,OBJ_ARROW,0,hev[k].t,hev[k].price))
         {
            ObjectSetInteger(panelChart,nx,OBJPROP_ARROWCODE,251);
            ObjectSetInteger(panelChart,nx,OBJPROP_COLOR,pc);
            ObjectSetInteger(panelChart,nx,OBJPROP_SELECTABLE,false);
            ObjectSetString(panelChart,nx,OBJPROP_TOOLTIP,"#"+IntegerToString((long)hev[k].ticket)+(hev[k].part>0?" partial close "+DoubleToString(hev[k].lots,2)+" @ ":" closed @ ")+Px(hev[k].price)+"  "+MoneyS(hev[k].profit));
         }
         if(ObjectCreate(panelChart,nl,OBJ_TREND,0,hev[k].t0,hev[k].p0,hev[k].t,hev[k].price))
         {
            ObjectSetInteger(panelChart,nl,OBJPROP_COLOR,col);
            ObjectSetInteger(panelChart,nl,OBJPROP_STYLE,STYLE_DOT);
            ObjectSetInteger(panelChart,nl,OBJPROP_WIDTH,1);
            ObjectSetInteger(panelChart,nl,OBJPROP_RAY_RIGHT,false);
            ObjectSetInteger(panelChart,nl,OBJPROP_SELECTABLE,false);
            ObjectSetInteger(panelChart,nl,OBJPROP_BACK,true);
         }
         int m=ArraySize(hDrawn);
         ArrayResize(hDrawn,m+1,64);
         hDrawn[m]=base;
         if(m+1>300)                                           // keep the chart light
         {
            string ob=hDrawn[0];
            ObjectDelete(panelChart,ob+"_in"); ObjectDelete(panelChart,ob+"_out"); ObjectDelete(panelChart,ob+"_ln");
            ArrayRemove(hDrawn,0,1);
         }
      }
   }
   ArrayResize(hev,0);
}

//+------------------------------------------------------------------+
//| Modify SL / TP: validation, drag on chart, Modify popup          |
//+------------------------------------------------------------------+
int FindPosByTicket(const ulong tk)
{
   for(int i=0;i<ArraySize(pos);i++) if(pos[i].open_ && pos[i].ticket==tk) return i;
   return -1;
}

bool SetPosLevel(const int i,const bool isSL,const double price0,string &err)
{
   err="";
   if(InpTradeMode!=MODE_SINGLE){ err="Martingale: SL/TP belong to the basket | در مارتینگل SL/TP برای کل سبد است"; return false; }
   double price=(price0<=0)?0.0:NormalizeDouble(price0,digitsN);
   if(price>0)
   {
      bool buy=(pos[i].dir>0);
      bool ok;
      if(isSL) ok=buy?(price<curBid):(price>curAsk);
      else     ok=buy?(price>curBid):(price<curAsk);
      if(!ok){ err=(isSL?"Invalid SL level":"Invalid TP level"); err+=" | سطح نامعتبر"; return false; }
   }
   if(isSL) pos[i].sl=price; else pos[i].tp=price;
   linesDirty=true; uiForce=true;
   return true;
}

int PriceToY(const double price)
{
   double mx=ChartGetDouble(panelChart,CHART_PRICE_MAX,0), mn=ChartGetDouble(panelChart,CHART_PRICE_MIN,0);
   int h=(int)ChartGetInteger(panelChart,CHART_HEIGHT_IN_PIXELS,0);
   if(mx<=mn || h<=0) return -10000;
   return (int)MathRound((mx-price)/(mx-mn)*h);
}

double YToPrice(const int y)
{
   double mx=ChartGetDouble(panelChart,CHART_PRICE_MAX,0), mn=ChartGetDouble(panelChart,CHART_PRICE_MIN,0);
   int h=(int)ChartGetInteger(panelChart,CHART_HEIGHT_IN_PIXELS,0);
   if(h<=0) return 0;
   return mx-(double)y/(double)h*(mx-mn);
}

void BeginDrag(const int kind,const ulong tk,const string name)
{
   dragKind=kind; dragTicket=tk; dragName=name;
   dragPrice=ObjectGetDouble(panelChart,name,OBJPROP_PRICE);
   dragPrice0=dragPrice;
   ObjectSetInteger(panelChart,name,OBJPROP_WIDTH,2);
   ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,false);
}

// press on a SL / TP / pending-order line -> drag it like in MetaTrader
bool TryStartLineDrag(const int x,const int y)
{
   if(dragKind!=0) return false;
   const int TOL=5;
   if(InpTradeMode==MODE_SINGLE)
   {
      for(int i=0;i<ArraySize(pos);i++)
      {
         if(!pos[i].open_) continue;
         string t=IntegerToString((long)pos[i].ticket);
         if(pos[i].sl>0 && MathAbs(y-PriceToY(pos[i].sl))<=TOL){ BeginDrag(1,pos[i].ticket,P+"S_"+t); return true; }
         if(pos[i].tp>0 && MathAbs(y-PriceToY(pos[i].tp))<=TOL){ BeginDrag(2,pos[i].ticket,P+"T_"+t); return true; }
      }
   }
   else if(basketLots>0 && basketTP>0 && MathAbs(y-PriceToY(basketTP))<=TOL)
   { BeginDrag(4,0,P+"BTP"); return true; }
   for(int i=0;i<ArraySize(ords);i++)
   {
      if(!ords[i].live) continue;
      if(MathAbs(y-PriceToY(ords[i].price))<=TOL){ BeginDrag(3,ords[i].ticket,P+"O_"+IntegerToString((long)ords[i].ticket)); return true; }
   }
   return false;
}

void DragMove(const int y)
{
   double p=NormalizeDouble(YToPrice(y),digitsN);
   if(p<=0) return;
   dragPrice=p;
   ObjectSetDouble(panelChart,dragName,OBJPROP_PRICE,p);
   ChartRedraw(panelChart);
}

void ApplyDrag()
{
   int kind=dragKind; dragKind=0;
   ObjectSetInteger(panelChart,dragName,OBJPROP_WIDTH,(dragName==P+"BTP")?2:1);
   linesDirty=true; uiForce=true;                 // redraw from data: reverts the line if the move is refused
   double np=NormalizeDouble(dragPrice,digitsN);
   if(MathAbs(np-dragPrice0)<InpPoint*0.5) return;
   string e="";
   if(kind==1 || kind==2)
   {
      int i=FindPosByTicket(dragTicket);
      if(i<0) return;
      if(SetPosLevel(i,kind==1,np,e)) lastMsg=StringFormat("#%I64u %s moved to %s",dragTicket,(kind==1?"SL":"TP"),Px(np));
      else lastMsg=e;
   }
   else if(kind==3)
   {
      for(int i=0;i<ArraySize(ords);i++)
      {
         if(!ords[i].live || ords[i].ticket!=dragTicket) continue;
         int t=ords[i].type; bool ok=false;
         if(t==1) ok=(np<curAsk); else if(t==2) ok=(np>curBid); else if(t==3) ok=(np>curAsk); else ok=(np<curBid);
         if(ok){ ords[i].price=np; lastMsg=StringFormat("Order #%I64u moved to %s",dragTicket,Px(np)); }
         else lastMsg="Invalid price for "+OrdTypeName(t)+" | قیمت نامعتبر";
         break;
      }
   }
   else if(kind==4)
   {
      bool ok=(bDir>0)?(np>basketAvg):(np<basketAvg);
      int pts=(int)MathRound(MathAbs(np-basketAvg)/InpPoint);
      if(ok && pts>=1)
      {
         tpPts=pts;
         ObjectSetString(panelChart,P+"TPP",OBJPROP_TEXT,IntegerToString(tpPts));
         double sl=basketSL; bool ta=basketTrailActive; CalcBasketAvg(); basketSL=sl; basketTrailActive=ta;
         lastMsg=StringFormat("Basket TP = %d points",tpPts);
      }
      else lastMsg="Invalid basket TP | حد سود نامعتبر";
   }
}

bool InMod(const int x,const int y)
{
   return modOpen && x>=modX && x<modX+MOD_W && y>=modY && y<modY+MOD_H;
}

string HitMod(const int x,const int y)
{
   if(!modOpen) return "";
   if(y>=modY+72 && y<modY+98)
   {
      if(x>=modX+10  && x<modX+94)  return "MOD_OK";
      if(x>=modX+100 && x<modX+190) return "MOD_NOSL";
      if(x>=modX+196 && x<modX+286) return "MOD_NOTP";
   }
   if(y>=modY+108 && y<modY+134 && x>=modX+196 && x<modX+286) return "MOD_X";
   return "";
}

void CloseMod()
{
   if(!modOpen) return;
   ObjectsDeleteAll(panelChart,P+"MOD_");
   modOpen=false; editing=false;
   ChartRedraw(panelChart);
}

void OpenMod(const int i)
{
   if(InpTradeMode!=MODE_SINGLE)
   { lastMsg="Martingale: SL/TP belong to the basket | در مارتینگل SL/TP برای کل سبد است"; uiForce=true; return; }
   if(i<0 || i>=ArraySize(pos) || !pos[i].open_) return;
   CloseVol();
   CloseMod();
   modOpen=true; modTicket=pos[i].ticket;
   modX=MathMax(2,trX+40);
   modY=(trY>MOD_H+12)?trY-MOD_H-6:trY+trH+6;
   Rect("MOD_BG",modX,modY,MOD_W,MOD_H,C'30,36,54',C'0,150,255',3400);
   RawBtn(P+"MOD_T",StringFormat("Modify  #%I64u  %s %.2f",pos[i].ticket,(pos[i].dir>0?"buy":"sell"),pos[i].lots),
          modX+3,modY+3,MOD_W-6,24,C'0,92,170',clrWhite,C'0,92,170',9,3500);
   Lbl("MOD_LS","S/L",modX+10,modY+42,clrWhite,9);
   EditBox("MOD_SL",pos[i].sl>0?Px(pos[i].sl):"0",modX+40,modY+36,100,26);
   Lbl("MOD_LT","T/P",modX+156,modY+42,clrWhite,9);
   EditBox("MOD_TP",pos[i].tp>0?Px(pos[i].tp):"0",modX+186,modY+36,100,26);
   ObjectSetInteger(panelChart,P+"MOD_SL",OBJPROP_ZORDER,3500);
   ObjectSetInteger(panelChart,P+"MOD_TP",OBJPROP_ZORDER,3500);
   RawBtn(P+"MOD_OK",   "Apply",     modX+10, modY+72,84, 26,clrForestGreen,clrWhite,Lighten(clrForestGreen,55),9,3500);
   RawBtn(P+"MOD_NOSL", "Remove SL", modX+100,modY+72,90, 26,clrFireBrick,  clrWhite,Lighten(clrFireBrick,55),  9,3500);
   RawBtn(P+"MOD_NOTP", "Remove TP", modX+196,modY+72,90, 26,clrFireBrick,  clrWhite,Lighten(clrFireBrick,55),  9,3500);
   RawBtn(P+"MOD_X",    "Close",     modX+196,modY+108,90,26,clrDimGray,    clrWhite,Lighten(clrDimGray,55),    9,3500);
   Lbl("MOD_H","0 = no level  |  صفر یعنی بدون سطح",modX+10,modY+114,C'140,152,185',8);
   ChartRedraw(panelChart);
}

void ApplyMod()
{
   int i=FindPosByTicket(modTicket);
   if(i<0){ CloseMod(); return; }
   string t1=ObjectGetString(panelChart,P+"MOD_SL",OBJPROP_TEXT), t2=ObjectGetString(panelChart,P+"MOD_TP",OBJPROP_TEXT);
   StringReplace(t1,",","."); StringReplace(t2,",",".");
   string e1="", e2="";
   bool a=SetPosLevel(i,true,StringToDouble(t1),e1);
   bool b=SetPosLevel(i,false,StringToDouble(t2),e2);
   if(a && b){ lastMsg=StringFormat("#%I64u SL/TP updated",modTicket); CloseMod(); }
   else lastMsg=(a?e2:e1);
   uiForce=true;
}

void ModRemove(const bool isSL)
{
   int i=FindPosByTicket(modTicket);
   if(i<0){ CloseMod(); return; }
   string e="";
   SetPosLevel(i,isSL,0,e);
   ObjectSetString(panelChart,P+(isSL?"MOD_SL":"MOD_TP"),OBJPROP_TEXT,"0");
   lastMsg=StringFormat("#%I64u %s removed",modTicket,(isSL?"SL":"TP"));
   uiForce=true;
}

//+------------------------------------------------------------------+
//| Change Volume of an open position = PARTIAL CLOSE (MT5 style)    |
//|  the removed part is closed at market, its P/L goes to balance   |
//+------------------------------------------------------------------+
bool PartialClose(const int i,const double newLots0,string &err)
{
   err="";
   if(i<0 || i>=ArraySize(pos) || !pos[i].open_){ err="Position not found | معامله پیدا نشد"; return false; }
   double st=MathMax(InpLotStep,0.0001);
   double nl=NormalizeDouble(MathRound(newLots0/st)*st,2);
   if(newLots0<=0 || nl<InpLotMin)
   { err=StringFormat("Minimum volume is %.2f | حداقل حجم %.2f است",InpLotMin,InpLotMin); return false; }
   if(nl>pos[i].lots+1e-9)
   { err=StringFormat("Volume can only be reduced (now %.2f) | حجم فقط کاهش می‌یابد",pos[i].lots); return false; }
   double cl=NormalizeDouble(pos[i].lots-nl,2);
   if(cl<=1e-9){ err="Same volume - nothing changed | حجم تغییری نکرد"; return false; }

   double price=(pos[i].dir>0)?curBid:curAsk;
   double pr=CalcProfit(pos[i].dir,pos[i].open,cl,price);        // P/L of the closed part only
   bal+=pr; dayProfit+=pr; weekProfit+=pr; monthProfit+=pr; closedToday+=pr;
   AddHevPartial(pos[i],cl,price,pr);
   pos[i].lots=nl;

   if(InpTradeMode==MODE_MARTINGALE)
   {
      double sl=basketSL; bool ta=basketTrailActive;
      CalcBasketAvg();
      basketSL=sl; basketTrailActive=ta;
   }
   linesDirty=true; uiForce=true;
   lastMsg=StringFormat("#%I64u closed %.2f lot, P/L %s | %.2f remains",pos[i].ticket,cl,MoneyS(pr),nl);
   pendLog+=StringFormat("Partial close #%I64u %s %.2f @ %s P/L=%+.2f | remaining %.2f\n",
                         pos[i].ticket,(pos[i].dir>0?"BUY":"SELL"),cl,Px(price),pr,nl);
   return true;
}

bool InVol(const int x,const int y)
{
   return volOpen && x>=volX && x<volX+MOD_W && y>=volY && y<volY+MOD_H;
}

string HitVol(const int x,const int y)
{
   if(!volOpen) return "";
   if(y>=volY+72 && y<volY+98)
   {
      if(x>=volX+10  && x<volX+94)  return "VOL_OK";
      if(x>=volX+196 && x<volX+286) return "VOL_X";
   }
   return "";
}

void CloseVol()
{
   if(!volOpen) return;
   ObjectsDeleteAll(panelChart,P+"VOL_");
   volOpen=false; editing=false;
   ChartRedraw(panelChart);
}

void OpenVol(const int i)
{
   if(i<0 || i>=ArraySize(pos) || !pos[i].open_) return;
   CloseMod(); CloseVol();
   volOpen=true; volTicket=pos[i].ticket;
   volX=MathMax(2,trX+40);
   volY=(trY>MOD_H+12)?trY-MOD_H-6:trY+trH+6;
   Rect("VOL_BG",volX,volY,MOD_W,MOD_H,C'30,36,54',C'0,150,255',3400);
   RawBtn(P+"VOL_T",StringFormat("Volume  #%I64u  %s %.2f",pos[i].ticket,(pos[i].dir>0?"buy":"sell"),pos[i].lots),
          volX+3,volY+3,MOD_W-6,24,C'0,92,170',clrWhite,C'0,92,170',9,3500);
   Lbl("VOL_LV","Volume",volX+10,volY+42,clrWhite,9);
   EditBox("VOL_V",DoubleToString(pos[i].lots,2),volX+70,volY+36,100,26);
   ObjectSetInteger(panelChart,P+"VOL_V",OBJPROP_ZORDER,3500);
   Lbl("VOL_LC",StringFormat("max %.2f",pos[i].lots),volX+182,volY+42,C'140,152,185',9);
   RawBtn(P+"VOL_OK","Apply",volX+10,volY+72,84,26,clrForestGreen,clrWhite,Lighten(clrForestGreen,55),9,3500);
   RawBtn(P+"VOL_X","Close",volX+196,volY+72,90,26,clrDimGray,clrWhite,Lighten(clrDimGray,55),9,3500);
   Lbl("VOL_H","New volume < current: the rest is closed at market  |  حجم کمتر یعنی بستن بخشی از معامله",volX+10,volY+108,C'140,152,185',7);
   ChartRedraw(panelChart);
}

void ApplyVol()
{
   int i=FindPosByTicket(volTicket);
   if(i<0){ CloseVol(); return; }
   string t=ObjectGetString(panelChart,P+"VOL_V",OBJPROP_TEXT);
   StringReplace(t,",","."); StringTrimLeft(t); StringTrimRight(t);
   string e="";
   if(PartialClose(i,StringToDouble(t),e)) CloseVol();
   else { lastMsg=e; uiForce=true; }
}

void ApplyTrailText()
{
   long a=StringToInteger(ObjectGetString(panelChart,P+"TRS",OBJPROP_TEXT));
   long b=StringToInteger(ObjectGetString(panelChart,P+"TRP",OBJPROP_TEXT));
   if(a<0) a=0; if(b<0) b=0;
   trStart=(int)a; trStep=(int)b;
   ObjectSetString(panelChart,P+"TRS",OBJPROP_TEXT,IntegerToString(trStart));
   ObjectSetString(panelChart,P+"TRP",OBJPROP_TEXT,IntegerToString(trStep));
   lastMsg=StringFormat("Trailing: start %d  step %d points",trStart,trStep);
   uiForce=true;
}

void ToggleTrail()
{
   trailOn=!trailOn;
   if(!trailOn && InpTradeMode==MODE_MARTINGALE){ basketTrailActive=false; basketSL=0; linesDirty=true; }
   lastMsg=trailOn?"Trailing stop ON | تریلینگ روشن":"Trailing stop OFF | تریلینگ خاموش";
   btnDirty=true; uiForce=true;
}

void EndDrags()
{
   if(dragKind!=0) ApplyDrag();
   if(trSize) trSizeDirty=true;
   sliderDrag=false; trDrag=false; trSize=false;
   ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,true);
}

//--- press dispatcher -------------------------------------------------
void PressAt(const int x,const int y)
{
   if(ctxOpen)
   {
      string c=HitCtx(x,y);
      CloseCtx();
      if(c!=""){ MarkPressed(c); Act(c); return; }
   }
   if(calOpen)
   {
      if(InCal(x,y))
      {
         string c=HitCal(x,y);
         if(c!=""){ MarkPressed(c); Act(c); }
         return;
      }
      string pid=HitPanel(x,y);
      bool same=(calTarget==0 && (pid=="FROM"||pid=="FROM_I")) || (calTarget==1 && (pid=="TO"||pid=="TO_I"));
      CloseCal();
      if(same){ MarkPressed(pid); return; }
      if(pid!=""){ MarkPressed(pid); Act(pid); }
      return;
   }
   if(volOpen)
   {
      if(InVol(x,y)){ string vc=HitVol(x,y); if(vc!=""){ MarkPressed(vc); Act(vc); } return; }
      CloseVol();
   }
   if(modOpen)
   {
      if(InMod(x,y)){ string mc=HitMod(x,y); if(mc!=""){ MarkPressed(mc); Act(mc); } return; }
      CloseMod();
   }
   if(InTrades(x,y)){ HandleTrades(x,y); return; }
   if(x>=slX-6 && x<slX+slW+6 && y>=slY-4 && y<slY+SL_H+4)
   {
      sliderDrag=true;
      ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,false);
      SliderAt(x);
      return;
   }
   if(!(x>=4 && x<4+panW && y>=4 && y<4+panH) && TryStartLineDrag(x,y)) return;
   if(!InpFireOnPress) return;
   string id=HitPanel(x,y);
   if(id!=""){ MarkPressed(id); Act(id); }
}

void SetPlay(const bool p)
{
   playing=p;
   lastUs=GetMicrosecondCount();
   EventSetMillisecondTimer(p?1:10);
   btnDirty=true; uiForce=true;
}

// Play applies the chosen date range first (if it changed or replay finished)
void StartPlay()
{
   bool atEnd=(cur>=endBar && tkIdx>=tkN && barClockUs>=barDurUs);
   if(selDirty || atEnd) ApplyRange();
   SetPlay(true);
}

void Act(const string b)
{
   if(b=="BUY")        OpenTrade(1);
   else if(b=="SELL")  OpenTrade(-1);
   else if(b=="CLOSE") CloseAll();
   else if(b=="PLAY")  { StartPlay(); UpdateButtonStates(true); btnDirty=false; }
   else if(b=="PAUSE") { SetPlay(false); UpdateButtonStates(true); btnDirty=false; }
   else if(b=="LIVE")  { SetSpeed(1.0); UpdateButtonStates(true); btnDirty=false; }
   else if(b=="LOT_M") SetLot(lotSize-InpLotStep);
   else if(b=="LOT_P") SetLot(lotSize+InpLotStep);
   else if(b=="MAXLOT") SetLot(MaxLotFor(FreeMargin(),curAsk));
   else if(b=="APPLY") ApplySLTPOpen();
   else if(b=="BAL_RESET") ResetBalance();
   else if(b=="BAL_DEP") Deposit();
   else if(b=="TRAIL_T") ToggleTrail();
   else if(b=="MOD_OK") ApplyMod();
   else if(b=="MOD_NOSL") ModRemove(true);
   else if(b=="MOD_NOTP") ModRemove(false);
   else if(b=="MOD_X") CloseMod();
   else if(b=="VOL_OK") ApplyVol();
   else if(b=="VOL_X") CloseVol();
   else if(b=="TRADES"){ if(trOpen) CloseTrades(); else OpenTrades(); UpdateButtonStates(true); btnDirty=false; }
   else if(b=="TW_CLOSE"){ CloseTrades(); UpdateButtonStates(true); btnDirty=false; }
   else if(b=="CTX_BL")  { PlaceOrder(1,ctxPrice); CloseCtx(); }
   else if(b=="CTX_SLM") { PlaceOrder(2,ctxPrice); CloseCtx(); }
   else if(b=="CTX_BS")  { PlaceOrder(3,ctxPrice); CloseCtx(); }
   else if(b=="CTX_SS")  { PlaceOrder(4,ctxPrice); CloseCtx(); }
   else if(b=="TF_M1")  SwitchTF(PERIOD_M1);
   else if(b=="TF_M5")  SwitchTF(PERIOD_M5);
   else if(b=="TF_M15") SwitchTF(PERIOD_M15);
   else if(b=="TF_M30") SwitchTF(PERIOD_M30);
   else if(b=="TF_H1")  SwitchTF(PERIOD_H1);
   else if(b=="TF_H4")  SwitchTF(PERIOD_H4);
   else if(b=="TF_D1")  SwitchTF(PERIOD_D1);
   else if(b=="TF_W1")  SwitchTF(PERIOD_W1);
   else if(b=="FROM"||b=="FROM_I") { if(calOpen && calTarget==0) CloseCal(); else OpenCal(0); }
   else if(b=="TO"||b=="TO_I")     { if(calOpen && calTarget==1) CloseCal(); else OpenCal(1); }
   else if(b=="CAL_PREV"){ calMon--; if(calMon<1){calMon=12;calYear--;} RefreshCal(); ChartRedraw(panelChart); }
   else if(b=="CAL_NEXT"){ calMon++; if(calMon>12){calMon=1;calYear++;} RefreshCal(); ChartRedraw(panelChart); }
   else if(b=="CAL_TODAY"){ PickDate(MathMax(dataFirst,MathMin(dataLast,DayStart(TimeLocal())))); }
   else if(StringFind(b,"CAL_D")==0)
   {
      int i=(int)StringToInteger(StringSubstr(b,5));
      if(i>=0 && i<42 && calOn[i]) PickDate(calDate[i]);
   }
   uiForce=true;
}

void OnChartEvent(const int id,const long &lp,const double &dp,const string &sp)
{
   if(!ready) return;

   if(id==CHARTEVENT_MOUSE_MOVE)
   {
      int x=(int)lp, y=(int)dp;
      uint fl=(uint)StringToInteger(sp);
      bool ld=((fl&1)!=0), rd=((fl&2)!=0);
      if(ld)
      {
         if(sliderDrag) SliderAt(x);
         else if(trDrag){ trX=MathMax(0,x-trDX); trY=MathMax(0,y-trDY); MoveTrades(); ChartRedraw(panelChart); }
         else if(trSize){ trW=MathMax(600,x-trX+10); trH=MathMax(160,y-trY+10); trSizeDirty=true; }
         else if(dragKind!=0) DragMove(y);
      }
      else if(sliderDrag||trDrag||trSize||dragKind!=0) EndDrags();
      if(ld && !mouseDown) PressAt(x,y);
      if(rd && !rightDown) RightClickAt(x,y);
      mouseDown=ld; rightDown=rd;
      return;
   }

   if(id==CHARTEVENT_OBJECT_ENDEDIT)
   {
      editing=false;
      if(sp==P+"LOT") ApplyLotText();
      else if(sp==P+"LEV") ApplyLevText();
      else if(sp==P+"SLP"||sp==P+"TPP") ApplySLTPText();
      else if(sp==P+"BALV") ApplyBalText();
      else if(sp==P+"TRS"||sp==P+"TRP") ApplyTrailText();
      return;
   }

   // hotkeys: B = Buy, S = Sell, C = Close all, Space = Play/Pause, +/- = speed, Esc = close popups
   if(id==CHARTEVENT_KEYDOWN)
   {
      if(editing) return;
      if(lp==66)      OpenTrade(1);
      else if(lp==83) OpenTrade(-1);
      else if(lp==67) CloseAll();
      else if(lp==32) { if(playing) Act("PAUSE"); else Act("PLAY"); }
      else if(lp==107||lp==187) SpeedStep(1);
      else if(lp==109||lp==189) SpeedStep(-1);
      else if(lp==27) { CloseCtx(); CloseCal(); CloseMod(); CloseVol(); }
      return;
   }

   // fallback path (click on release) - skipped when the press already fired
   if(id!=CHARTEVENT_OBJECT_CLICK) return;
   if(StringFind(sp,P)!=0) return;
   if(IsEditName(sp)){ editing=true; return; }
   string b=StringSubstr(sp,StringLen(P));
   if(b=="") return;
   bool dup=(b==pressId && (GetTickCount64()-pressMs)<1500);
   if(dup) pressId=""; else Act(b);
   ObjectSetInteger(panelChart,sp,OBJPROP_STATE,false);
   btnDirty=true; uiForce=true;
}

//+------------------------------------------------------------------+
//| TF switch: terminal rebuilds every TF from ticks, so no reload.  |
//+------------------------------------------------------------------+
void SwitchTF(ENUM_TIMEFRAMES tf)
{
   if(tf==currentTF) return;
   FlushTicks();
   ChartSetSymbolPeriod(panelChart,customSym,tf);
}

datetime DayStart(const datetime t){ return (datetime)(((long)t/86400)*86400); }
int FindFirst(const datetime t)      // first bar with time >= t
{
   int lo=0,hi=total-1;
   while(lo<hi){ int mid=(lo+hi)/2; if(rates[mid].time<t) lo=mid+1; else hi=mid; }
   return lo;
}
int FindLast(const datetime t)       // last bar with time <= t
{
   int lo=0,hi=total-1;
   while(lo<hi){ int mid=(lo+hi+1)/2; if(rates[mid].time>t) hi=mid-1; else lo=mid; }
   return lo;
}

void ApplyRange()
{
   if(selTo<selFrom) selTo=selFrom;
   int bf=FindFirst(selFrom);
   int bt=FindLast(selTo+86399);
   if(bt<=bf) bt=total-1;
   SetPlay(false);
   endBar=bt;
   selDirty=false;
   ResetTradeState(false);
   ClearAllLines();
   StartAt(bf);
   linesDirty=true;
}

void ResetTradeState(const bool resetStats)
{
   ArrayResize(pos,0); openCnt=0; needCompact=false;
   ArrayResize(ords,0); ordLive=0; ordCompact=false;
   martLevel=0; martDir=0;
   basketAvg=0; basketLots=0; basketSL=0; basketTP=0; bDir=0; basketTrailActive=false;
   if(resetStats)
   {
      nextT=1; lastDay=0; lastWeek=0; lastMonth=0;
      dayProfit=0; ydayProfit=0; weekProfit=0; monthProfit=0;
      dayLots=0; weekLots=0; monthLots=0; closedToday=0;
   }
}

//+------------------------------------------------------------------+
//| Replay positioning                                               |
//|  History = base bars [from..idx-1]  +  coarser TFs stitched in   |
//|  for everything older (complete higher-TF history, no holes)     |
//+------------------------------------------------------------------+
void PushHistory(const int idx)
{
   int from=MathMax(0,idx-InpHistoryBars);
   CustomRatesDelete(customSym,0,LONG_MAX);
   CustomTicksDelete(customSym,0,LONG_MAX);

   datetime boundary=rates[from].time;
   int segS[8], segC[8], segN=0;
   int totalN=idx-from;
   for(int k=0;k<cK && segN<8;k++)
   {
      int ps=PeriodSeconds(cTF[k]);
      int off=cOff[k], m=cCnt[k];
      int lo=0, hi=m;
      while(lo<hi){ int mid=(lo+hi)/2; if(cser[off+mid].time+ps<=boundary) lo=mid+1; else hi=mid; }
      if(lo<=0) continue;
      segS[segN]=off; segC[segN]=lo; segN++;
      totalN+=lo;
      boundary=cser[off].time;
   }
   if(totalN<=0) return;
   MqlRates all[];
   ArrayResize(all,totalN);
   int w=0;
   for(int s=segN-1;s>=0;s--){ ArrayCopy(all,cser,w,segS[s],segC[s]); w+=segC[s]; }
   if(idx-from>0) ArrayCopy(all,rates,w,from,idx-from);
   CustomRatesUpdate(customSym,all);
}

void StartAt(const int idx)
{
   cur=idx;
   PushHistory(idx);
   curBid=(idx>0)?rates[idx-1].close:rates[0].open;
   curAsk=curBid+spreadPx;
   UpdateStatsPeriod(rates[cur].time);
   BuildBarTicks(cur);
   tkIdx=0; barClockUs=0;
   lastUs=GetMicrosecondCount();
   Advance(0.0);                  // emit opening tick so the first candle is visible
}
void UpdateStatsPeriod(const datetime t)
{
   datetime dayStart=(datetime)(((long)t/86400)*86400);
   if(dayStart==lastDay && lastWeek!=0 && lastMonth!=0) return;

   MqlDateTime d; TimeToStruct(dayStart,d);
   long dn=(long)dayStart/86400;
   datetime weekStart =(datetime)((dn-((dn+3)%7))*86400);     // Monday based
   datetime monthStart=(datetime)(((long)dayStart)-(long)(d.day-1)*86400);

   if(lastDay==0) lastDay=dayStart;
   else if(dayStart!=lastDay){ ydayProfit=dayProfit; dayProfit=0; dayLots=0; closedToday=0; lastDay=dayStart; }

   if(lastWeek==0) lastWeek=weekStart;
   else if(weekStart!=lastWeek){ weekProfit=0; weekLots=0; lastWeek=weekStart; }

   if(lastMonth==0) lastMonth=monthStart;
   else if(monthStart!=lastMonth){ monthProfit=0; monthLots=0; lastMonth=monthStart; }
}

//+------------------------------------------------------------------+
//| Data: full multi-TF export / cached load                         |
//+------------------------------------------------------------------+
string CsvPath(ENUM_TIMEFRAMES tf){ return folderName+"\\"+baseSym+"+"+TFName(tf)+".csv"; }
string BinPath(ENUM_TIMEFRAMES tf){ return folderName+"\\"+baseSym+"+"+TFName(tf)+".bin"; }

int TfCandidates(ENUM_TIMEFRAMES &c[])
{
   ArrayResize(c,8);
   c[0]=PERIOD_M1; c[1]=PERIOD_M5; c[2]=PERIOD_M15; c[3]=PERIOD_M30; c[4]=PERIOD_H1; c[5]=PERIOD_H4; c[6]=PERIOD_D1; c[7]=PERIOD_W1;
   int s=0;
   for(int i=0;i<8;i++) if(c[i]==InpBaseTF){ s=i; break; }
   return s;
}

// make sure the terminal really has the whole history before exporting
int FetchFull(const string sym,ENUM_TIMEFRAMES tf,MqlRates &r[])
{
   for(int w=0;w<25;w++){ if((bool)SeriesInfoInteger(sym,tf,SERIES_SYNCHRONIZED)) break; Sleep(200); }
   int prev=-1, n=0;
   for(int k=0;k<8;k++)
   {
      n=CopyRates(sym,tf,0,InpBarsToSave,r);
      if(n<=0){ Sleep(250); continue; }
      if(n==prev || n>=InpBarsToSave) break;      // stopped growing => fully loaded
      prev=n; Sleep(250);
   }
   return n;
}

void SaveSource()
{
   ENUM_TIMEFRAMES c[]; int s=TfCandidates(c);
   SymbolSelect(_Symbol,true);
   for(int k=s;k<8;k++)
   {
      if(!InpResaveOnInit && FileIsExist(CsvPath(c[k]))) continue;
      MqlRates r[];
      int n=FetchFull(_Symbol,c[k],r);
      if(n<=0){ Print("No history for ",TFName(c[k])," on ",_Symbol); continue; }
      if(r[n-1].time+PeriodSeconds(c[k])>TimeCurrent()) n--;     // drop the still-forming bar
      if(n<=0) continue;
      int h=FileOpen(CsvPath(c[k]),FILE_WRITE|FILE_CSV|FILE_ANSI,',');
      if(h==INVALID_HANDLE){ Print("Cannot write ",CsvPath(c[k])); continue; }
      FileWrite(h,"DateTime","Open","High","Low","Close","TickVolume","Spread","RealVolume");
      for(int j=0;j<n;j++)
         FileWrite(h,TimeToString(r[j].time,TIME_DATE|TIME_SECONDS),
                   DoubleToString(r[j].open,_Digits),DoubleToString(r[j].high,_Digits),
                   DoubleToString(r[j].low,_Digits),DoubleToString(r[j].close,_Digits),
                   (long)r[j].tick_volume,(int)r[j].spread,(long)r[j].real_volume);
      FileClose(h);
      FileDelete(BinPath(c[k]));                                  // invalidate binary cache
      Print("Saved ",TFName(c[k])," | bars: ",n," | ",TimeToString(r[0].time)," -> ",TimeToString(r[n-1].time));
   }
}

bool SetupCustom()
{
   if(!SymbolInfoInteger(customSym,SYMBOL_EXIST))
   {
      if(!CustomSymbolCreate(customSym,"Custom\\Replay")) return false;
   }
   CustomSymbolSetInteger(customSym,SYMBOL_DIGITS,digitsN);
   CustomSymbolSetDouble(customSym,SYMBOL_POINT,InpPoint);
   CustomSymbolSetDouble(customSym,SYMBOL_TRADE_TICK_SIZE,InpPoint);
   CustomSymbolSetDouble(customSym,SYMBOL_TRADE_CONTRACT_SIZE,InpContractSize);
   CustomSymbolSetInteger(customSym,SYMBOL_TRADE_CALC_MODE,SYMBOL_CALC_MODE_CFD);
   CustomSymbolSetInteger(customSym,SYMBOL_TRADE_MODE,SYMBOL_TRADE_MODE_FULL);
   SymbolSelect(customSym,true);                 // required for CustomTicksAdd
   return true;
}

// binary cache: loads hundreds of thousands of bars in milliseconds
bool LoadBin(ENUM_TIMEFRAMES tf,MqlRates &out[])
{
   if(!FileIsExist(BinPath(tf)) || !FileIsExist(CsvPath(tf))) return false;
   int hc=FileOpen(CsvPath(tf),FILE_READ|FILE_TXT|FILE_ANSI|FILE_SHARE_READ);
   if(hc==INVALID_HANDLE) return false;
   long dCsv=FileGetInteger(hc,FILE_MODIFY_DATE); FileClose(hc);
   int h=FileOpen(BinPath(tf),FILE_READ|FILE_BIN);
   if(h==INVALID_HANDLE) return false;
   bool ok=false;
   if(FileGetInteger(h,FILE_MODIFY_DATE)>=dCsv && FileReadInteger(h)==0x42494E32 && FileReadInteger(h)==InpBarsToLoad)
   {
      int n=FileReadInteger(h);
      if(n>=10 && n<=20000000)
      {
         ArrayResize(out,n);
         ok=((int)FileReadArray(h,out,0,n)==n);
      }
   }
   FileClose(h);
   return ok;
}

void SaveBin(ENUM_TIMEFRAMES tf,MqlRates &src[])
{
   int n=ArraySize(src);
   int h=FileOpen(BinPath(tf),FILE_WRITE|FILE_BIN);
   if(h==INVALID_HANDLE) return;
   FileWriteInteger(h,0x42494E32); FileWriteInteger(h,InpBarsToLoad); FileWriteInteger(h,n);
   FileWriteArray(h,src,0,n);
   FileClose(h);
}

bool ReadSeries(ENUM_TIMEFRAMES tf,MqlRates &out[])
{
   if(LoadBin(tf,out)) return ArraySize(out)>=10;
   if(!FileIsExist(CsvPath(tf)))
   {
      int n0=CopyRates(baseSym,tf,0,InpBarsToLoad,out);
      return n0>=10;
   }
   int h=FileOpen(CsvPath(tf),FILE_READ|FILE_TXT|FILE_ANSI|FILE_SHARE_READ);
   if(h==INVALID_HANDLE) return false;
   MqlRates tmp[];
   ArrayResize(tmp,0,MathMin(InpBarsToSave,3000000)+16);
   int n=0; string line; string p[]; datetime lastT=0;
   while(!FileIsEnding(h))
   {
      line=FileReadString(h);
      if(StringLen(line)<16) continue;
      int k=StringSplit(line,',',p);
      if(k<6) continue;
      datetime t=StringToTime(p[0]);
      if(t<=0 || t<=lastT) continue;                         // header / duplicates / disorder
      double o=StringToDouble(p[1]), hi=StringToDouble(p[2]), lo=StringToDouble(p[3]), cl=StringToDouble(p[4]);
      if(o<=0 || hi<=0 || lo<=0 || cl<=0) continue;
      MqlRates rr; ZeroMemory(rr);
      rr.time=t; rr.open=o; rr.high=hi; rr.low=lo; rr.close=cl;
      rr.tick_volume=(long)StringToInteger(p[4+1]); if(rr.tick_volume<=0) rr.tick_volume=1;
      if(k>=7) rr.spread=(int)StringToInteger(p[6]);
      if(k>=8) rr.real_volume=(long)StringToInteger(p[7]);
      ArrayResize(tmp,n+1);
      tmp[n++]=rr; lastT=t;
   }
   FileClose(h);
   if(n<10) return false;
   int keep=MathMin(n,InpBarsToLoad);                          // newest bars win
   ArrayResize(out,keep);
   ArrayCopy(out,tmp,0,n-keep,keep);
   SaveBin(tf,out);
   return true;
}

bool LoadBase()
{
   ENUM_TIMEFRAMES c[]; int s=TfCandidates(c);
   int kb=-1;
   for(int k=s;k<8;k++) if(ReadSeries(c[k],rates)){ kb=k; break; }
   if(kb<0) return false;
   total=ArraySize(rates);
   usedTF=c[kb];

   ArrayResize(cser,0); cK=0;
   int w=0;
   for(int k=kb+1;k<8 && cK<8;k++)
   {
      MqlRates t[];
      if(!ReadSeries(c[k],t)) continue;
      int m=ArraySize(t);
      ArrayResize(cser,w+m);
      ArrayCopy(cser,t,w,0,m);
      cTF[cK]=c[k]; cOff[cK]=w; cCnt[cK]=m; cK++; w+=m;
   }
   Print("Loaded base ",TFName(usedTF)," bars: ",total," | ",TimeToString(rates[0].time)," -> ",TimeToString(rates[total-1].time),
         " | stitched coarser TFs: ",cK);
   return total>=10;
}

//+------------------------------------------------------------------+
//| Persist / restore state across TF changes (MT5 re-inits the EA)  |
//+------------------------------------------------------------------+
void SaveState()
{
   int h=FileOpen(StatePath(),FILE_WRITE|FILE_BIN);
   if(h==INVALID_HANDLE) return;
   FileWriteInteger(h,0x52504C5C);
   FileWriteLong(h,(long)TimeLocal());
   FileWriteInteger(h,cur); FileWriteInteger(h,endBar); FileWriteInteger(h,tkIdx);
   FileWriteDouble(h,barClockUs); FileWriteDouble(h,bal); FileWriteDouble(h,speedMult); FileWriteDouble(h,lotSize);
   FileWriteInteger(h,leverage); FileWriteInteger(h,slPts); FileWriteInteger(h,tpPts); FileWriteDouble(h,resetBal);
   FileWriteInteger(h,trailOn?1:0); FileWriteInteger(h,trStart); FileWriteInteger(h,trStep);
   FileWriteInteger(h,playing?1:0); FileWriteLong(h,(long)nextT);
   FileWriteInteger(h,martLevel); FileWriteInteger(h,martDir);
   FileWriteDouble(h,basketSL); FileWriteInteger(h,basketTrailActive?1:0);
   FileWriteDouble(h,curBid);
   FileWriteDouble(h,dayProfit); FileWriteDouble(h,ydayProfit); FileWriteDouble(h,weekProfit); FileWriteDouble(h,monthProfit);
   FileWriteDouble(h,dayLots); FileWriteDouble(h,weekLots); FileWriteDouble(h,monthLots); FileWriteDouble(h,closedToday);
   FileWriteLong(h,(long)lastDay); FileWriteLong(h,(long)lastWeek); FileWriteLong(h,(long)lastMonth);
   FileWriteLong(h,(long)selFrom); FileWriteLong(h,(long)selTo); FileWriteInteger(h,selDirty?1:0);
   FileWriteInteger(h,trOpen?1:0); FileWriteInteger(h,trX); FileWriteInteger(h,trY); FileWriteInteger(h,trW); FileWriteInteger(h,trH);
   int n=ArraySize(pos);
   FileWriteInteger(h,n);
   for(int i=0;i<n;i++) FileWriteStruct(h,pos[i]);
   int m=ArraySize(ords);
   FileWriteInteger(h,m);
   for(int i=0;i<m;i++) FileWriteStruct(h,ords[i]);
   FileClose(h);
}

bool TryRestoreState()
{
   if(!FileIsExist(StatePath())) return false;
   int h=FileOpen(StatePath(),FILE_READ|FILE_BIN);
   if(h==INVALID_HANDLE) return false;
   bool ok=false;
   if(FileReadInteger(h)==0x52504C5C)
   {
      long stamp=FileReadLong(h);
      if(MathAbs((long)TimeLocal()-stamp)<=30)
      {
         cur=FileReadInteger(h); endBar=FileReadInteger(h); tkIdx=FileReadInteger(h);
         barClockUs=FileReadDouble(h); bal=FileReadDouble(h); speedMult=FileReadDouble(h); lotSize=FileReadDouble(h);
         leverage=FileReadInteger(h); slPts=FileReadInteger(h); tpPts=FileReadInteger(h); resetBal=FileReadDouble(h);
         trailOn=(FileReadInteger(h)==1); trStart=FileReadInteger(h); trStep=FileReadInteger(h);
         playing=(FileReadInteger(h)==1); nextT=(ulong)FileReadLong(h);
         martLevel=FileReadInteger(h); martDir=FileReadInteger(h);
         basketSL=FileReadDouble(h); basketTrailActive=(FileReadInteger(h)==1);
         curBid=FileReadDouble(h);
         dayProfit=FileReadDouble(h); ydayProfit=FileReadDouble(h); weekProfit=FileReadDouble(h); monthProfit=FileReadDouble(h);
         dayLots=FileReadDouble(h); weekLots=FileReadDouble(h); monthLots=FileReadDouble(h); closedToday=FileReadDouble(h);
         lastDay=(datetime)FileReadLong(h); lastWeek=(datetime)FileReadLong(h); lastMonth=(datetime)FileReadLong(h);
         selFrom=(datetime)FileReadLong(h); selTo=(datetime)FileReadLong(h); selDirty=(FileReadInteger(h)==1);
         trOpen=(FileReadInteger(h)==1); trX=FileReadInteger(h); trY=FileReadInteger(h); trW=FileReadInteger(h); trH=FileReadInteger(h);
         int n=FileReadInteger(h);
         ArrayResize(pos,0); ArrayResize(ords,0);
         if(n>=0 && n<100000)
         {
            ArrayResize(pos,n,64);
            for(int i=0;i<n;i++) FileReadStruct(h,pos[i]);
            int m=FileReadInteger(h);
            if(m>=0 && m<100000)
            {
               ArrayResize(ords,m,16);
               for(int i=0;i<m;i++) FileReadStruct(h,ords[i]);
               ok=(cur>=0 && cur<total && endBar<total);
            }
         }
      }
   }
   FileClose(h);
   FileDelete(StatePath());
   if(!ok){ ArrayResize(pos,0); ArrayResize(ords,0); return false; }

   if(speedMult<SPD_MIN) speedMult=1.0;
   if(lotSize<=0) lotSize=InpLot;
   if(leverage<1) leverage=InpLeverage;
   if(resetBal<=0) resetBal=InpBalance;
   if(trStart<0) trStart=0; if(trStep<0) trStep=0;
   endBar=MathMin(endBar,total-1);
   curAsk=curBid+spreadPx;
   openCnt=0; ordLive=0;
   for(int i=0;i<ArraySize(pos);i++) if(pos[i].open_) openCnt++;
   for(int i=0;i<ArraySize(ords);i++) if(ords[i].live) ordLive++;
   if(InpTradeMode==MODE_MARTINGALE){ double sl=basketSL; bool ta=basketTrailActive; CalcBasketAvg(); basketSL=sl; basketTrailActive=ta; }
   BuildBarTicks(cur);
   if(tkIdx>tkN) tkIdx=tkN;
   eq=bal;
   Print("State restored after TF change | وضعیت حفظ شد. Bar=",cur);
   return true;
}

//+------------------------------------------------------------------+
//| Chart lines - MetaTrader 5 standard look                         |
//|   dotted lines, labels "#ticket buy 0.10" / "#ticket sl|tp"      |
//+------------------------------------------------------------------+
void DrawHLine(const string name,const double price,const color clr,const ENUM_LINE_STYLE st,const int w,const string txt)
{
   if(dragKind!=0 && name==dragName) return;          // do not fight the user while a line is being dragged
   if(ObjectFind(panelChart,name)<0)
   {
      ObjectCreate(panelChart,name,OBJ_HLINE,0,0,price);
      ObjectSetInteger(panelChart,name,OBJPROP_COLOR,clr);
      ObjectSetInteger(panelChart,name,OBJPROP_STYLE,st);
      ObjectSetInteger(panelChart,name,OBJPROP_WIDTH,w);
      ObjectSetInteger(panelChart,name,OBJPROP_BACK,true);
      ObjectSetInteger(panelChart,name,OBJPROP_SELECTABLE,false);
   }
   else ObjectSetDouble(panelChart,name,OBJPROP_PRICE,price);
   ObjectSetString(panelChart,name,OBJPROP_TEXT,txt);
}
void DeletePosLines(const ulong ticket)
{
   string t=IntegerToString((long)ticket);
   ObjectDelete(panelChart,P+"E_"+t);
   ObjectDelete(panelChart,P+"S_"+t);
   ObjectDelete(panelChart,P+"T_"+t);
}

void ClearBasketLines()
{
   ObjectDelete(panelChart,P+"BAVG");
   ObjectDelete(panelChart,P+"BTP");
   ObjectDelete(panelChart,P+"BSL");
}

void ClearAllLines()
{
   ObjectsDeleteAll(panelChart,P+"E_");
   ObjectsDeleteAll(panelChart,P+"S_");
   ObjectsDeleteAll(panelChart,P+"T_");
   ObjectsDeleteAll(panelChart,P+"O_");
   ObjectsDeleteAll(panelChart,"RPH_");
   ArrayResize(hev,0); ArrayResize(hDrawn,0);
   ClearBasketLines();
}

void CompactPositions()
{
   int w=0, n=ArraySize(pos);
   for(int i=0;i<n;i++)
   {
      if(!pos[i].open_){ DeletePosLines(pos[i].ticket); continue; }
      if(w!=i) pos[w]=pos[i];
      w++;
   }
   ArrayResize(pos,w);
   needCompact=false;
}

void CompactOrders()
{
   int w=0, n=ArraySize(ords);
   for(int i=0;i<n;i++)
   {
      if(!ords[i].live){ ObjectDelete(panelChart,P+"O_"+IntegerToString((long)ords[i].ticket)); continue; }
      if(w!=i) ords[w]=ords[i];
      w++;
   }
   ArrayResize(ords,w);
   ordCompact=false;
}

void UpdateOrderLines()
{
   for(int i=0;i<ArraySize(ords);i++)
   {
      if(!ords[i].live) continue;
      string t=IntegerToString((long)ords[i].ticket);
      DrawHLine(P+"O_"+t,ords[i].price,InpColEntry,STYLE_DOT,1,"#"+t+" "+OrdTypeName(ords[i].type)+" "+DoubleToString(ords[i].lots,2));
   }
}

void UpdateTradeLines()
{
   for(int i=0;i<ArraySize(pos);i++)
   {
      if(!pos[i].open_) continue;
      string t=IntegerToString((long)pos[i].ticket);
      DrawHLine(P+"E_"+t,pos[i].open,InpColEntry,STYLE_DOT,1,"#"+t+" "+(pos[i].dir>0?"buy ":"sell ")+DoubleToString(pos[i].lots,2));
      if(InpTradeMode!=MODE_SINGLE) continue;
      if(pos[i].sl>0) DrawHLine(P+"S_"+t,pos[i].sl,InpColSL,STYLE_DOT,1,"#"+t+" sl");
      else ObjectDelete(panelChart,P+"S_"+t);
      if(pos[i].tp>0) DrawHLine(P+"T_"+t,pos[i].tp,InpColTP,STYLE_DOT,1,"#"+t+" tp");
      else ObjectDelete(panelChart,P+"T_"+t);
   }
}

void UpdateBasketLines()
{
   if(basketLots<=0 || basketAvg<=0){ ClearBasketLines(); return; }
   DrawHLine(P+"BAVG",basketAvg,InpColEntry,STYLE_SOLID,2,StringFormat("basket %s %.2f",(bDir>0?"buy":"sell"),basketLots));
   DrawHLine(P+"BTP",basketTP,InpColTP,STYLE_SOLID,2,"basket tp");
   if(basketTrailActive && basketSL>0) DrawHLine(P+"BSL",basketSL,InpColSL,STYLE_SOLID,2,"basket sl");
   else ObjectDelete(panelChart,P+"BSL");
}

//+------------------------------------------------------------------+
//| UI refresh (throttled, never inside the tick loop)               |
//+------------------------------------------------------------------+
void SetT(const int k,const string id,const string t0)
{
   string t=(t0=="")?" ":t0;
   if(lcT[k]==t) return;
   lcT[k]=t;
   ObjectSetString(panelChart,P+id,OBJPROP_TEXT,t);
}
void SetCol(const int k,const string id,const color c)
{
   if(lcC[k]==c) return;
   lcC[k]=c;
   ObjectSetInteger(panelChart,P+id,OBJPROP_COLOR,c);
}

void UpdateUI()
{
   uiForce=false;

   double flo=0, used=0, buyL=0, sellL=0; int nb=0, ns=0;
   for(int i=0;i<ArraySize(pos);i++)
   {
      if(!pos[i].open_) continue;
      double fl=CalcProfit(pos[i].dir,pos[i].open,pos[i].lots,pos[i].dir>0?curBid:curAsk);
      flo+=fl;
      used+=pos[i].lots*InpContractSize*pos[i].open/leverage;
      if(pos[i].dir>0){ buyL+=pos[i].lots; nb++; } else { sellL+=pos[i].lots; ns++; }
         ObjectSetString(panelChart,P+"E_"+IntegerToString((long)pos[i].ticket),OBJPROP_TEXT,
            StringFormat("#%I64u %s %.2f   %s",pos[i].ticket,(pos[i].dir>0?"buy":"sell"),pos[i].lots,MoneyS(fl)));
   }
   eq=bal+flo;
   double freeM=eq-used;
   double mlvl=(used>0)?eq/used*100.0:0;

   if(needCompact) CompactPositions();
   if(ordCompact)  CompactOrders();
   if(linesDirty)
   {
      linesDirty=false;
      UpdateOrderLines();
      UpdateTradeLines();
      if(InpTradeMode==MODE_MARTINGALE) UpdateBasketLines();
   }
   ProcessHistory();
   if(btnDirty){ btnDirty=false; UpdateButtonStates(false); }
   if(pendLog!=""){ Print(pendLog); pendLog=""; }

   // simulated time & candle countdown
   double simSec=(double)rates[cur].time+barClockUs/1e6;
   int tfs=PeriodSeconds(currentTF); if(tfs<=0) tfs=300;
   double tfOff=(currentTF==PERIOD_W1)?3.0*86400.0:0.0;
   double remReal=(tfs-MathMod(simSec-tfOff,(double)tfs))/MathMax(0.01,speedMult);
   int rm=(int)(remReal/60.0), rs=(int)MathMod(remReal,60.0), rt=(int)(MathMod(remReal,1.0)*10.0);

   // --- big quote buttons
   SetT(K_SELL,"SELL","SELL   "+Px(curBid));
   SetT(K_BUY, "BUY", "BUY   "+Px(curAsk));
   SetT(K_SPEED,"SPDV",SpeedTxt(speedMult));

   // --- account cells
   SetT(K_BAL,"VB",Money(bal));
   SetT(K_EQ, "VE",Money(eq));   SetCol(K_EQ,"VE",PnlCol(eq-bal));
   SetT(K_FLO,"VF",MoneyS(flo)); SetCol(K_FLO,"VF",PnlCol(flo));

   SetT(K_MG,"VMG",Money(used));
   SetT(K_FM,"VFM",Money(freeM)); SetCol(K_FM,"VFM",(freeM>=0)?clrWhite:C'255,100,100');
   SetT(K_ML,"VML",(used>0)?DoubleToString(mlvl,1)+"%":"--");
   SetCol(K_ML,"VML",(used<=0)?clrWhite:(mlvl<InpStopOutPct*1.5)?C'255,100,100':(mlvl<150.0)?C'255,190,60':C'90,225,130');

   double mpl=InpContractSize*curAsk/leverage;           // margin for 1.00 lot
   int fit=(mpl*lotSize>0)?(int)MathFloor(MathMax(0.0,freeM)/(mpl*lotSize)):0;
   SetT(K_LI,"LI",StringFormat("Margin/1 lot %s   |   This lot %s   |   Max lot %.2f   |   Fits %d trade(s)",
        Money(mpl),Money(mpl*lotSize),MaxLotFor(freeM,curAsk),fit));

   int op=nb+ns;
   SetT(K_POS,"POS",(op==0)?StringFormat("No open positions   |   Pending: %d",ordLive)
        :StringFormat("Open %d   |   Buy %.2f (%d)   Sell %.2f (%d)   Net %+.2f   |   Pending: %d",op,buyL,nb,sellL,ns,buyL-sellL,ordLive));

   SetT(K_TD,"VT",MoneyS(dayProfit));   SetCol(K_TD,"VT",PnlCol(dayProfit));
   SetT(K_YD,"VY",MoneyS(ydayProfit));  SetCol(K_YD,"VY",PnlCol(ydayProfit));
   SetT(K_WK,"VW",MoneyS(weekProfit));  SetCol(K_WK,"VW",PnlCol(weekProfit));
   SetT(K_MO,"VM",MoneyS(monthProfit)); SetCol(K_MO,"VM",PnlCol(monthProfit));
   SetT(K_LOTS,"LOTS",StringFormat("Lots traded   Today %.2f   |   Week %.2f   |   Month %.2f",dayLots,weekLots,monthLots));

   if(InpTradeMode==MODE_SINGLE)
      SetT(K_MODE,"MODE",StringFormat("Mode: Single | تک معامله   SL %d  TP %d  Trail %s %d/%d   Lev 1:%d",slPts,tpPts,(trailOn?"ON":"OFF"),trStart,trStep,leverage));
   else
      SetT(K_MODE,"MODE",StringFormat("Mode: Martingale | مارتینگل   Lvl %d  Avg %s  Lots %.2f  Trail %s",
           martLevel,(basketAvg>0?Px(basketAvg):"--"),basketLots,basketTrailActive?"ON":"OFF"));

   SetT(K_INFO,"INFO",StringFormat("%s %s   %s   Bid %s   Ask %s   Spr %d",(playing?"▶":"⏸"),SpeedTxt(speedMult),
        TimeToString((datetime)simSec,TIME_DATE|TIME_SECONDS),Px(curBid),Px(curAsk),InpSpreadPts));
   SetT(K_INFO2,"INFO2",StringFormat("TF %s   |   bar %d/%d   |   tick %d/%d   |   ⏱ %d:%02d.%d",
        TFName(currentTF),cur+1,total,tkIdx,tkN,rm,rs,rt));
   SetT(K_MSG,"MSG",lastMsg);

   if(trOpen) RefreshTrades();
   ChartRedraw(panelChart);
}

//+------------------------------------------------------------------+
//| Panel: framed, 3D-style buttons                                  |
//+------------------------------------------------------------------+
color Lighten(const color c,const int a)
{
   int r=(int)(((uint)c)&0xFF), g=(int)((((uint)c)>>8)&0xFF), b=(int)((((uint)c)>>16)&0xFF);
   r=MathMin(255,r+a); g=MathMin(255,g+a); b=MathMin(255,b+a);
   return (color)(r|(g<<8)|(b<<16));
}
void Rect(const string id,const int x,const int y,const int w,const int h,const color bg,const color border,const int z=0)
{
   string n=P+id;
   ObjectCreate(panelChart,n,OBJ_RECTANGLE_LABEL,0,0,0);
   ObjectSetInteger(panelChart,n,OBJPROP_CORNER,CORNER_LEFT_UPPER);
   ObjectSetInteger(panelChart,n,OBJPROP_XDISTANCE,x);
   ObjectSetInteger(panelChart,n,OBJPROP_YDISTANCE,y);
   ObjectSetInteger(panelChart,n,OBJPROP_XSIZE,w);
   ObjectSetInteger(panelChart,n,OBJPROP_YSIZE,h);
   ObjectSetInteger(panelChart,n,OBJPROP_BGCOLOR,bg);
   ObjectSetInteger(panelChart,n,OBJPROP_BORDER_TYPE,BORDER_FLAT);
   ObjectSetInteger(panelChart,n,OBJPROP_COLOR,border);
   ObjectSetInteger(panelChart,n,OBJPROP_BACK,false);
   ObjectSetInteger(panelChart,n,OBJPROP_SELECTABLE,false);
   ObjectSetInteger(panelChart,n,OBJPROP_ZORDER,z);
}
void Reg(const string id,const int x,const int y,const int w,const int h)
{
   if(rN>=48) return;
   rId[rN]=id; rX[rN]=x; rY[rN]=y; rW[rN]=w; rH[rN]=h; rN++;
}
void RawBtn(const string n,const string t,const int x,const int y,const int w,const int h,
            const color bg,const color tc,const color border,const int fs,const int z)
{
   ObjectCreate(panelChart,n,OBJ_BUTTON,0,0,0);
   ObjectSetInteger(panelChart,n,OBJPROP_XDISTANCE,x);
   ObjectSetInteger(panelChart,n,OBJPROP_YDISTANCE,y);
   ObjectSetInteger(panelChart,n,OBJPROP_XSIZE,w);
   ObjectSetInteger(panelChart,n,OBJPROP_YSIZE,h);
   ObjectSetString(panelChart,n,OBJPROP_TEXT,t);
   ObjectSetString(panelChart,n,OBJPROP_FONT,"Segoe UI Semibold");
   ObjectSetInteger(panelChart,n,OBJPROP_FONTSIZE,fs);
   ObjectSetInteger(panelChart,n,OBJPROP_COLOR,tc);
   ObjectSetInteger(panelChart,n,OBJPROP_BGCOLOR,bg);
   ObjectSetInteger(panelChart,n,OBJPROP_BORDER_COLOR,border);
   ObjectSetInteger(panelChart,n,OBJPROP_CORNER,CORNER_LEFT_UPPER);
   ObjectSetInteger(panelChart,n,OBJPROP_SELECTABLE,false);
   ObjectSetInteger(panelChart,n,OBJPROP_ZORDER,z);
   ObjectSetInteger(panelChart,n,OBJPROP_STATE,false);
}
void Btn3D(const string id,const string t,const int x,const int y,const int w,const int h,const color bg,const int fs=9)
{
   Rect(id+"_sh",x+2,y+3,w,h,C'6,8,14',C'6,8,14');
   RawBtn(P+id,t,x,y,w,h,bg,clrWhite,Lighten(bg,55),fs,500);
   Rect(id+"_hl",x+2,y+2,w-4,1,Lighten(bg,110),Lighten(bg,110));
   Reg(id,x,y,w,h);
}
void SetBtn(const string id,const color bg,const color tc)
{
   ObjectSetInteger(panelChart,P+id,OBJPROP_BGCOLOR,bg);
   ObjectSetInteger(panelChart,P+id,OBJPROP_COLOR,tc);
   ObjectSetInteger(panelChart,P+id,OBJPROP_BORDER_COLOR,Lighten(bg,55));
   ObjectSetInteger(panelChart,P+id+"_hl",OBJPROP_BGCOLOR,Lighten(bg,110));
   ObjectSetInteger(panelChart,P+id+"_hl",OBJPROP_COLOR,Lighten(bg,110));
}

void Lbl(const string id,const string t,const int x,const int y,const color c=clrYellow,
         const int fs=9,const string font="Segoe UI")
{
   string n=P+id;
   ObjectCreate(panelChart,n,OBJ_LABEL,0,0,0);
   ObjectSetInteger(panelChart,n,OBJPROP_XDISTANCE,x);
   ObjectSetInteger(panelChart,n,OBJPROP_YDISTANCE,y);
   ObjectSetString(panelChart,n,OBJPROP_TEXT,(t=="")?" ":t);       // empty text would show "Label"
   ObjectSetString(panelChart,n,OBJPROP_FONT,font);
   ObjectSetInteger(panelChart,n,OBJPROP_COLOR,c);
   ObjectSetInteger(panelChart,n,OBJPROP_CORNER,CORNER_LEFT_UPPER);
   ObjectSetInteger(panelChart,n,OBJPROP_FONTSIZE,fs);
   ObjectSetInteger(panelChart,n,OBJPROP_SELECTABLE,false);
   ObjectSetInteger(panelChart,n,OBJPROP_ZORDER,0);
}

void EditBox(const string id,const string t,const int x,const int y,const int w,const int h)
{
   string n=P+id;
   ObjectCreate(panelChart,n,OBJ_EDIT,0,0,0);
   ObjectSetInteger(panelChart,n,OBJPROP_XDISTANCE,x);
   ObjectSetInteger(panelChart,n,OBJPROP_YDISTANCE,y);
   ObjectSetInteger(panelChart,n,OBJPROP_XSIZE,w);
   ObjectSetInteger(panelChart,n,OBJPROP_YSIZE,h);
   ObjectSetString(panelChart,n,OBJPROP_TEXT,t);
   ObjectSetString(panelChart,n,OBJPROP_FONT,"Segoe UI Semibold");
   ObjectSetInteger(panelChart,n,OBJPROP_FONTSIZE,11);
   ObjectSetInteger(panelChart,n,OBJPROP_COLOR,clrBlack);
   ObjectSetInteger(panelChart,n,OBJPROP_BGCOLOR,clrWhite);
   ObjectSetInteger(panelChart,n,OBJPROP_BORDER_COLOR,C'0,120,215');
   ObjectSetInteger(panelChart,n,OBJPROP_CORNER,CORNER_LEFT_UPPER);
   ObjectSetInteger(panelChart,n,OBJPROP_ALIGN,ALIGN_CENTER);
   ObjectSetInteger(panelChart,n,OBJPROP_ZORDER,500);
}

void DateField(const string id,const datetime d,const int x,const int y)
{
   RawBtn(P+id,TimeToString(d,TIME_DATE),x,y,104,26,clrWhite,clrBlack,C'0,120,215',10,500);
   Reg(id,x,y,104,26);
   Btn3D(id+"_I","▦ ▾",x+104,y,28,26,C'96,110,140',9);
}

void BuildPanel()
{
   ObjectsDeleteAll(panelChart,P);
   rN=0; calOpen=false; ctxOpen=false;
   for(int i=0;i<40;i++){ lcC[i]=clrNONE; lcT[i]="~~"; }
   const int PX=4, PY=4;
   panW=480;
   const int x=PX+14;
   const color KEY=C'140,152,185', LAB=C'190,200,225';
   int y=PY+34;

   Rect("FRAME", PX,  PY,  panW,   400,C'24,30,46',C'0,150,255');
   Rect("FRAME2",PX+3,PY+3,panW-6, 394,C'24,30,46',C'52,68,104');
   Rect("TBAR",  PX+4,PY+4,panW-8, 24, C'0,92,170',C'0,92,170');
   Lbl("TTL","◆  MARKET REPLAY  v9.1   |   ریپلی بازار",x,PY+8,clrWhite,10,"Segoe UI Semibold");

   // --- row 1: transport
   Btn3D("PLAY",  "▶ Play",  x,     y,104,30,clrDarkGreen,10);
   Btn3D("PAUSE", "⏸ Pause", x+112, y,104,30,clrDarkOrange,10);
   Btn3D("TRADES","▤ Trades",x+224, y,124,30,clrSteelBlue,10);

   // --- row 2: speed slider
   y+=40;
   Lbl("LS","Speed",x,y+4,LAB,9);
   slX=x+50; slY=y;
   Rect("SL_TRK",slX,slY+SL_H/2-5,slW,10,C'208,213,226',C'96,108,140',600);
   Rect("SL_GRV",slX+3,slY+SL_H/2-1,slW-6,2,C'120,132,165',C'120,132,165',600);
   for(int i=0;i<5;i++)
   {
      string tx=(i==0)?"0.1x":(i==1)?"1x":(i==2)?"10x":(i==3)?"100x":"1000x";
      int tx_x=slX+(int)MathRound(i*0.25*(slW-SL_TH))+SL_TH/2-(StringLen(tx)*3);
      Lbl("SK"+IntegerToString(i),tx,tx_x,y+SL_H+3,KEY,7);
      Rect("ST"+IntegerToString(i),slX+(int)MathRound(i*0.25*(slW-SL_TH))+SL_TH/2,slY+SL_H/2+6,1,4,C'96,108,140',C'96,108,140',600);
   }
   RawBtn(P+"SL_TH","",slX,slY,SL_TH,SL_H,C'238,241,248',clrBlack,C'70,80,115',8,700);
   PlaceThumb();
   Lbl("SPDV","Live 1x",x+322,y+3,clrGold,11,"Segoe UI Semibold");
   Btn3D("LIVE","Live",x+400,y,52,26,clrTeal);

   // --- row 3: timeframes
   y+=50;
   Lbl("LTF","TF",x,y+5,LAB);
   Btn3D("TF_M1", "M1",  x+26,  y,48,26,clrSteelBlue);
   Btn3D("TF_M5", "M5",  x+78,  y,48,26,clrSteelBlue);
   Btn3D("TF_M15","M15", x+130, y,48,26,clrSteelBlue);
   Btn3D("TF_M30","M30", x+182, y,48,26,clrSteelBlue);
   Btn3D("TF_H1", "H1",  x+234, y,48,26,clrSteelBlue);
   Btn3D("TF_H4", "H4",  x+286, y,48,26,clrSteelBlue);
   Btn3D("TF_D1", "D1",  x+338, y,48,26,clrSteelBlue);
   Btn3D("TF_W1", "W1",  x+390, y,48,26,clrSteelBlue);

   // --- row 4: date range
   y+=38;
   dateRowY=y; fromFieldX=x+44; toFieldX=x+246;
   Lbl("LF","From:",x,y+5,LAB);
   DateField("FROM",selFrom,fromFieldX,y);
   Lbl("LT","To:",x+206,y+5,LAB);
   DateField("TO",selTo,toFieldX,y);

   // --- row 5: lot + leverage
   y+=38;
   Lbl("LLOT","Lot:",x,y+5,LAB);
   Btn3D("LOT_M","−",x+34, y,30,26,clrDimGray,12);
   EditBox("LOT",DoubleToString(lotSize,2),x+68,y,78,26);
   Btn3D("LOT_P","+",x+150,y,30,26,clrDimGray,12);
   Btn3D("MAXLOT","Max",x+186,y,46,26,clrSlateGray,9);
   Lbl("LLEV","Leverage  1 :",x+250,y+5,LAB);
   EditBox("LEV",IntegerToString(leverage),x+346,y,70,26);
   y+=31;
   Lbl("LI","",x,y,KEY,8);
   y+=22;

   // --- row 6: SL / TP
   Lbl("LSL","SL pts:",x,y+5,LAB);
   EditBox("SLP",IntegerToString(slPts),x+50,y,76,26);
   Lbl("LTP",(InpTradeMode==MODE_SINGLE)?"TP pts:":"Basket TP:",x+140,y+5,LAB);
   EditBox("TPP",IntegerToString(tpPts),x+206,y,76,26);
   Btn3D("APPLY","Apply to open",x+296,y,120,26,clrSteelBlue,9);

   // --- row 6b: trailing stop
   y+=36;
   Lbl("LTR",(InpTradeMode==MODE_SINGLE)?"Trailing:":"Basket trail:",x,y+5,LAB);
   Btn3D("TRAIL_T",trailOn?"ON":"OFF",x+84,y,52,26,trailOn?clrForestGreen:clrDimGray,9);
   Lbl("LTS","Start pts:",x+146,y+5,LAB);
   EditBox("TRS",IntegerToString(trStart),x+214,y,66,26);
   Lbl("LTP2","Step pts:",x+290,y+5,LAB);
   EditBox("TRP",IntegerToString(trStep),x+354,y,66,26);

   // --- row 7: balance control
   y+=36;
   Lbl("LBV","Amount:",x,y+5,LAB);
   EditBox("BALV",DoubleToString(resetBal,2),x+56,y,110,26);
   Btn3D("BAL_RESET","Reset balance",x+174,y,130,26,clrDarkOrange,9);
   Btn3D("BAL_DEP","+ Deposit",x+312,y,110,26,clrTeal,9);

   // --- row 8: SELL (left)  CLOSE  BUY (right)
   y+=40;
   Btn3D("SELL", "SELL",     x,     y,166,46,clrFireBrick,12);
   Btn3D("CLOSE","Close All",x+174, y,104,46,clrDimGray,10);
   Btn3D("BUY",  "BUY",      x+286, y,166,46,clrForestGreen,12);

   // --- stats block
   y+=58;
   int statTop=y-6;
   Rect("STATS",x-6,statTop,panW-16,200,C'12,16,28',C'60,74,108');
   Lbl("KB","BALANCE",x,y,KEY,8);          Lbl("VB","",x,y+12,clrWhite,13,"Segoe UI Semibold");
   Lbl("KE","EQUITY",x+156,y,KEY,8);       Lbl("VE","",x+156,y+12,clrWhite,13,"Segoe UI Semibold");
   Lbl("KF","FLOATING P/L",x+312,y,KEY,8); Lbl("VF","",x+312,y+12,clrWhite,13,"Segoe UI Semibold");
   y+=42;
   Lbl("KG","USED MARGIN",x,y,KEY,8);          Lbl("VMG","",x,y+12,clrWhite,11,"Segoe UI Semibold");
   Lbl("KH","FREE MARGIN",x+156,y,KEY,8);      Lbl("VFM","",x+156,y+12,clrWhite,11,"Segoe UI Semibold");
   Lbl("KL","MARGIN LEVEL",x+312,y,KEY,8);     Lbl("VML","",x+312,y+12,clrWhite,11,"Segoe UI Semibold");
   y+=40;
   Lbl("POS","",x,y,clrWhite,9);
   y+=22;
   Rect("SEP1",x,y-2,panW-28,1,C'60,74,108',C'60,74,108');
   Lbl("KT","TODAY",x,y+2,KEY,8);          Lbl("VT","",x,y+14,clrWhite,11,"Segoe UI Semibold");
   Lbl("KY","YESTERDAY",x+114,y+2,KEY,8);  Lbl("VY","",x+114,y+14,clrWhite,11,"Segoe UI Semibold");
   Lbl("KW","WEEK",x+228,y+2,KEY,8);       Lbl("VW","",x+228,y+14,clrWhite,11,"Segoe UI Semibold");
   Lbl("KM","MONTH",x+342,y+2,KEY,8);      Lbl("VM","",x+342,y+14,clrWhite,11,"Segoe UI Semibold");
   y+=40;
   Lbl("LOTS","",x,y,LAB,9);               y+=20;
   Lbl("MODE","",x,y,LAB,9);               y+=22;
   Rect("SEP2",x,y-2,panW-28,1,C'60,74,108',C'60,74,108');
   Lbl("INFO","",x,y+2,clrWhite,9);        y+=19;
   Lbl("INFO2","",x,y+2,clrWhite,9);       y+=19;
   Lbl("MSG","",x,y+2,clrTomato,9);        y+=19;
   Lbl("HINT","Keys: B=Buy  S=Sell  C=Close  Space=Play/Pause  +/-=Speed  Esc=Cancel",x,y+2,C'110,124,160',8);
   y+=26;

   panH=y-PY;
   ObjectSetInteger(panelChart,P+"FRAME", OBJPROP_YSIZE,panH);
   ObjectSetInteger(panelChart,P+"FRAME2",OBJPROP_YSIZE,panH-6);
   ObjectSetInteger(panelChart,P+"STATS", OBJPROP_YSIZE,y-26-statTop+22);
}

void SpBtn(const string id,const bool on,const color idle)
{
   if(on) SetBtn(id,clrGold,clrBlack); else SetBtn(id,idle,clrWhite);
}
void TfBtn(const string id,const ENUM_TIMEFRAMES tf)
{
   if(currentTF==tf) SetBtn(id,clrDodgerBlue,clrWhite); else SetBtn(id,clrSteelBlue,clrWhite);
}

void UpdateButtonStates(const bool redraw)
{
   SetBtn("PLAY", playing?clrLimeGreen:clrDarkGreen, playing?clrBlack:clrWhite);
   SetBtn("PAUSE",playing?clrDarkOrange:clrOrange,   clrWhite);
   ObjectSetString(panelChart,P+"PLAY", OBJPROP_TEXT,playing?"▶ Playing":"▶ Play");
   ObjectSetString(panelChart,P+"PAUSE",OBJPROP_TEXT,playing?"⏸ Pause":"⏸ Paused");
   if(trOpen) SetBtn("TRADES",clrDodgerBlue,clrWhite); else SetBtn("TRADES",clrSteelBlue,clrWhite);
   SpBtn("LIVE",speedMult==1.0,clrTeal);
   SetBtn("TRAIL_T",trailOn?clrForestGreen:clrDimGray,clrWhite);
   ObjectSetString(panelChart,P+"TRAIL_T",OBJPROP_TEXT,trailOn?"ON":"OFF");

   TfBtn("TF_M1",PERIOD_M1);   TfBtn("TF_M5",PERIOD_M5);   TfBtn("TF_M15",PERIOD_M15);
   TfBtn("TF_M30",PERIOD_M30); TfBtn("TF_H1",PERIOD_H1);   TfBtn("TF_H4",PERIOD_H4);
   TfBtn("TF_D1",PERIOD_D1);   TfBtn("TF_W1",PERIOD_W1);
   SetT(K_SPEED,"SPDV",SpeedTxt(speedMult));
   if(redraw) ChartRedraw(panelChart);
}

//+------------------------------------------------------------------+
//| Calendar popup (month grid, Sun..Sat, like a Windows date picker)|
//+------------------------------------------------------------------+
void CalBtn(const string id,const string t,const int x,const int y,const int w,const int h,
            const color bg,const color tc,const color border,const int fs=9)
{
   RawBtn(P+"CAL_"+id,t,x,y,w,h,bg,tc,border,fs,2000);
}
void OpenCal(const int target)
{
   CloseCal();
   calTarget=target; calOpen=true;
   datetime d=(target==0)?selFrom:selTo;
   MqlDateTime s; TimeToStruct(d,s);
   calYear=s.year; calMon=s.mon;
   int fx=(target==0)?fromFieldX:toFieldX;
   calX=MathMin(fx,4+panW-calW-6);
   calY=dateRowY+28;

   Rect("CAL_BG",calX,calY,calW,calH,clrWhite,C'110,110,110',1999);
   CalBtn("PREV","◀",calX+6,calY+4,28,24,clrWhite,C'60,60,60',clrWhite,10);
   CalBtn("NEXT","▶",calX+calW-34,calY+4,28,24,clrWhite,C'60,60,60',clrWhite,10);
   CalBtn("TITLE","",calX+40,calY+4,calW-80,24,clrWhite,clrBlack,clrWhite,10);
   string wd[7]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
   int gx=calX+8, gy=calY+CAL_HDR+CAL_WK;
   for(int c=0;c<7;c++)
      CalBtn("W"+IntegerToString(c),wd[c],gx+c*CAL_CW,calY+CAL_HDR,CAL_CW,CAL_WK,clrWhite,C'40,40,40',clrWhite,9);
   for(int i=0;i<42;i++)
      CalBtn("D"+IntegerToString(i),"",gx+(i%7)*CAL_CW+1,gy+(i/7)*CAL_CH+1,CAL_CW-2,CAL_CH-2,clrWhite,clrBlack,clrWhite,10);
   CalBtn("TODAY","Today: "+TimeToString(DayStart(TimeLocal()),TIME_DATE),gx,gy+6*CAL_CH+4,210,24,clrWhite,C'30,30,30',C'0,120,215',9);
   RefreshCal();
   ChartRedraw(panelChart);
}
void RefreshCal()
{
   ObjectSetString(panelChart,P+"CAL_TITLE",OBJPROP_TEXT,MonName[calMon-1]+" "+IntegerToString(calYear));
   datetime first=StringToTime(StringFormat("%04d.%02d.01",calYear,calMon));
   MqlDateTime f; TimeToStruct(first,f);
   datetime start=first-(datetime)((long)f.day_of_week*86400);
   datetime sel=(calTarget==0)?selFrom:selTo;
   datetime today=DayStart(TimeLocal());
   for(int i=0;i<42;i++)
   {
      datetime d=start+(datetime)((long)i*86400);
      MqlDateTime m; TimeToStruct(d,m);
      bool inMon=(m.mon==calMon);
      bool on=(d>=dataFirst && d<=dataLast);
      calDate[i]=d; calOn[i]=on;
      string n=P+"CAL_D"+IntegerToString(i);
      ObjectSetString(panelChart,n,OBJPROP_TEXT,IntegerToString(m.day));
      color tc=!on?C'205,205,205':(inMon?clrBlack:C'140,140,140');
      color bg=(d==sel)?C'204,228,247':clrWhite;
      color bd=(d==sel)?C'0,120,215':((d==today)?clrCrimson:clrWhite);
      ObjectSetInteger(panelChart,n,OBJPROP_COLOR,tc);
      ObjectSetInteger(panelChart,n,OBJPROP_BGCOLOR,bg);
      ObjectSetInteger(panelChart,n,OBJPROP_BORDER_COLOR,bd);
   }
}
void CloseCal()
{
   if(!calOpen) return;
   ObjectsDeleteAll(panelChart,P+"CAL_");
   calOpen=false;
   ChartRedraw(panelChart);
}
void PickDate(const datetime d)
{
   if(calTarget==0){ selFrom=d; if(selTo<selFrom) selTo=selFrom; }
   else            { selTo=d;   if(selFrom>selTo) selFrom=selTo; }
   selDirty=true;
   ObjectSetString(panelChart,P+"FROM",OBJPROP_TEXT,TimeToString(selFrom,TIME_DATE));
   ObjectSetString(panelChart,P+"TO",  OBJPROP_TEXT,TimeToString(selTo,TIME_DATE));
   lastMsg="Range set - press Play to apply | محدوده انتخاب شد، Play را بزنید";
   CloseCal();
}

//+------------------------------------------------------------------+
//| Trades window: floating, draggable, resizable, MT5-like table    |
//+------------------------------------------------------------------+
double twFr[10]={0.09,0.08,0.15,0.10,0.07,0.11,0.10,0.10,0.10,0.10};

void TwReg(const string n,const int ox,const int oy)
{
   if(twCnt>=600) return;
   twN[twCnt]=n; twOX[twCnt]=ox; twOY[twCnt]=oy; twCnt++;
}

void TwRect(const string id,const int ox,const int oy,const int w,const int h,const color bg,const color bd)
{
   Rect(id,trX+ox,trY+oy,w,h,bg,bd,3000);
   TwReg(P+id,ox,oy);
}

void TwLbl(const string id,const string t,const int ox,const int oy,const color c,const int fs,const bool right,
           const string font="Segoe UI")
{
   string n=P+id;
   ObjectCreate(panelChart,n,OBJ_LABEL,0,0,0);
   ObjectSetInteger(panelChart,n,OBJPROP_CORNER,CORNER_LEFT_UPPER);
   ObjectSetInteger(panelChart,n,OBJPROP_ANCHOR,right?ANCHOR_RIGHT_UPPER:ANCHOR_LEFT_UPPER);
   ObjectSetInteger(panelChart,n,OBJPROP_XDISTANCE,trX+ox);
   ObjectSetInteger(panelChart,n,OBJPROP_YDISTANCE,trY+oy);
   ObjectSetString(panelChart,n,OBJPROP_TEXT,(t=="")?" ":t);      // empty text would show "Label"
   ObjectSetString(panelChart,n,OBJPROP_FONT,font);
   ObjectSetInteger(panelChart,n,OBJPROP_FONTSIZE,fs);
   ObjectSetInteger(panelChart,n,OBJPROP_COLOR,c);
   ObjectSetInteger(panelChart,n,OBJPROP_SELECTABLE,false);
   ObjectSetInteger(panelChart,n,OBJPROP_ZORDER,0);
   TwReg(n,ox,oy);
}

void BuildTrades()
{
   ObjectsDeleteAll(panelChart,P+"TW_");
   twCnt=0; trOpen=true;
   int cw=(int)ChartGetInteger(panelChart,CHART_WIDTH_IN_PIXELS);
   int ch=(int)ChartGetInteger(panelChart,CHART_HEIGHT_IN_PIXELS);
   trW=MathMax(600,MathMin(trW,cw-4)); trH=MathMax(160,MathMin(trH,ch-4));
   trX=MathMax(0,MathMin(trX,cw-trW)); trY=MathMax(0,MathMin(trY,ch-trH));
   twVis=MathMax(1,MathMin(TR_MAXROWS,(trH-TR_TITLE-TR_HEAD-TR_FOOT)/TR_ROWH));
   for(int i=0;i<500;i++){ twC[i]="~~"; twCC[i]=clrNONE; }
   for(int i=36;i<40;i++){ lcT[i]="~~"; lcC[i]=clrNONE; }

   TwRect("TW_BG",0,0,trW,trH,C'252,252,254',C'80,92,130');
   TwRect("TW_TBAR",1,1,trW-2,TR_TITLE-1,C'0,92,170',C'0,92,170');
   TwLbl("TW_TTL","Trades   |   معاملات",8,4,clrWhite,9,false,"Arial Bold");
   TwLbl("TW_XC","✕",trW-20,3,clrWhite,10,false);
   TwRect("TW_HD",1,TR_TITLE,trW-2,TR_HEAD,C'208,216,236',C'160,172,204');

   // bold, large, dark column titles
   string hd[10]={"Symbol","Ticket","Time","Type","Volume","Price","S / L","T / P","Price","Profit"};
   double tw=(double)(trW-2-30);
   double acc=1.0;
   double colR[10]; double colL[10];
   for(int c=0;c<10;c++){ colL[c]=acc; acc+=twFr[c]*tw; colR[c]=acc; }
   for(int c=0;c<10;c++)
      TwLbl("TW_H"+IntegerToString(c),hd[c],(int)(c<4?colL[c]+6:colR[c]-6),TR_TITLE+6,C'10,20,70',10,c>=4,"Arial Bold");

   for(int r=0;r<twVis;r++)
   {
      int yy=TR_TITLE+TR_HEAD+r*TR_ROWH;
      color bg=(r%2==0)?C'255,255,255':C'243,246,251';
      TwRect("TW_S"+IntegerToString(r),1,yy,trW-2,TR_ROWH,bg,bg);
      for(int c=0;c<10;c++)
         TwLbl("TW_C"+IntegerToString(r)+"_"+IntegerToString(c)," ",(int)(c<4?colL[c]+6:colR[c]-6),yy+3,C'30,36,60',9,c>=4);
      TwLbl("TW_C"+IntegerToString(r)+"_10"," ",trW-24,yy+2,C'200,40,40',10,false);
   }

   // footer: big bold Balance / Equity / Profit
   int fy=trH-TR_FOOT;
   TwRect("TW_FT",1,fy,trW-2,TR_FOOT-1,C'208,216,236',C'160,172,204');
   TwLbl("TW_FBK","Balance:",10,fy+8,C'40,50,90',10,false,"Arial Bold");
   TwLbl("TW_FBV"," ",84,fy+7,C'8,16,60',12,false,"Arial Bold");
   TwLbl("TW_FEK","Equity:",210,fy+8,C'40,50,90',10,false,"Arial Bold");
   TwLbl("TW_FEV"," ",272,fy+7,C'8,16,60',12,false,"Arial Bold");
   TwLbl("TW_FPK","Profit:",390,fy+8,C'40,50,90',10,false,"Arial Bold");
   TwLbl("TW_FPV"," ",446,fy+7,C'0,130,50',12,false,"Arial Bold");
   TwLbl("TW_UP","▲",trW-72,fy+8,C'70,80,115',10,false);
   TwLbl("TW_DN","▼",trW-46,fy+8,C'70,80,115',10,false);
   TwLbl("TW_GR","◢",trW-15,trH-17,C'110,120,150',9,false);
}

void TwSet(const int r,const int c,const string txt0,const color col)
{
   int k=r*11+c;
   if(k>=500) return;
   string txt=(txt0=="")?" ":txt0;                                // never leave a label empty
   string n=P+"TW_C"+IntegerToString(r)+"_"+IntegerToString(c);
   if(twC[k]!=txt){ twC[k]=txt; ObjectSetString(panelChart,n,OBJPROP_TEXT,txt); }
   if(twCC[k]!=col){ twCC[k]=col; ObjectSetInteger(panelChart,n,OBJPROP_COLOR,col); }
}

void RefreshTrades()
{
   if(!trOpen) return;
   twRows=0;
   for(int i=0;i<ArraySize(pos);i++)  if(pos[i].open_ && twRows<800){ twKind[twRows]=0; twIdx[twRows]=i; twRows++; }
   for(int i=0;i<ArraySize(ords);i++) if(ords[i].live && twRows<800){ twKind[twRows]=1; twIdx[twRows]=i; twRows++; }
   trTop=MathMax(0,MathMin(trTop,MathMax(0,twRows-twVis)));

   const color TX=C'30,36,60', BUYC=C'0,90,200', SELLC=C'200,40,40', GRN=C'0,140,60', RED=C'200,40,40';
   for(int r=0;r<twVis;r++)
   {
      int row=trTop+r;
      if(row>=twRows){ for(int c=0;c<=10;c++) TwSet(r,c,"",TX); continue; }
      if(twKind[row]==0)
      {
         int i=twIdx[row];
         double pr=(pos[i].dir>0)?curBid:curAsk;
         double fl=CalcProfit(pos[i].dir,pos[i].open,pos[i].lots,pr);
         double ssl=pos[i].sl, stp=pos[i].tp;
         if(InpTradeMode==MODE_MARTINGALE){ ssl=basketTrailActive?basketSL:0; stp=basketTP; }
         TwSet(r,0,baseSym,TX);
         TwSet(r,1,IntegerToString((long)pos[i].ticket),TX);
         TwSet(r,2,TimeToString(pos[i].time,TIME_DATE|TIME_SECONDS),TX);
         TwSet(r,3,(pos[i].dir>0)?"buy":"sell",(pos[i].dir>0)?BUYC:SELLC);
         TwSet(r,4,DoubleToString(pos[i].lots,2),TX);
         TwSet(r,5,Px(pos[i].open),TX);
         TwSet(r,6,ssl>0?Px(ssl):"",TX);
         TwSet(r,7,stp>0?Px(stp):"",TX);
         TwSet(r,8,Px(pr),TX);
         TwSet(r,9,Money(fl),(fl>=0)?GRN:RED);
         TwSet(r,10,"✕",RED);
      }
      else
      {
         int i=twIdx[row];
         int t=ords[i].type;
         bool buy=(t==1||t==3);
         TwSet(r,0,baseSym,TX);
         TwSet(r,1,IntegerToString((long)ords[i].ticket),TX);
         TwSet(r,2,TimeToString(ords[i].time,TIME_DATE|TIME_SECONDS),TX);
         TwSet(r,3,OrdTypeName(t),buy?BUYC:SELLC);
         TwSet(r,4,DoubleToString(ords[i].lots,2),TX);
         TwSet(r,5,Px(ords[i].price),TX);
         TwSet(r,6,"",TX); TwSet(r,7,"",TX);
         TwSet(r,8,Px(buy?curAsk:curBid),TX);
         TwSet(r,9,"",TX);
         TwSet(r,10,"✕",RED);
      }
   }

   // footer values: large, bold, strong colours
   string vb=Money(bal), ve=Money(eq), vp=MoneyS(eq-bal);
   color pc=(eq-bal>=0)?C'0,130,50':C'200,30,30';
   if(lcT[36]!=vb){ lcT[36]=vb; ObjectSetString(panelChart,P+"TW_FBV",OBJPROP_TEXT,vb); }
   if(lcT[37]!=ve){ lcT[37]=ve; ObjectSetString(panelChart,P+"TW_FEV",OBJPROP_TEXT,ve); }
   if(lcT[38]!=vp){ lcT[38]=vp; ObjectSetString(panelChart,P+"TW_FPV",OBJPROP_TEXT,vp); }
   if(lcC[38]!=pc){ lcC[38]=pc; ObjectSetInteger(panelChart,P+"TW_FPV",OBJPROP_COLOR,pc); }
}

void OpenTrades()
{
   trOpen=true;
   BuildTrades();
   RefreshTrades();
   ChartRedraw(panelChart);
}

void CloseTrades()
{
   trOpen=false; trDrag=false; trSize=false;
   ObjectsDeleteAll(panelChart,P+"TW_");
   twCnt=0;
   ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,true);
   ChartRedraw(panelChart);
}