//+------------------------------------------------------------------+
//|                                          CopySlave_MT5.mq5       |
//|         Fast Local Copy Trade - SLAVE (MT4 -> MT5)  v5.00        |
//|         File based | No DLL | Hedging account required           |
//+------------------------------------------------------------------+
#property copyright "Fast Copy Trade System"
#property version   "5.00"
#property description "SLAVE EA - fast local copy from MT4 Master (file, no DLL)"
#property description "Hedging account + AutoTrading required. Attach to ONE chart."

input group "============== FILE & CONNECTION =============="
input string   InpFileName        = "CopyTrade_MT4_to_MT5.csv";   // Shared file name (same as Master)
input long     InpMasterAccount   = 0;                            // Master account (0 = any) - SET on real
input int      InpStaleMs         = 3000;                         // Master lost if no heartbeat for (ms)

input group "============== SYMBOL MAPPING =============="
input string   InpReplaceFrom     = "";                           // Replace this in symbol
input string   InpReplaceTo       = "";                           // With this
input string   InpSymbolPrefix    = "";                           // Then PREFIX
input string   InpSymbolSuffix    = "+";                          // Then SUFFIX (your broker: +)
input string   InpPreloadSymbols  = "";                           // Preload (master names, comma sep) e.g. EURUSD,XAUUSD

input group "============== LOT SETTINGS =============="
input double   InpLotMultiplier   = 1.0;                          // Lot multiplier
input double   InpFixedLot        = 0.0;                          // Fixed lot (0 = use multiplier)
input double   InpMaxLot          = 50.0;                         // Max lot (0 = off)
input double   InpMinLot          = 0.01;                         // Min lot (0 = off)

input group "============== TRADE SETTINGS =============="
input int      InpSlippage        = 50;                           // Slippage (points)
input int      InpMagicNumber     = 20241014;                     // Magic for copied trades
input bool     InpReverseTrade    = false;                        // Reverse Buy/Sell (SL<->TP swapped)
input bool     InpCopySL          = true;                         // Copy SL (also follows trailing)
input bool     InpCopyTP          = true;                         // Copy TP
input bool     InpOnlyNewTrades   = false;                        // Ignore trades already open at EA start
input int      InpMaxOpenAgeSec   = 0;                            // Skip trades older than N sec (0 = off)
input bool     InpAsyncMode       = true;                         // Async orders (fastest)
input int      InpPendingMs       = 3000;                         // Async: wait before re-sending (ms)

input group "============== ACCOUNT PROTECTION =============="
input int      InpMaxPositions    = 0;                            // Max copied positions (0 = off)
input double   InpMinMarginLevel  = 0.0;                          // Min margin level % after open (0 = off)
input int      InpMaxRetries      = 6;                            // Max open retries per trade
input int      InpHistoryDays     = 14;                           // History scan to avoid re-opening (days)

input group "============== SPEED =============="
input int      InpTimerMs         = 1;                            // Timer ms (1 = fastest)
input int      InpFullSyncMs      = 250;                          // Periodic full re-check (ms)

input group "============== PANEL / LOG =============="
input bool     InpShowPanel       = true;                         // Show panel
input int      InpPanelMs         = 500;                          // Panel refresh ms
input bool     InpShowLogs        = true;                         // Log copies

#define P        "CTS5_"
#define CMT      "CT#"
#define K_OPEN   1
#define K_MOD    2
#define K_CLOSE  3
#define K_WARN   9

struct MTrade
{
   ulong    ticket;
   ulong    parent;
   string   symbol;
   int      type;
   double   lots;
   double   sl;
   double   tp;
   datetime openTime;
};

struct SPos
{
   ulong    ticket;
   ulong    ref;
   double   vol;
   double   sl;
   double   tp;
   string   sym;
   int      ptype;
};

struct RState
{
   int      kind;
   ulong    key;
   uint     nextMs;
   int      fails;
   bool     dead;
};

struct SymC
{
   string   name;
   int      digits;
   double   point;
   double   tick;
   double   vmin;
   double   vmax;
   double   vstep;
   int      vdig;
   int      fillOpen;
   int      fillClose;
};

struct AliasT
{
   ulong    o;
   ulong    n;
};

MTrade   g_list[];
int      g_mCount = 0;
SPos     g_sp[];
int      g_spN = 0;
RState   g_rs[];
SymC     g_sc[];
AliasT   g_al[];
ulong    g_done[];

ulong    g_lastVer      = 0;
bool     g_haveList     = false;
bool     g_verChanged   = false;
bool     g_baselineDone = false;
bool     g_mReady       = false;
long     g_masterAcc    = 0;
datetime g_mst          = 0;
uint     g_changeTick   = 0;
uint     g_lastGoodMs   = 0;
bool     g_everGood     = false;
bool     g_connected    = false;
int      g_lat          = -1;
double   g_latSum       = 0;
int      g_latN         = 0;
int      g_latMax       = 0;
ulong    g_copied       = 0;
string   g_lastError    = "";
bool     g_tradeBlocked = false;
uint     g_lastFullMs   = 0;
uint     g_lastSyncMs   = 0;
bool     g_needSync     = false;
uint     g_lastPanel    = 0;

