//+------------------------------------------------------------------+
//|                                                       VtLive.mqh |
//|                                      Copyright 2026, Allan Niñal |
//|                                  https://www.allanninal.dev/mql5 |
//+------------------------------------------------------------------+
//| MT4 edition of the terminal side of Vitals: account figures,     |
//| open positions (risk at the stops, exposure value) and the order |
//| history turned into the engine's deal list. Read-only: no order  |
//| function is ever called.                                         |
//|   MT4 keeps ORDERS, not deals, so every order becomes an IN deal at its open time and, once      |
//|   closed, an OUT deal at its close time carrying profit, swap    |
//|   and commission. A partial close leaves an order for the closed |
//|   part and opens a new one commented "from #<ticket>": the chain |
//|   is ONE position (the engine's trade), keyed by the first ticket.|
//|   Balance records (type 6) are cash flow, credit (7) is credit.  |
//|   There is no fee in MT4. Prices come from MarketInfo (the       |
//|   SymbolInfo bid/ask is 0 for some symbols in the tester);       |
//|   there is no OrderCalcProfit: risk at a stop = distance / tick  |
//|   size x tick value x lots, with the documented fallback when the|
//|   tester gives MODE_TICKVALUE 0 (gold, crypto).                  |
//+------------------------------------------------------------------+
// SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0 (see LICENSE)
#ifndef VTLIVE_MQH
#define VTLIVE_MQH
#include "VtCore.mqh"
#include "VtExposure.mqh"

#define VT_SO_PERCENT 0                  // AccountStopoutMode(): 0 = percent, 1 = money

//--- the server clock: the last tick's time (MQL4 has no TimeTradeServer); in the tester the simulated time
long VtServerNow() { return((long)TimeCurrent()); }
//--- microsecond counter stand-in (MQL4 has no GetMicrosecondCount): milliseconds x 1000, good enough for the perf log
ulong VtMicros() { return((ulong)GetTickCount()*1000); }

struct VtAcct
  {
   long   login,leverage;
   string name,server,ccy,mode;
   double balance,equity,margin,free,level,so,profit,credit;
   long   so_mode;                       // VT_SO_PERCENT / 1 = money
  };

void VtReadAccount(VtAcct &a)
  {
   a.login=AccountNumber();
   a.leverage=AccountLeverage();
   a.name=AccountName();
   a.server=AccountServer();
   a.ccy=AccountCurrency();
   a.mode="hedging";
   a.balance=AccountBalance();
   a.equity=AccountEquity();
   a.margin=AccountMargin();
   a.free=AccountFreeMargin();
   a.level=(a.margin>0 ? 100.0*a.equity/a.margin : 0.0);
   a.so=AccountStopoutLevel();
   a.so_mode=AccountStopoutMode();
   a.profit=AccountProfit();
   a.credit=AccountCredit();
  }

//--- rate profit currency -> account currency from a cross symbol in the terminal (suffix of the position's symbol
//--- tried first); returns 0 when there is none
double VtCrossRate(const string ccy,const string acct,const string suffix)
  {
   if(ccy==acct)
      return(1.0);
   string a=ccy+acct+suffix,b=acct+ccy+suffix,c=ccy+acct,d=acct+ccy;
   string cand[4];
   cand[0]=a; cand[1]=b; cand[2]=c; cand[3]=d;
   for(int i=0; i<4; i++)
     {
      ResetLastError();
      double bid=MarketInfo(cand[i],MODE_BID);
      if(bid<=0 || GetLastError()!=0)
         continue;
      return(i%2==0 ? bid : 1.0/bid);
     }
   return(0.0);
  }

//--- account money of one tick of one lot: MODE_TICKVALUE; when the terminal gives 0 (tester: gold, crypto),
//--- tick size x contract size x the profit currency's rate to the account currency
double VtTickValue(const string sym,const string acct_ccy,double &tick_size)
  {
   tick_size=MarketInfo(sym,MODE_TICKSIZE);
   double tv=MarketInfo(sym,MODE_TICKVALUE);
   if(tv>0)
      return(tv);
   double contract=MarketInfo(sym,MODE_LOTSIZE);
   string ccy=SymbolInfoString(sym,SYMBOL_CURRENCY_PROFIT);
   if(tick_size<=0 || contract<=0 || ccy=="")
      return(0.0);
   string suffix=(StringLen(sym)>6 ? StringSubstr(sym,6) : "");
   double rate=VtCrossRate(ccy,acct_ccy,suffix);
   return(rate>0 ? tick_size*contract*rate : 0.0);
  }