//+------------------------------------------------------------------+
int OnInit()
{
   if(AccountInfoInteger(ACCOUNT_MARGIN_MODE) != ACCOUNT_MARGIN_MODE_RETAIL_HEDGING)
   {
      Print("FATAL: this EA needs a HEDGING account (netting would merge copied trades).");
      return(INIT_FAILED);
   }
   if(InpLotMultiplier <= 0 && InpFixedLot <= 0)
   {
      Print("FATAL: lot multiplier / fixed lot invalid");
      return(INIT_PARAMETERS_INCORRECT);
   }
   if(!EventSetMillisecondTimer(MathMax(1, InpTimerMs)))
   {
      Print("FATAL timer: ", GetLastError());
      return(INIT_FAILED);
   }

   LoadHistoryDone();
   PreloadSymbols();
   if(InpShowPanel) CreatePanel();

   Print("======================================================");
   Print("CopySlave_MT5 v5.00 (File, comment-mapped, ", (InpAsyncMode ? "ASYNC" : "SYNC"), ")");
   Print("File   : Common\\Files\\", InpFileName);
   Print("Suffix : [", InpSymbolSuffix, "]  Magic: ", InpMagicNumber);
   Print("Timer  : ", MathMax(1, InpTimerMs), " ms   done-set from history: ", ArraySize(g_done));
   Print("======================================================");
   return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason)
{
   EventKillTimer();
   ObjectsDeleteAll(0, P);
   Print("Slave stopped | Copied: ", g_copied);
}

void OnTimer()
{
   Poll();
   if(InpShowPanel) UpdatePanel();
}

//+------------------------------------------------------------------+
//| Failures of async requests + detection of executed entries       |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
{
   if(trans.type == TRADE_TRANSACTION_DEAL_ADD)
   {
      if(!HistoryDealSelect(trans.deal)) return;
      if(HistoryDealGetInteger(trans.deal, DEAL_MAGIC) != InpMagicNumber) return;
      if(HistoryDealGetInteger(trans.deal, DEAL_ENTRY) != DEAL_ENTRY_IN) return;
      ulong ref = ParseRef(HistoryDealGetString(trans.deal, DEAL_COMMENT));
      if(ref > 0)
      {
         AddDone(ref);
         RClear(K_OPEN, ref);
         g_copied++;
         g_needSync = true;
      }
      return;
   }

   if(!InpAsyncMode) return;
   if(trans.type != TRADE_TRANSACTION_REQUEST) return;
   if(request.magic != (ulong)InpMagicNumber) return;

   uint rc = result.retcode;
   if(RcOK(rc)) return;

   uint now = GetTickCount();
   if(request.action == TRADE_ACTION_DEAL && request.position == 0)
   {
      ulong ref = ParseRef(request.comment);
      if(ref > 0)
      {
         if(rc == TRADE_RETCODE_INVALID_FILL) RotateFill(request.symbol);
         RFail(K_OPEN, ref, rc, now);
         Print("ASYNC OPEN FAIL [", request.symbol, "] #", ref, " rc=", rc, " ", RcText(rc));
         g_lastError = RcText(rc);
         g_needSync = true;
      }
   }
   else if(request.action == TRADE_ACTION_DEAL)
   {
      if(rc == TRADE_RETCODE_POSITION_CLOSED) return;
      if(rc == TRADE_RETCODE_INVALID_FILL) RotateFill(request.symbol);
      RFail(K_CLOSE, request.position, rc, now);
      Print("ASYNC CLOSE FAIL #", request.position, " rc=", rc, " ", RcText(rc));
      g_lastError = RcText(rc);
   }
   else if(request.action == TRADE_ACTION_SLTP)
   {
      if(rc == TRADE_RETCODE_NO_CHANGES) return;
      RFail(K_MOD, request.position, rc, now);
   }
}

//+------------------------------------------------------------------+
//| Helpers                                                          |
//+------------------------------------------------------------------+
void Lg(string s) { if(InpShowLogs) Print(s); }

bool RcOK(uint rc)
{
   return (rc == TRADE_RETCODE_DONE || rc == TRADE_RETCODE_DONE_PARTIAL || rc == TRADE_RETCODE_PLACED);
}

string RcText(uint rc)
{
   switch(rc)
   {
      case TRADE_RETCODE_REQUOTE:            return "Requote";
      case TRADE_RETCODE_REJECT:             return "Rejected";
      case TRADE_RETCODE_TIMEOUT:            return "Timeout";
      case TRADE_RETCODE_INVALID_VOLUME:     return "Invalid volume";
      case TRADE_RETCODE_INVALID_PRICE:      return "Invalid price";
      case TRADE_RETCODE_INVALID_STOPS:      return "Invalid stops";
      case TRADE_RETCODE_TRADE_DISABLED:     return "Trade disabled";
      case TRADE_RETCODE_MARKET_CLOSED:      return "Market closed";
      case TRADE_RETCODE_NO_MONEY:           return "No money";
      case TRADE_RETCODE_PRICE_CHANGED:      return "Price changed";
      case TRADE_RETCODE_PRICE_OFF:          return "No quotes";
      case TRADE_RETCODE_TOO_MANY_REQUESTS:  return "Too many requests";
      case TRADE_RETCODE_CONNECTION:         return "No connection";
      case TRADE_RETCODE_INVALID_FILL:       return "Invalid fill mode";
      case TRADE_RETCODE_LIMIT_VOLUME:       return "Volume limit";
      case TRADE_RETCODE_LIMIT_POSITIONS:    return "Positions limit";
      case TRADE_RETCODE_HEDGE_PROHIBITED:   return "Hedge prohibited";
      case TRADE_RETCODE_FIFO_CLOSE:         return "FIFO rule";
      case TRADE_RETCODE_CLIENT_DISABLES_AT: return "AutoTrading off (client)";
      case TRADE_RETCODE_SERVER_DISABLES_AT: return "AutoTrading off (server)";
   }
   return "retcode " + IntegerToString((long)rc);
}

string MapSymbol(string src)
{
   string s = src;
   if(StringLen(InpReplaceFrom) > 0)
      StringReplace(s, InpReplaceFrom, InpReplaceTo);
   return InpSymbolPrefix + s + InpSymbolSuffix;
}

ulong ParseRef(const string c)
{
   if(StringFind(c, CMT) != 0) return 0;
   return (ulong)StringToInteger(StringSubstr(c, StringLen(CMT)));
}

bool TradingAllowed()
{
   if(!TerminalInfoInteger(TERMINAL_CONNECTED))    return false;
   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED)) return false;
   if(!MQLInfoInteger(MQL_TRADE_ALLOWED))           return false;
   if(!AccountInfoInteger(ACCOUNT_TRADE_ALLOWED))   return false;
   if(!AccountInfoInteger(ACCOUNT_TRADE_EXPERT))    return false;
   return true;
}

bool SendReq(MqlTradeRequest &rq, MqlTradeResult &rs)
{
   if(InpAsyncMode) return OrderSendAsync(rq, rs);
   return OrderSend(rq, rs);
}

//--- alias table (master partial-close chain: old ticket -> new ticket)
ulong AliasGet(ulong o)
{
   for(int i = ArraySize(g_al) - 1; i >= 0; i--)
      if(g_al[i].o == o) return g_al[i].n;
   return 0;
}

void AliasSet(ulong o, ulong n)
{
   int k = ArraySize(g_al);
   for(int i = 0; i < k; i++)
      if(g_al[i].o == o) { g_al[i].n = n; return; }
   if(k >= 256)
   {
      for(int j = 1; j < k; j++) g_al[j-1] = g_al[j];
      k--;
   }
   else
      ArrayResize(g_al, k + 1);
   g_al[k].o = o;
   g_al[k].n = n;
}

//--- "done" set: master tickets already copied / deliberately skipped
bool DoneHas(ulong t)
{
   for(int i = ArraySize(g_done) - 1; i >= 0; i--)
      if(g_done[i] == t) return true;
   return false;
}

void AddDone(ulong t)
{
   if(t == 0 || DoneHas(t)) return;
   int n = ArraySize(g_done);
   ArrayResize(g_done, n + 1);
   g_done[n] = t;
}

bool IsDone(const MTrade &t)
{
   if(DoneHas(t.ticket)) return true;
   if(t.parent > 0 && DoneHas(t.parent)) { AddDone(t.ticket); return true; }
   return false;
}

void PruneDone()
{
   int n = ArraySize(g_done), k = 0;
   for(int i = 0; i < n; i++)
      if(FindMasterIdx(g_done[i]) >= 0) g_done[k++] = g_done[i];
   ArrayResize(g_done, k);
}

//--- retry / pending state
int RFind(int kind, ulong key)
{
   for(int i = ArraySize(g_rs) - 1; i >= 0; i--)
      if(g_rs[i].kind == kind && g_rs[i].key == key) return i;
   return -1;
}

int RGet(int kind, ulong key, uint now)
{
   int i = RFind(kind, key);
   if(i >= 0) return i;
   i = ArraySize(g_rs);
   ArrayResize(g_rs, i + 1);
   g_rs[i].kind   = kind;
   g_rs[i].key    = key;
   g_rs[i].nextMs = now;
   g_rs[i].fails  = 0;
   g_rs[i].dead   = false;
   return i;
}

bool RReady(int kind, ulong key, uint now)
{
   int i = RFind(kind, key);
   if(i < 0) return true;
   if(g_rs[i].dead) return false;
   return ((int)(now - g_rs[i].nextMs) >= 0);
}

void RHold(int kind, ulong key, uint now, uint ms)
{
   int i = RGet(kind, key, now);
   g_rs[i].nextMs = now + ms;
}

void RSuccess(int kind, ulong key, uint now, uint holdMs)
{
   int i = RGet(kind, key, now);
   g_rs[i].fails  = 0;
   g_rs[i].dead   = false;
   g_rs[i].nextMs = now + holdMs;
}

void RClear(int kind, ulong key)
{
   int i = RFind(kind, key);
   if(i < 0) return;
   int n = ArraySize(g_rs);
   g_rs[i] = g_rs[n - 1];
   ArrayResize(g_rs, n - 1);
}

uint RetryDelay(uint rc, int fails, int kind)
{
   uint d;
   switch(rc)
   {
      case TRADE_RETCODE_REQUOTE:
      case TRADE_RETCODE_PRICE_CHANGED:
      case TRADE_RETCODE_PRICE_OFF:
      case TRADE_RETCODE_REJECT:
      case TRADE_RETCODE_INVALID_FILL:
         d = (uint)MathMin(20 * fails, 300);
         break;
      case TRADE_RETCODE_TIMEOUT:
      case TRADE_RETCODE_CONNECTION:
         d = 1500;
         break;
      case TRADE_RETCODE_TOO_MANY_REQUESTS:
         d = 1000;
         break;
      default:
         d = (uint)MathMin(1000 * fails, 10000);
         break;
   }
   if(kind != K_OPEN && d > 2000) d = 2000;
   return d;
}

void RFail(int kind, ulong key, uint rc, uint now)
{
   int i = RGet(kind, key, now);
   g_rs[i].fails++;
   g_rs[i].nextMs = now + RetryDelay(rc, g_rs[i].fails, kind);
   if(kind == K_OPEN && g_rs[i].fails >= InpMaxRetries)
   {
      g_rs[i].dead = true;
      Print("GIVE UP opening master #", key, " after ", g_rs[i].fails, " tries: ", RcText(rc));
   }
}

bool SlaveHas(ulong tk)
{
   for(int i = 0; i < g_spN; i++)
      if(g_sp[i].ticket == tk) return true;
   return false;
}

void PruneRS(uint now)
{
   for(int i = ArraySize(g_rs) - 1; i >= 0; i--)
   {
      bool rm = false;
      int  kd = g_rs[i].kind;
      ulong key = g_rs[i].key;
      bool expired = ((int)(now - g_rs[i].nextMs) >= 0);

      if(kd == K_OPEN)
      {
         if(FindMasterIdx(key) < 0) rm = true;
         else if(g_rs[i].fails == 0 && !g_rs[i].dead && expired) rm = true;
      }
      else if(kd == K_WARN)
      {
         if(!SlaveHas(key)) rm = true;
      }
      else
      {
         if(!SlaveHas(key)) rm = true;
         else if(g_rs[i].fails == 0 && expired) rm = true;
      }
      if(rm)
      {
         int n = ArraySize(g_rs);
         g_rs[i] = g_rs[n - 1];
         ArrayResize(g_rs, n - 1);
      }
   }
}