//--- loss (<= 0) of `lots` from `open` to `stop`, in account money; 0 when the symbol gives no tick value
double VtRiskMoney(const string sym,const int dir,const double lots,const double open,const double stop,const string acct_ccy)
  {
   double ts;
   double tv=VtTickValue(sym,acct_ccy,ts);
   if(tv<=0 || ts<=0)
      return(0.0);
   double dist=(dir==0 ? stop-open : open-stop);
   return(dist/ts*tv*lots);
  }

//--- the open positions as engine input
int VtReadPositions(VtPos &out[],const string acct_ccy)
  {
   int total=OrdersTotal(),k=0;
   ArrayResize(out,total);
   for(int i=0; i<total; i++)
     {
      if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES) || OrderType()>OP_SELL)
         continue;
      string sym=OrderSymbol();
      int type=OrderType();
      double vol=OrderLots(),po=OrderOpenPrice(),sl=OrderStopLoss();
      double pc=OrderClosePrice();                  // the current price of an open order
      out[k].symbol=sym;
      out[k].magic=OrderMagicNumber();
      out[k].comment=OrderComment();
      out[k].dir=(type==OP_BUY ? 0 : 1);
      out[k].volume=vol;
      out[k].profit=OrderProfit()+OrderSwap();
      out[k].sl=sl;
      int digits=(int)MarketInfo(sym,MODE_DIGITS);
      double point=MarketInfo(sym,MODE_POINT);
      int mult=VtPipMult(sym,digits);
      double pips=0;
      if(point>0)
         pips=(pc-po)/point/mult;
      out[k].pips=(type==OP_BUY ? pips : -pips);
      out[k].risk=0;
      if(sl>0)
         out[k].risk=VtRiskMoney(sym,out[k].dir,vol,po,sl,acct_ccy);
      out[k].base=SymbolInfoString(sym,SYMBOL_CURRENCY_BASE);
      out[k].ccy=SymbolInfoString(sym,SYMBOL_CURRENCY_PROFIT);
      string suffix=(StringLen(sym)>6 ? StringSubstr(sym,6) : "");
      double rate=VtCrossRate(out[k].ccy,acct_ccy,suffix);
      double contract=MarketInfo(sym,MODE_LOTSIZE);
      if(rate<=0)                                   // no cross symbol: the terminal's own conversion
        {
         double ts;
         double tv=VtTickValue(sym,acct_ccy,ts);
         rate=(contract>0 && ts>0 ? tv/ts/contract : 0.0);
        }
      out[k].value=vol*contract*pc*rate;
      if(out[k].base=="")
         out[k].base=sym;
      if(out[k].ccy=="")
         out[k].ccy=sym;
      k++;
     }
   ArrayResize(out,k);
   return(k);
  }

//--- "from #123" = the rest of a partially closed order; the chain's first ticket is the position
long VtFromTicket(const string c)
  {
   if(StringFind(c,"from #")!=0)
      return(0);
   return(StringToInteger(StringSubstr(c,6)));
  }

//--- the comment an EA gave the order: the server's own notes are not part of it
string VtCleanComment(string c)
  {
   if(StringFind(c,"from #")==0 || StringFind(c,"to #")==0 || StringFind(c,"partial close")==0 || StringFind(c,"close hedge")==0)
      return("");
   int k=StringFind(c,"[");                    // "[sl]", "[tp]", "[so]" added when the server closed it
   if(k==0)
      return("");                              // (StringSubstr with length 0 would return the WHOLE string)
   if(k>0)
      c=StringSubstr(c,0,k);
   StringTrimRight(c);
   return(c);
  }