bool HasActiveRS()
{
   for(int i = ArraySize(g_rs) - 1; i >= 0; i--)
      if(!g_rs[i].dead) return true;
   return false;
}

//--- symbol cache
int VolDigits(double step)
{
   int d = 0;
   double s = step;
   while(d < 8 && MathAbs(s - MathRound(s)) > 1e-9) { s *= 10.0; d++; }
   return d;
}

void DetectFills(int i)
{
   long fm = SymbolInfoInteger(g_sc[i].name, SYMBOL_FILLING_MODE);
   if((fm & SYMBOL_FILLING_FOK) != 0)      g_sc[i].fillOpen = ORDER_FILLING_FOK;
   else if((fm & SYMBOL_FILLING_IOC) != 0) g_sc[i].fillOpen = ORDER_FILLING_IOC;
   else                                    g_sc[i].fillOpen = ORDER_FILLING_RETURN;

   if((fm & SYMBOL_FILLING_IOC) != 0)      g_sc[i].fillClose = ORDER_FILLING_IOC;
   else if((fm & SYMBOL_FILLING_FOK) != 0) g_sc[i].fillClose = ORDER_FILLING_FOK;
   else                                    g_sc[i].fillClose = ORDER_FILLING_RETURN;
}

int NextFill(int f)
{
   if(f == ORDER_FILLING_FOK) return ORDER_FILLING_IOC;
   if(f == ORDER_FILLING_IOC) return ORDER_FILLING_RETURN;
   return ORDER_FILLING_FOK;
}

void RotateFill(string sym)
{
   for(int i = 0; i < ArraySize(g_sc); i++)
      if(g_sc[i].name == sym)
      {
         g_sc[i].fillOpen  = NextFill(g_sc[i].fillOpen);
         g_sc[i].fillClose = NextFill(g_sc[i].fillClose);
         return;
      }
}

int SymIdx(const string name)
{
   for(int i = ArraySize(g_sc) - 1; i >= 0; i--)
      if(g_sc[i].name == name) return i;

   if(!SymbolSelect(name, true)) return -1;

   // first use: give the terminal a moment to receive the first quote
   for(int w = 0; w < 60; w++)
   {
      MqlTick x;
      if(SymbolInfoTick(name, x) && x.bid > 0) break;
      Sleep(5);
   }

   double pt = SymbolInfoDouble(name, SYMBOL_POINT);
   if(pt <= 0) return -1;

   int n = ArraySize(g_sc);
   ArrayResize(g_sc, n + 1);
   g_sc[n].name   = name;
   g_sc[n].digits = (int)SymbolInfoInteger(name, SYMBOL_DIGITS);
   g_sc[n].point  = pt;
   double ts = SymbolInfoDouble(name, SYMBOL_TRADE_TICK_SIZE);
   g_sc[n].tick   = (ts > 0) ? ts : pt;
   g_sc[n].vmin   = SymbolInfoDouble(name, SYMBOL_VOLUME_MIN);
   g_sc[n].vmax   = SymbolInfoDouble(name, SYMBOL_VOLUME_MAX);
   g_sc[n].vstep  = SymbolInfoDouble(name, SYMBOL_VOLUME_STEP);
   if(g_sc[n].vstep <= 0) g_sc[n].vstep = 0.01;
   if(g_sc[n].vmin  <= 0) g_sc[n].vmin  = g_sc[n].vstep;
   if(g_sc[n].vmax  <= 0) g_sc[n].vmax  = 1000.0;
   g_sc[n].vdig   = VolDigits(g_sc[n].vstep);
   DetectFills(n);
   return n;
}

void PreloadSymbols()
{
   if(StringLen(InpPreloadSymbols) == 0) return;
   string arr[];
   int c = StringSplit(InpPreloadSymbols, ',', arr);
   for(int i = 0; i < c; i++)
   {
      string s = arr[i];
      StringTrimLeft(s);
      StringTrimRight(s);
      if(StringLen(s) == 0) continue;
      string m = MapSymbol(s);
      if(SymIdx(m) < 0) Print("Preload: symbol not found [", m, "]");
   }
}

double Snap(double p, int si)
{
   if(p <= 0) return 0;
   double ts = g_sc[si].tick;
   if(ts > 0) p = MathRound(p / ts) * ts;
   return NormalizeDouble(p, g_sc[si].digits);
}

double CalcLots(double mLots, int si)
{
   double lots = (InpFixedLot > 0) ? InpFixedLot : mLots * InpLotMultiplier;
   if(InpMinLot > 0 && lots < InpMinLot) lots = InpMinLot;
   if(InpMaxLot > 0 && lots > InpMaxLot) lots = InpMaxLot;
   double step = g_sc[si].vstep;
   lots = MathFloor(lots / step + 1e-9) * step;
   if(lots < g_sc[si].vmin) lots = g_sc[si].vmin;
   if(lots > g_sc[si].vmax) lots = g_sc[si].vmax;
   return NormalizeDouble(lots, g_sc[si].vdig);
}

void LoadHistoryDone()
{
   if(InpHistoryDays <= 0) return;
   datetime to   = TimeCurrent() + 86400;
   datetime from = to - (datetime)(InpHistoryDays * 86400);
   if(!HistorySelect(from, to)) return;
   int n = HistoryDealsTotal();
   for(int i = 0; i < n; i++)
   {
      ulong d = HistoryDealGetTicket(i);
      if(d == 0) continue;
      if(HistoryDealGetInteger(d, DEAL_MAGIC) != InpMagicNumber) continue;
      if(HistoryDealGetInteger(d, DEAL_ENTRY) != DEAL_ENTRY_IN) continue;
      ulong ref = ParseRef(HistoryDealGetString(d, DEAL_COMMENT));
      if(ref > 0) AddDone(ref);
   }
}

//+------------------------------------------------------------------+
//| Snapshot reading (validated: header + count + end marker)        |
//+------------------------------------------------------------------+
int FindMasterIdx(ulong tk)
{
   for(int i = 0; i < g_mCount; i++)
      if(g_list[i].ticket == tk) return i;
   return -1;
}

int FindChildIdx(ulong parent)
{
   for(int i = 0; i < g_mCount; i++)
      if(g_list[i].parent == parent) return i;
   return -1;
}

int ResolveIdx(ulong ref)
{
   ulong cur = ref;
   for(int hop = 0; hop < 12; hop++)
   {
      int idx = FindMasterIdx(cur);
      if(idx >= 0)
      {
         if(cur != ref) AliasSet(ref, cur);
         return idx;
      }
      ulong a = AliasGet(cur);
      if(a > 0 && a != cur) { cur = a; continue; }
      int c = FindChildIdx(cur);
      if(c >= 0)
      {
         AliasSet(cur, g_list[c].ticket);
         cur = g_list[c].ticket;
         continue;
      }
      return -1;
   }
   return -1;
}

bool ReadSnapshot(uint now)
{
   g_verChanged = false;

   int h = FileOpen(InpFileName, FILE_READ|FILE_TXT|FILE_ANSI|FILE_COMMON|FILE_SHARE_READ|FILE_SHARE_WRITE);
   if(h == INVALID_HANDLE) return false;

   string hp[];
   int hn = StringSplit(FileReadString(h), ',', hp);
   if(hn < 9 || hp[0] != "H" || hp[1] != "5") { FileClose(h); return false; }

   long acc = StringToInteger(hp[2]);
   if(InpMasterAccount != 0 && acc != InpMasterAccount)
   {
      FileClose(h);
      g_lastError = "Master account mismatch";
      return false;
   }

   ulong    seq   = (ulong)StringToInteger(hp[3]);
   ulong    ver   = (ulong)StringToInteger(hp[4]);
   uint     mTick = (uint)StringToInteger(hp[5]);
   int      hcnt  = (int)StringToInteger(hp[6]);
   bool     mrdy  = (hp[7] == "1");
   datetime mst   = (datetime)StringToInteger(hp[8]);

   uint d   = now - mTick;
   int  lat = (d <= 0x7FFFFFFF) ? (int)d : 0;
   g_lat = lat;
   if(lat > InpStaleMs) { FileClose(h); return false; }          // stale file = master gone

   if(hcnt < 0 || hcnt > 5000) { FileClose(h); return false; }

   g_masterAcc  = acc;
   g_mReady     = mrdy;
   g_mst        = mst;
   g_lastGoodMs = now;
   g_everGood   = true;

   if(g_haveList && ver == g_lastVer) { FileClose(h); return true; }   // nothing changed: cheap exit

   MTrade tmp[];
   ArrayResize(tmp, hcnt);
   int  n = 0;
   bool tailOK = false;

   while(!FileIsEnding(h))
   {
      string line = FileReadString(h);
      if(StringLen(line) < 3) continue;
      string p[];
      int c = StringSplit(line, ',', p);
      if(c < 1) continue;

      if(p[0] == "T")
      {
         if(c < 11 || n >= hcnt) { n = -1; break; }
         tmp[n].ticket   = (ulong)StringToInteger(p[1]);
         tmp[n].symbol   = MapSymbol(p[2]);
         tmp[n].type     = (int)StringToInteger(p[3]);
         tmp[n].lots     = StringToDouble(p[4]);
         tmp[n].sl       = StringToDouble(p[6]);
         tmp[n].tp       = StringToDouble(p[7]);
         tmp[n].openTime = (datetime)StringToInteger(p[9]);
         tmp[n].parent   = (ulong)StringToInteger(p[10]);
         n++;
      }
      else if(p[0] == "E")
      {
         tailOK = (c >= 3 && StringToInteger(p[1]) == (long)seq && StringToInteger(p[2]) == hcnt);
         break;
      }
   }
   FileClose(h);

   if(n != hcnt || !tailOK) return false;                         // torn / partial read -> ignore

   ArrayResize(g_list, n);
   for(int i = 0; i < n; i++) g_list[i] = tmp[i];
   g_mCount     = n;
   g_lastVer    = ver;
   g_haveList   = true;
   g_verChanged = true;
   g_changeTick = mTick;

   if(g_baselineDone)
   {
      g_latSum += lat;
      g_latN++;
      if(lat > g_latMax) g_latMax = lat;
   }
   return true;
}

//+------------------------------------------------------------------+
void Poll()
{
   uint now = GetTickCount();
   bool ok  = ReadSnapshot(now);

   g_connected = g_everGood && ((int)(now - g_lastGoodMs) < InpStaleMs);
   if(!ok) return;
   if(!g_mReady) return;

   bool due = g_verChanged
           || (g_needSync && (int)(now - g_lastSyncMs) >= 5)
           || ((int)(now - g_lastFullMs) >= MathMax(50, InpFullSyncMs));
   if(!due) return;

   Sync(now);
   g_lastFullMs = now;
}

void ScanSlavePositions()
{
   int pt = PositionsTotal();
   ArrayResize(g_sp, pt);
   g_spN = 0;
   for(int i = 0; i < pt; i++)
   {
      ulong tk = PositionGetTicket(i);
      if(tk == 0) continue;
      if(PositionGetInteger(POSITION_MAGIC) != InpMagicNumber) continue;
      int k = g_spN++;
      g_sp[k].ticket = tk;
      g_sp[k].ref    = ParseRef(PositionGetString(POSITION_COMMENT));
      g_sp[k].vol    = PositionGetDouble(POSITION_VOLUME);
      g_sp[k].sl     = PositionGetDouble(POSITION_SL);
      g_sp[k].tp     = PositionGetDouble(POSITION_TP);
      g_sp[k].sym    = PositionGetString(POSITION_SYMBOL);
      g_sp[k].ptype  = (int)PositionGetInteger(POSITION_TYPE);
   }
}