//--- the order history, rebuilt into the engine whenever it changes
class CVtHistory
  {
public:
   long     last_time;
   ulong    last_ticket;
   int      ndeals;
   bool     want_risk;
   long     login;
   bool     record;                // tests only: keep every deal that went into the engine
   VtDeal   rec[];
   int      nrec;
   string   m_sig;
   string   acct_ccy;
            CVtHistory(): last_time(0),last_ticket(0),ndeals(0),want_risk(false),login(0),record(false),nrec(0),m_sig("") {}
   void     Forget() { last_time=0; last_ticket=0; ndeals=0; m_sig=""; }
   //--- what changes when the history or the open orders change
   string   Signature()
     {
      int nh=OrdersHistoryTotal(),no=OrdersTotal();
      double st=0,sl=0;
      for(int i=0; i<no; i++)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
           { st+=OrderTicket(); sl+=OrderLots(); }
      long lt=0;
      if(nh>0 && OrderSelect(nh-1,SELECT_BY_POS,MODE_HISTORY))
         lt=OrderTicket();
      return(StringFormat("%d|%d|%.0f|%.2f|%I64d|%I64d",nh,no,st,sl,lt,AccountNumber()));
     }
   //--- the orders as deals, in time order (IN before OUT at the same second), into the engine
   bool     Rebuild(CVtEngine &e)
     {
      e.Reset();
      acct_ccy=AccountCurrency();
      ndeals=0; nrec=0; last_time=0; last_ticket=0;
      int nh=OrdersHistoryTotal(),no=OrdersTotal(),n=0;
      long   tk[],par[],ot[],ct[],mg[];
      int    ty[];
      double lt[],pf[],sw[],cm[],sl[],op[],cp[];
      string cmt[],sy[];
      int cap=nh+no;
      ArrayResize(tk,cap); ArrayResize(par,cap); ArrayResize(ot,cap); ArrayResize(ct,cap); ArrayResize(mg,cap); ArrayResize(ty,cap);
      ArrayResize(lt,cap); ArrayResize(pf,cap); ArrayResize(sw,cap); ArrayResize(cm,cap); ArrayResize(sl,cap);
      ArrayResize(op,cap); ArrayResize(cp,cap); ArrayResize(cmt,cap); ArrayResize(sy,cap);
      for(int pass=0; pass<2; pass++)
         for(int i=0; i<(pass==0 ? nh : no); i++)
           {
            if(!OrderSelect(i,SELECT_BY_POS,pass==0 ? MODE_HISTORY : MODE_TRADES))
               continue;
            int t=OrderType();
            if(t>OP_SELL && t!=6 && t!=7)
               continue;                            // pending orders: not trades
            tk[n]=OrderTicket(); ty[n]=t; cmt[n]=OrderComment(); par[n]=VtFromTicket(cmt[n]);
            ot[n]=(long)OrderOpenTime(); ct[n]=(pass==0 ? (long)OrderCloseTime() : 0); mg[n]=OrderMagicNumber();
            lt[n]=OrderLots(); pf[n]=OrderProfit(); sw[n]=OrderSwap(); cm[n]=OrderCommission();
            sl[n]=OrderStopLoss(); op[n]=OrderOpenPrice(); cp[n]=OrderClosePrice(); sy[n]=OrderSymbol();
            n++;
           }
      //--- position of each order: follow "from #" to the first ticket (tickets sorted for the lookup)
      double idx[][2];
      ArrayResize(idx,n);
      for(int i=0; i<n; i++)
        { idx[i][0]=(double)tk[i]; idx[i][1]=i; }
      if(n>1)
         ArraySort(idx);
      long root[];
      ArrayResize(root,n);
      for(int i=0; i<n; i++)
        {
         long r=tk[i],p=par[i];
         for(int guard=0; p!=0 && guard<10000; guard++)
           {
            r=p;
            p=0;
            int lo=0,hi=n-1;                        // binary search for ticket r
            while(lo<=hi)
              {
               int mid=(lo+hi)/2;
               if(idx[mid][0]<(double)r)
                  lo=mid+1;
               else
                  if(idx[mid][0]>(double)r)
                     hi=mid-1;
                  else
                    { p=par[(int)idx[mid][1]]; break; }
              }
           }
         root[i]=r;
        }
      //--- tick size and value per symbol (cached for this rebuild)
      string csym[];
      double cts[],ctv[];
      int    ncs=0;
      //--- the deals; phase 0 cash, 1 opening, 2 closing; sorted by time, phase, reading order
      int nd=0;
      VtDeal dl[];
      double key[][2];
      ArrayResize(dl,2*n); ArrayResize(key,2*n);
      for(int i=0; i<n; i++)
        {
         if(ty[i]==6 || ty[i]==7)
           {
            VtDeal d;
            d.time=ct[i]>0 ? ct[i] : ot[i]; d.pos=tk[i]; d.magic=0; d.type=(ty[i]==6 ? VT_T_CASH : VT_T_CREDIT); d.entry=VT_IN;
            d.volume=0; d.price=0; d.profit=pf[i]; d.swap=0; d.commission=0; d.fee=0; d.sl=0; d.risk=0; d.symbol=""; d.comment="";
            dl[nd]=d;
            key[nd][0]=((double)d.time*3.0+0)*1048576.0+nd; key[nd][1]=nd; nd++;
            continue;
           }
         for(int e2=0; e2<2; e2++)
           {
            if(e2==1 && ct[i]==0)
               continue;
            VtDeal d;
            d.time=(e2==0 ? ot[i] : ct[i]); d.pos=root[i]; d.magic=mg[i];
            d.type=(e2==0 ? (ty[i]==OP_BUY ? VT_T_BUY : VT_T_SELL) : (ty[i]==OP_BUY ? VT_T_SELL : VT_T_BUY));
            d.entry=(e2==0 ? VT_IN : VT_OUT);
            d.volume=lt[i]; d.price=(e2==0 ? op[i] : cp[i]);
            d.profit=(e2==0 ? 0 : pf[i]); d.swap=(e2==0 ? 0 : sw[i]); d.commission=(e2==0 ? 0 : cm[i]); d.fee=0;
            d.sl=(e2==0 ? sl[i] : 0); d.risk=0;
            d.symbol=sy[i]; d.comment=(e2==0 ? VtCleanComment(cmt[i]) : "");
            if(want_risk && e2==0 && sl[i]>0)
              {
               int q=-1;
               for(int j=0; j<ncs; j++)
                  if(csym[j]==sy[i])
                    { q=j; break; }
               if(q<0)
                 {
                  q=ncs++;
                  ArrayResize(csym,ncs); ArrayResize(cts,ncs); ArrayResize(ctv,ncs);
                  csym[q]=sy[i]; ctv[q]=VtTickValue(sy[i],acct_ccy,cts[q]);
                 }
               if(ctv[q]>0 && cts[q]>0)
                 {
                  double dist=(ty[i]==OP_BUY ? sl[i]-op[i] : op[i]-sl[i]);
                  d.risk=MathMax(0.0,-(dist/cts[q]*ctv[q]*lt[i]));
                 }
              }
            dl[nd]=d;
            key[nd][0]=((double)d.time*3.0+(e2==0 ? 1 : 2))*1048576.0+nd; key[nd][1]=nd; nd++;
           }
        }
      ArrayResize(key,nd);
      if(nd>1)
         ArraySort(key);
      for(int i=0; i<nd; i++)
        {
         VtDeal d=dl[(int)key[i][1]];
         if(record)
           { ArrayResize(rec,nrec+1,4096); rec[nrec++]=d; }
         e.Add(d);
         last_time=d.time;
         ndeals++;
        }
      last_ticket=(ndeals>0 ? 1 : 0);
      m_sig=Signature();
      return(true);
     }
   //--- true when the engine changed (a new order, a close, a partial close, another account)
   bool     Refresh(CVtEngine &e,bool &rebuilt)
     {
      rebuilt=false;
      long lg=AccountNumber();
      string sg=Signature();
      if(sg==m_sig && lg==login)
         return(false);
      login=lg;
      rebuilt=true;
      Rebuild(e);
      return(true);
     }
  };

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