//+------------------------------------------------------------------+
void Sync(uint now)
{
   g_lastSyncMs = now;

   if(!TradingAllowed()) { g_tradeBlocked = true; return; }
   g_tradeBlocked = false;

   if(!g_baselineDone)
   {
      if(InpOnlyNewTrades)
         for(int i = 0; i < g_mCount; i++) AddDone(g_list[i].ticket);
      g_baselineDone = true;
   }

   ScanSlavePositions();

   bool covered[];
   ArrayResize(covered, g_mCount);
   ArrayInitialize(covered, false);

   //--- 1) existing slave positions: close / partial / stops
   for(int k = 0; k < g_spN; k++)
   {
      if(g_sp[k].ref == 0)
      {
         if(RFind(K_WARN, g_sp[k].ticket) < 0)
         {
            int w = RGet(K_WARN, g_sp[k].ticket, now);
            g_rs[w].dead = true;
            Print("WARNING: position #", g_sp[k].ticket, " has our magic but no CT# comment -> ignored");
         }
         continue;
      }

      AddDone(g_sp[k].ref);
      int mi = ResolveIdx(g_sp[k].ref);
      if(mi < 0)
      {
         if(RReady(K_CLOSE, g_sp[k].ticket, now))
            CloseVol(g_sp[k].ticket, g_sp[k].sym, g_sp[k].ptype, g_sp[k].vol, now, false);
         continue;
      }

      covered[mi] = true;
      AddDone(g_list[mi].ticket);
      if(g_list[mi].ticket != g_sp[k].ref) PartialSync(k, mi, now);
      SyncStops(k, mi, now);
   }

   //--- 2) new master trades
   int openCnt = g_spN;
   for(int i = 0; i < g_mCount; i++)
   {
      if(covered[i]) continue;
      if(IsDone(g_list[i])) continue;
      if(!RReady(K_OPEN, g_list[i].ticket, now)) continue;

      if(InpMaxOpenAgeSec > 0 && g_mst > 0 && g_list[i].openTime > 0 &&
         (long)(g_mst - g_list[i].openTime) > InpMaxOpenAgeSec)
      {
         AddDone(g_list[i].ticket);
         Lg("SKIP old master trade #" + IntegerToString((long)g_list[i].ticket));
         continue;
      }
      if(InpMaxPositions > 0 && openCnt >= InpMaxPositions) continue;
      if(OpenTrade(g_list[i], now)) openCnt++;
   }

   //--- 3) housekeeping
   if(g_verChanged) PruneDone();
   PruneRS(now);
   g_needSync = HasActiveRS();
}

//+------------------------------------------------------------------+
void SyncStops(int k, int mi, uint now)
{
   if(!InpCopySL && !InpCopyTP) return;
   if(!RReady(K_MOD, g_sp[k].ticket, now)) return;

   string sym = g_sp[k].sym;
   int si = SymIdx(sym);
   if(si < 0) return;

   double wsl = InpReverseTrade ? g_list[mi].tp : g_list[mi].sl;
   double wtp = InpReverseTrade ? g_list[mi].sl : g_list[mi].tp;
   double curSL = g_sp[k].sl, curTP = g_sp[k].tp;
   double nsl = InpCopySL ? Snap(wsl, si) : curSL;
   double ntp = InpCopyTP ? Snap(wtp, si) : curTP;
   double half = g_sc[si].tick * 0.5;

   bool dSL = (MathAbs(nsl - curSL) > half);
   bool dTP = (MathAbs(ntp - curTP) > half);
   if(!dSL && !dTP) return;

   MqlTick tk;
   if(!SymbolInfoTick(sym, tk)) return;
   double lvl = (double)SymbolInfoInteger(sym, SYMBOL_TRADE_STOPS_LEVEL) * g_sc[si].point;
   bool buy = (g_sp[k].ptype == POSITION_TYPE_BUY);

   if(dSL && nsl > 0)
   {
      bool okS = buy ? (nsl < tk.bid - lvl) : (nsl > tk.ask + lvl);
      if(!okS) { nsl = curSL; dSL = false; }
   }
   if(dTP && ntp > 0)
   {
      bool okT = buy ? (ntp > tk.bid + lvl) : (ntp < tk.ask - lvl);
      if(!okT) { ntp = curTP; dTP = false; }
   }
   if(!dSL && !dTP) return;                       // will be re-checked on next full sync

   MqlTradeRequest rq;
   MqlTradeResult  rs;
   ZeroMemory(rq);
   ZeroMemory(rs);
   rq.action   = TRADE_ACTION_SLTP;
   rq.position = g_sp[k].ticket;
   rq.symbol   = sym;
   rq.sl       = nsl;
   rq.tp       = ntp;
   rq.magic    = InpMagicNumber;

   bool sent = SendReq(rq, rs);
   if(sent && (RcOK(rs.retcode) || rs.retcode == TRADE_RETCODE_NO_CHANGES))
      RSuccess(K_MOD, g_sp[k].ticket, now, InpAsyncMode ? 120 : 30);
   else
   {
      uint rc = (rs.retcode == 0) ? TRADE_RETCODE_REJECT : rs.retcode;
      RFail(K_MOD, g_sp[k].ticket, rc, now);
   }
}

void PartialSync(int k, int mi, uint now)
{
   if(InpFixedLot > 0) return;
   if(!RReady(K_CLOSE, g_sp[k].ticket, now)) return;
   int si = SymIdx(g_sp[k].sym);
   if(si < 0) return;

   double target = CalcLots(g_list[mi].lots, si);
   double step   = g_sc[si].vstep;
   double diff   = g_sp[k].vol - target;
   if(diff < step * 0.999) return;
   diff = MathFloor(diff / step + 1e-9) * step;
   if(diff < g_sc[si].vmin) return;
   if(g_sp[k].vol - diff < g_sc[si].vmin - 1e-9) return;

   CloseVol(g_sp[k].ticket, g_sp[k].sym, g_sp[k].ptype, NormalizeDouble(diff, g_sc[si].vdig), now, true);
}

//+------------------------------------------------------------------+
void CloseVol(ulong ticket, string sym, int ptype, double vol, uint now, bool partial)
{
   int si = SymIdx(sym);
   if(si < 0) return;

   MqlTick tk;
   if(!SymbolInfoTick(sym, tk) || tk.bid <= 0 || tk.ask <= 0)
   {
      RHold(K_CLOSE, ticket, now, 20);
      return;
   }

   MqlTradeRequest rq;
   MqlTradeResult  rs;
   ZeroMemory(rq);
   ZeroMemory(rs);
   bool buy = (ptype == POSITION_TYPE_BUY);
   rq.action       = TRADE_ACTION_DEAL;
   rq.position     = ticket;
   rq.symbol       = sym;
   rq.volume       = vol;
   rq.type         = buy ? ORDER_TYPE_SELL : ORDER_TYPE_BUY;
   rq.price        = buy ? tk.bid : tk.ask;
   rq.deviation    = InpSlippage;
   rq.magic        = InpMagicNumber;
   rq.type_filling = (ENUM_ORDER_TYPE_FILLING)g_sc[si].fillClose;
   rq.comment      = partial ? "CT-part" : "CT-close";

   uint t0 = GetTickCount();
   int  detect = (int)(t0 - g_changeTick);
   bool sent = SendReq(rq, rs);
   uint t1 = GetTickCount();

   if(sent && (RcOK(rs.retcode) || rs.retcode == TRADE_RETCODE_POSITION_CLOSED))
   {
      RSuccess(K_CLOSE, ticket, now, InpAsyncMode ? 400 : 150);
      Lg((partial ? "PARTIAL " : "CLOSE ") + sym + " #" + IntegerToString((long)ticket) +
         " vol=" + DoubleToString(vol, g_sc[si].vdig) +
         " master->send=" + IntegerToString(detect) + "ms call=" + IntegerToString((int)(t1 - t0)) + "ms");
      return;
   }

   uint rc = (rs.retcode == 0) ? TRADE_RETCODE_REJECT : rs.retcode;
   if(rc == TRADE_RETCODE_INVALID_FILL) RotateFill(sym);
   RFail(K_CLOSE, ticket, rc, now);
   g_lastError = RcText(rc);
   Print("CLOSE FAIL [", sym, "] #", ticket, " ", RcText(rc));
}

//+------------------------------------------------------------------+
bool OpenTrade(const MTrade &t, uint now)
{
   string sym = t.symbol;
   int si = SymIdx(sym);
   if(si < 0)
   {
      g_lastError = "Not found: " + sym;
      RFail(K_OPEN, t.ticket, 0, now);
      Print("Symbol not found: [", sym, "] - check symbol mapping");
      return false;
   }

   bool wantBuy = ((t.type == 0) != InpReverseTrade);

   long tm = SymbolInfoInteger(sym, SYMBOL_TRADE_MODE);
   if(tm == SYMBOL_TRADE_MODE_DISABLED || tm == SYMBOL_TRADE_MODE_CLOSEONLY ||
      (wantBuy && tm == SYMBOL_TRADE_MODE_SHORTONLY) || (!wantBuy && tm == SYMBOL_TRADE_MODE_LONGONLY))
   {
      g_lastError = "Trade mode: " + sym;
      RFail(K_OPEN, t.ticket, TRADE_RETCODE_TRADE_DISABLED, now);
      return false;
   }

   MqlTick tk;
   if(!SymbolInfoTick(sym, tk) || tk.ask <= 0 || tk.bid <= 0)
   {
      RFail(K_OPEN, t.ticket, TRADE_RETCODE_PRICE_OFF, now);
      return false;
   }

   double lots = CalcLots(t.lots, si);
   if(lots <= 0) return false;

   ENUM_ORDER_TYPE otype = wantBuy ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
   double price = wantBuy ? tk.ask : tk.bid;

   double margin = 0;
   if(OrderCalcMargin(otype, sym, lots, price, margin))
   {
      bool bad = (margin > AccountInfoDouble(ACCOUNT_MARGIN_FREE));
      if(!bad && InpMinMarginLevel > 0)
      {
         double used = AccountInfoDouble(ACCOUNT_MARGIN) + margin;
         if(used > 0 && AccountInfoDouble(ACCOUNT_EQUITY) / used * 100.0 < InpMinMarginLevel) bad = true;
      }
      if(bad)
      {
         g_lastError = "Margin too low";
         RFail(K_OPEN, t.ticket, TRADE_RETCODE_NO_MONEY, now);
         Print("OPEN SKIP [", sym, "] margin too low (need ", DoubleToString(margin, 2), ")");
         return false;
      }
   }

   double sl = 0, tp = 0;
   if(InpCopySL || InpCopyTP)
   {
      double msl = InpReverseTrade ? t.tp : t.sl;
      double mtp = InpReverseTrade ? t.sl : t.tp;
      double lvl = (double)SymbolInfoInteger(sym, SYMBOL_TRADE_STOPS_LEVEL) * g_sc[si].point;
      if(InpCopySL && msl > 0)
      {
         double v = Snap(msl, si);
         if(wantBuy ? (v < tk.bid - lvl) : (v > tk.ask + lvl)) sl = v;
      }
      if(InpCopyTP && mtp > 0)
      {
         double v = Snap(mtp, si);
         if(wantBuy ? (v > tk.bid + lvl) : (v < tk.ask - lvl)) tp = v;
      }
   }

   MqlTradeRequest rq;
   MqlTradeResult  rs;
   ZeroMemory(rq);
   ZeroMemory(rs);
   rq.action       = TRADE_ACTION_DEAL;
   rq.symbol       = sym;
   rq.volume       = lots;
   rq.type         = otype;
   rq.price        = price;
   rq.sl           = sl;
   rq.tp           = tp;
   rq.deviation    = InpSlippage;
   rq.magic        = InpMagicNumber;
   rq.comment      = CMT + IntegerToString((long)t.ticket);
   rq.type_filling = (ENUM_ORDER_TYPE_FILLING)g_sc[si].fillOpen;

   uint t0 = GetTickCount();
   int  detect = (int)(t0 - g_changeTick);
   bool sent = SendReq(rq, rs);
   uint t1 = GetTickCount();

   if(sent && RcOK(rs.retcode))
   {
      RSuccess(K_OPEN, t.ticket, now, InpAsyncMode ? (uint)MathMax(500, InpPendingMs) : 500);
      if(!InpAsyncMode) AddDone(t.ticket);
      g_lastError = "";
      Lg("OPEN " + sym + " " + EnumToString(otype) + " lot=" + DoubleToString(lots, g_sc[si].vdig) +
         " #" + IntegerToString((long)t.ticket) +
         " ipc=" + IntegerToString(g_lat) + "ms master->send=" + IntegerToString(detect) +
         "ms call=" + IntegerToString((int)(t1 - t0)) + "ms");
      return true;
   }

   uint rc = (rs.retcode == 0) ? TRADE_RETCODE_REJECT : rs.retcode;
   if(rc == TRADE_RETCODE_INVALID_FILL) RotateFill(sym);
   RFail(K_OPEN, t.ticket, rc, now);
   g_lastError = RcText(rc);
   Print("OPEN FAIL [", sym, "] #", t.ticket, " ", RcText(rc));
   return false;
}

//+------------------------------------------------------------------+
//| Panel                                                            |
//+------------------------------------------------------------------+
void CreatePanel()
{
   ObjectsDeleteAll(0, P);
   ObjectCreate(0, P+"bg", OBJ_RECTANGLE_LABEL, 0, 0, 0);
   ObjectSetInteger(0, P+"bg", OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(0, P+"bg", OBJPROP_XDISTANCE, 8);
   ObjectSetInteger(0, P+"bg", OBJPROP_YDISTANCE, 18);
   ObjectSetInteger(0, P+"bg", OBJPROP_XSIZE, 300);
   ObjectSetInteger(0, P+"bg", OBJPROP_YSIZE, 150);
   ObjectSetInteger(0, P+"bg", OBJPROP_BGCOLOR, C'12,12,18');
   ObjectSetInteger(0, P+"bg", OBJPROP_BORDER_TYPE, BORDER_FLAT);
   ObjectSetInteger(0, P+"bg", OBJPROP_COLOR, clrDodgerBlue);
   ObjectSetInteger(0, P+"bg", OBJPROP_WIDTH, 1);
   ObjectSetInteger(0, P+"bg", OBJPROP_BACK, false);
   ObjectSetInteger(0, P+"bg", OBJPROP_SELECTABLE, false);

   Lbl(P+"t", 16, 26,  "SLAVE v5.00", 10, clrDodgerBlue);
   Lbl(P+"s", 16, 48,  "Status: ...", 9, clrOrange);
   Lbl(P+"a", 16, 66,  "Master: --", 9, clrWhite);
   Lbl(P+"l", 16, 86,  "IPC: -- ms", 9, clrAqua);
   Lbl(P+"m", 16, 106, "M:0  S:0", 9, clrWhite);
   Lbl(P+"c", 16, 124, "Copied: 0", 9, clrSilver);
   Lbl(P+"e", 16, 140, "", 8, clrOrange);
}

void Lbl(string n, int x, int y, string t, int sz, color c)
{
   ObjectCreate(0, n, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, n, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(0, n, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, n, OBJPROP_YDISTANCE, y);
   ObjectSetString(0, n, OBJPROP_TEXT, t);
   ObjectSetString(0, n, OBJPROP_FONT, "Arial");
   ObjectSetInteger(0, n, OBJPROP_FONTSIZE, sz);
   ObjectSetInteger(0, n, OBJPROP_COLOR, c);
   ObjectSetInteger(0, n, OBJPROP_SELECTABLE, false);
}

void UpdatePanel()
{
   uint n = GetTickCount();
   if((int)(n - g_lastPanel) < InpPanelMs) return;
   g_lastPanel = n;

   string st; color sc;
   if(!g_connected)         { st = "Status: MASTER LOST";            sc = clrRed; }
   else if(!g_mReady)       { st = "Status: MASTER WARM-UP (idle)";  sc = clrOrange; }
   else if(g_tradeBlocked)  { st = "Status: AUTOTRADING OFF";        sc = clrRed; }
   else                     { st = "Status: CONNECTED";              sc = clrLime; }
   ObjectSetString (0, P+"s", OBJPROP_TEXT, st);
   ObjectSetInteger(0, P+"s", OBJPROP_COLOR, sc);
   ObjectSetString (0, P+"a", OBJPROP_TEXT, "Master: " + (g_masterAcc > 0 ? IntegerToString(g_masterAcc) : "--"));

   string ls = "IPC: " + (g_lat >= 0 ? IntegerToString(g_lat) : "--") + " ms";
   if(g_latN > 0) ls += "  avg " + DoubleToString(g_latSum / g_latN, 1) + "  max " + IntegerToString(g_latMax);
   ObjectSetString(0, P+"l", OBJPROP_TEXT, ls);

   ObjectSetString(0, P+"m", OBJPROP_TEXT, "M:" + IntegerToString(g_mCount) + "  S:" + IntegerToString(g_spN) +
                   (InpAsyncMode ? "  ASYNC" : "  SYNC"));
   ObjectSetString(0, P+"c", OBJPROP_TEXT, "Copied: " + IntegerToString((long)g_copied));
   ObjectSetString(0, P+"e", OBJPROP_TEXT, g_lastError);
   ChartRedraw(0);
}
//+------------------------------------------------------------------+