//+------------------------------------------------------------------+
//|                                                     UQ_Exec.mqh |
//|   Universal Quant EA - sizing, order validation and position I/O |
//|                                                                  |
//|  Position ownership is decided by Magic Number only. Anything    |
//|  with a different magic is treated as external and is never      |
//|  modified or closed unless whole-account liquidation was          |
//|  explicitly enabled by the owner.                                |
//+------------------------------------------------------------------+
#ifndef UQ_EXEC_MQH
#define UQ_EXEC_MQH

#include "UQ_Defs.mqh"
#include "UQ_Symbols.mqh"
#include "UQ_Risk.mqh"

//+------------------------------------------------------------------+
//| Execution configuration                                          |
//+------------------------------------------------------------------+
struct UQExecConfig
  {
   ulong    magic;
   ulong    deviation;
   string   portfolioTag;
   double   riskPct;
   double   maxAggRiskPct;
   double   riskBufferPct;      // % of the risk budget withheld for costs and slippage
   double   slAtrMultiplier;
   double   maxSpreadPoints;
  };

//--- The aggregate exposure is calculated in exactly one place,
//--- UQExposureFromPools() in UQ_Risk.mqh, so positions, pending orders and
//--- unreconciled reservations can never be counted by two different formulas.

//+------------------------------------------------------------------+
//| Volume derived from monetary risk and the entry-to-stop distance |
//| Never rounded upward beyond the permitted risk budget.           |
//+------------------------------------------------------------------+
bool UQVolumeForRisk(const string symbol, const ENUM_ORDER_TYPE type,
                     const double entry, const double stop,
                     const double riskMoney, double &lotsOut, string &err)
  {
   lotsOut = 0.0;
   err     = "";

   if(!(riskMoney > 0.0))
     {
      err = "risk budget is not positive";
      return(false);
     }

   const double vstep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
   const double vmin  = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
   const double vmax  = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
   if(!(vstep > 0.0) || !(vmin > 0.0) || !(vmax > 0.0))
     {
      err = "invalid broker volume constraints";
      return(false);
     }

   double p1 = 0.0;
   if(!OrderCalcProfit(type, symbol, 1.0, entry, stop, p1))
     {
      err = StringFormat("OrderCalcProfit failed for one lot (%d)", GetLastError());
      return(false);
     }

   //--- a stop-loss distance must produce an actual adverse loss: a zero or
   //--- positive result cannot describe risk, and MathAbs() must never turn it
   //--- into a plausible positive estimate
   if(!MathIsValidNumber(p1) || !(p1 < 0.0))
     {
      err = StringFormat("the per-lot loss estimate is not an adverse loss (%s)",
                         DoubleToString(p1, 2));
      return(false);
     }

   const double lossPerLot = -p1;

   const double raw      = riskMoney / lossPerLot;
   const int    vdigits  = UQVolumeDigits(vstep);

   double lots = NormalizeDouble(MathFloor(raw / vstep + 1e-9) * vstep, vdigits);
   if(lots > vmax)
      lots = NormalizeDouble(MathFloor(vmax / vstep) * vstep, vdigits);

   //--- bounded downward correction: the realised risk must never exceed the budget
   for(int attempt = 0; attempt < 8 && lots >= vmin; attempt++)
     {
      double p = 0.0;
      if(!OrderCalcProfit(type, symbol, lots, entry, stop, p))
        {
         err = StringFormat("OrderCalcProfit failed for %s lots (%d)",
                            DoubleToString(lots, vdigits), GetLastError());
         return(false);
        }
      if(!MathIsValidNumber(p) || !(p < 0.0))
        {
         err = StringFormat("the loss estimate for %s lots is not an adverse loss (%s)",
                            DoubleToString(lots, vdigits), DoubleToString(p, 2));
         return(false);
        }
      if(-p <= riskMoney + 1e-9)
         break;
      lots = NormalizeDouble(lots - vstep, vdigits);
     }

   if(lots < vmin)
     {
      err = StringFormat("minimum lot %s exceeds the permitted risk budget (raw %s lots)",
                         DoubleToString(vmin, vdigits), DoubleToString(raw, 4));
      return(false);
     }
   if(lots > vmax)
     {
      err = "volume exceeds the broker maximum";
      return(false);
     }

   lotsOut = lots;
   return(true);
  }

//+------------------------------------------------------------------+
//| Market order submission with protective stop attached.           |
//+------------------------------------------------------------------+
bool UQSendMarket(const string symbol, const int direction, const double lots,
                  const double slPrice, const ulong magic, const ulong deviation,
                  const string comment, ulong &orderTicket, ulong &dealTicket,
                  ENUM_UQ_SUBMIT_RESULT &outcome, string &err)
  {
   orderTicket = 0;
   dealTicket  = 0;
   err         = "";
   //--- every path below either proves that nothing was submitted or knows how
   //--- far the request went. The caller releases reserved risk on exactly two
   //--- of these outcomes.
   outcome     = UQ_SUBMIT_NONE_LOCAL;

   MqlTick tick;
   if(!SymbolInfoTick(symbol, tick))
     {
      err = "quote is unavailable";
      return(false);
     }

   const ENUM_ORDER_TYPE type  = (direction > 0) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
   const double          price = (direction > 0) ? tick.ask : tick.bid;
   if(price <= 0.0)
     {
      err = "bid/ask is invalid";
      return(false);
     }

   MqlTradeRequest req;
   MqlTradeResult  res;
   ZeroMemory(req);
   ZeroMemory(res);

   req.action       = TRADE_ACTION_DEAL;
   req.symbol       = symbol;
   req.volume       = lots;
   req.type         = type;
   req.price        = UQNormalizePrice(symbol, price);
   req.sl           = (slPrice > 0.0) ? UQNormalizePrice(symbol, slPrice) : 0.0;
   req.tp           = 0.0;
   req.deviation    = deviation;
   req.magic        = magic;
   req.comment      = comment;
   req.type_filling = UQPickFillingMode(symbol);

   //--- a failed call is classified before any conclusion is drawn about the
   //--- risk: a lost answer is not a rejection, so the reservation must stay
   if(!OrderSend(req, res))
     {
      outcome = UQSubmitResultFromRetcode(res.retcode);
      err     = StringFormat("OrderSend failed (retcode=%d, last error=%d), submission %s",
                             res.retcode, GetLastError(), UQSubmitResultText(outcome));
      return(false);
     }

   if(res.retcode != TRADE_RETCODE_DONE &&
      res.retcode != TRADE_RETCODE_PLACED &&
      res.retcode != TRADE_RETCODE_DONE_PARTIAL)
     {
      //--- the call returned but the server did not accept the request: only
      //--- a retcode that proves non-execution may release the reserved risk
      outcome = UQSubmitResultFromRetcode(res.retcode);
      err     = StringFormat("order rejected (retcode=%d, comment='%s'), submission %s",
                             res.retcode, res.comment, UQSubmitResultText(outcome));
      return(false);
     }

   orderTicket = (ulong)res.order;
   dealTicket  = (ulong)res.deal;
   outcome     = UQ_SUBMIT_ACCEPTED;
   return(true);
  }

//+------------------------------------------------------------------+
//| Open one signal position with full pre-trade validation.         |
//|                                                                  |
//| Order of operations, fail closed at every step:                   |
//|   1. quote, spread and normalised stop (tick-size aligned);        |
//|   2. monetary budget from equity, minus the configured cost        |
//|      buffer;                                                       |
//|   3. aggregate exposure (positions + pending + reservation) and    |
//|      the remaining aggregate budget;                               |
//|   4. volume from the normalised stop, margin, OrderCheck;          |
//|   5. the actual risk is reserved and persisted BEFORE the request  |
//|      leaves the terminal;                                          |
//|   6. the server answer is verified: a rejected order releases the  |
//|      reservation, an accepted one keeps it until the resulting     |
//|      position or pending order is visible.                          |
//+------------------------------------------------------------------+
bool UQOpenSignalPosition(const string symbol, const int direction, const double atr,
                          UQExecConfig &cfg, CUQRisk &risk, double &lotsOut, string &err)
  {
   lotsOut = 0.0;
   err     = "";

   if(direction == 0)
     {
      err = "no signal direction";
      return(false);
     }
   if(!(atr > 0.0))
     {
      err = "ATR is not usable";
      return(false);
     }

   MqlTick tick;
   if(!SymbolInfoTick(symbol, tick))
     {
      err = "quote is unavailable";
      return(false);
     }
   if(tick.bid <= 0.0 || tick.ask <= 0.0)
     {
      err = "bid/ask is invalid";
      return(false);
     }

   const double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
   if(!(point > 0.0))
     {
      err = "point size is invalid";
      return(false);
     }

   const double spreadPoints = (tick.ask - tick.bid) / point;
   if(cfg.maxSpreadPoints > 0.0 && spreadPoints > cfg.maxSpreadPoints)
     {
      err = StringFormat("spread %s points exceeds limit %s",
                         DoubleToString(spreadPoints, 1), DoubleToString(cfg.maxSpreadPoints, 1));
      return(false);
     }

   const ENUM_ORDER_TYPE type  = (direction > 0) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
   const double          entry = UQNormalizePrice(symbol, (direction > 0) ? tick.ask : tick.bid);
   const int             sdig  = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
   const double          dist  = atr * cfg.slAtrMultiplier;

   //--- the stop is aligned to the broker tick size first: the volume, the
   //--- monetary risk and the aggregate check all use the exact price that is
   //--- submitted, never a pre-normalisation estimate
   const double stop = UQNormalizePrice(symbol, (direction > 0) ? (entry - dist) : (entry + dist));

   if(!(dist > 0.0) || stop <= 0.0)
     {
      err = "invalid stop distance";
      return(false);
     }
   if(direction > 0 && !(stop < entry))
     {
      err = "the normalised stop is not below the entry price";
      return(false);
     }
   if(direction < 0 && !(stop > entry))
     {
      err = "the normalised stop is not above the entry price";
      return(false);
     }

   //--- broker minimum stop distance
   const long   stopsLevel = (long)SymbolInfoInteger(symbol, SYMBOL_TRADE_STOPS_LEVEL);
   const double minDist    = (double)stopsLevel * point;
   if(minDist > 0.0)
     {
      if(direction > 0 && (entry - stop) < minDist)
        {
         err = StringFormat("stop distance %s below broker minimum %s",
                            DoubleToString(entry - stop, sdig), DoubleToString(minDist, sdig));
         return(false);
        }
      if(direction < 0 && (stop - entry) < minDist)
        {
         err = StringFormat("stop distance %s below broker minimum %s",
                            DoubleToString(stop - entry, sdig), DoubleToString(minDist, sdig));
         return(false);
        }
     }

   //--- risk budget
   const double equity = AccountInfoDouble(ACCOUNT_EQUITY);
   if(!(equity > 0.0))
     {
      err = "account equity is unavailable";
      return(false);
     }

   double budget = equity * cfg.riskPct / 100.0;

   //--- optional withholding for transaction costs and slippage. It only ever
   //--- reduces the budget: at zero the estimate covers the stop-loss distance
   //--- alone and no all-in cost claim is made.
   if(cfg.riskBufferPct > 0.0)
      budget *= (1.0 - MathMin(cfg.riskBufferPct, 90.0) / 100.0);

   //--- aggregate exposure: positions, pending orders and reserved money
   UQExposure exp;
   risk.Exposure(cfg.magic, exp);
   if(!exp.bounded)
     {
      err = StringFormat("the aggregate EA exposure cannot be bounded (%s); new entries are blocked", exp.detail);
      return(false);
     }

   const double occupied     = exp.Total();
   const double aggLimit     = equity * cfg.maxAggRiskPct / 100.0;
   const double aggRemaining = aggLimit - occupied;
   if(aggRemaining <= 0.0)
     {
      err = StringFormat("aggregate exposure %s already reached the limit %s (positions %s, pending %s, reserved %s)",
                         DoubleToString(occupied, 2), DoubleToString(aggLimit, 2),
                         DoubleToString(exp.positions, 2), DoubleToString(exp.pending, 2),
                         DoubleToString(exp.reserved, 2));
      return(false);
     }
   if(budget > aggRemaining)
      budget = aggRemaining;

   if(budget <= 0.0)
     {
      err = "risk budget is exhausted";
      return(false);
     }

   //--- volume
   double lots = 0.0;
   if(!UQVolumeForRisk(symbol, type, entry, stop, budget, lots, err))
      return(false);

   //--- margin
   double margin = 0.0;
   if(!OrderCalcMargin(type, symbol, lots, entry, margin))
     {
      err = StringFormat("OrderCalcMargin failed (%d)", GetLastError());
      return(false);
     }
   const double freeMargin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
   if(margin > freeMargin)
     {
      err = StringFormat("insufficient free margin (required %s, free %s)",
                         DoubleToString(margin, 2), DoubleToString(freeMargin, 2));
      return(false);
     }

   //--- the risk that the submitted volume actually carries
   double actualRisk = 0.0;
   if(!OrderCalcProfit(type, symbol, lots, entry, stop, actualRisk))
     {
      err = StringFormat("OrderCalcProfit failed for the final volume (%d)", GetLastError());
      return(false);
     }
   //--- the risk that is going to be reserved must be a verified adverse loss:
   //--- a zero or positive result means the monetary risk cannot be measured,
   //--- so the entry is refused instead of reserving a fabricated amount
   if(!MathIsValidNumber(actualRisk) || !(actualRisk < 0.0))
     {
      err = StringFormat("the monetary risk to the stop cannot be measured (result %s); the entry is refused",
                         DoubleToString(actualRisk, 2));
      return(false);
     }
   actualRisk = -actualRisk;
   if(actualRisk > budget + 1e-9)
     {
      err = StringFormat("the normalised stop makes the risk %s exceed the budget %s",
                         DoubleToString(actualRisk, 2), DoubleToString(budget, 2));
      return(false);
     }
   if(actualRisk > aggRemaining + 1e-9)
     {
      err = StringFormat("the normalised stop makes the risk %s exceed the remaining aggregate budget %s",
                         DoubleToString(actualRisk, 2), DoubleToString(aggRemaining, 2));
      return(false);
     }

   //--- broker pre-trade validation of the exact request
   MqlTradeRequest     req;
   MqlTradeCheckResult chk;
   ZeroMemory(req);
   ZeroMemory(chk);
   req.action       = TRADE_ACTION_DEAL;
   req.symbol       = symbol;
   req.volume       = lots;
   req.type         = type;
   req.price        = entry;
   req.sl           = stop;
   req.tp           = 0.0;
   req.deviation    = cfg.deviation;
   req.magic        = cfg.magic;
   req.comment      = cfg.portfolioTag;
   req.type_filling = UQPickFillingMode(symbol);

   if(!OrderCheck(req, chk))
     {
      err = StringFormat("OrderCheck failed (retcode=%d, comment='%s', margin=%s, free=%s, last error=%d)",
                         chk.retcode, chk.comment,
                         DoubleToString(chk.margin, 2), DoubleToString(chk.margin_free, 2), GetLastError());
      return(false);
     }
   if(chk.retcode != TRADE_RETCODE_DONE && chk.retcode != 0)
     {
      err = StringFormat("OrderCheck rejected the request (retcode=%d, comment='%s')",
                         chk.retcode, chk.comment);
      return(false);
     }

   //--- the risk is reserved and persisted together with the identity of the
   //--- request, so a restart or a lost answer cannot lose it
   if(!risk.ReserveEntryRisk(cfg.magic, symbol, direction, lots, entry, stop,
                             actualRisk, err))
      return(false);

   //--- submit
   ulong  orderTicket = 0;
   ulong  dealTicket  = 0;
   ENUM_UQ_SUBMIT_RESULT outcome = UQ_SUBMIT_UNCERTAIN;
   if(!UQSendMarket(symbol, direction, lots, stop, cfg.magic, cfg.deviation,
                    cfg.portfolioTag, orderTicket, dealTicket, outcome, err))
     {
      //--- only "nothing was submitted" and a proven broker rejection allow
      //--- the reserved risk to be withdrawn. Any other result means the
      //--- request may be live at the broker, so it stays reserved.
      if(outcome == UQ_SUBMIT_NONE_LOCAL || outcome == UQ_SUBMIT_REJECTED)
         risk.ReleaseReservation(UQSubmitResultText(outcome));
      else
        {
         risk.MarkReservationUncertain(err);
         err = err + "; the reserved risk stays active and new entries are blocked";
        }
      return(false);
     }

   //--- the accepted order keeps its reservation until the broker state shows
   //--- the position or the pending order it produced. Reconciling here means
   //--- the remaining symbols of this processing interval are already measured
   //--- against the verified exposure instead of the reservation.
   risk.NoteSubmittedTickets(orderTicket, dealTicket);
   risk.ReconcileReservationDepth(true);

   lotsOut = lots;

   PrintFormat("[UQ] OPEN %s %s lots=%s entry=%s sl=%s riskBudget=%s order=%s deal=%s",
               symbol, (direction > 0 ? "BUY" : "SELL"),
               DoubleToString(lots, UQVolumeDigits(SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP))),
               DoubleToString(entry, sdig), DoubleToString(stop, sdig),
               DoubleToString(budget, 2),
               IntegerToString((long)orderTicket), IntegerToString((long)dealTicket));
   return(true);
  }

//+------------------------------------------------------------------+
//| Close one position by ticket                                     |
//+------------------------------------------------------------------+
bool UQClosePosition(const ulong ticket, const ulong deviation, string &err)
  {
   err = "";

   if(!PositionSelectByTicket(ticket))
     {
      err = StringFormat("position %s is not selectable", IntegerToString((long)ticket));
      return(false);
     }

   const string symbol = PositionGetString(POSITION_SYMBOL);
   const double volume = PositionGetDouble(POSITION_VOLUME);
   const long   ptype  = PositionGetInteger(POSITION_TYPE);
   const ulong  magic  = (ulong)PositionGetInteger(POSITION_MAGIC);

   if(volume <= 0.0)
     {
      err = "position volume is invalid";
      return(false);
     }

   MqlTick tick;
   if(!SymbolInfoTick(symbol, tick))
     {
      err = "quote is unavailable";
      return(false);
     }

   MqlTradeRequest req;
   MqlTradeResult  res;
   ZeroMemory(req);
   ZeroMemory(res);

   req.action       = TRADE_ACTION_DEAL;
   req.position     = ticket;
   req.symbol       = symbol;
   req.volume       = volume;
   req.type         = (ptype == POSITION_TYPE_BUY) ? ORDER_TYPE_SELL : ORDER_TYPE_BUY;
   req.price        = UQNormalizePrice(symbol, (ptype == POSITION_TYPE_BUY) ? tick.bid : tick.ask);
   req.deviation    = deviation;
   req.magic        = magic;
   req.comment      = "UQ close";
   req.type_filling = UQPickFillingMode(symbol);

   if(!OrderSend(req, res))
     {
      err = StringFormat("close OrderSend failed (retcode=%d, last error=%d)", res.retcode, GetLastError());
      return(false);
     }
   if(res.retcode != TRADE_RETCODE_DONE &&
      res.retcode != TRADE_RETCODE_PLACED &&
      res.retcode != TRADE_RETCODE_DONE_PARTIAL)
     {
      err = StringFormat("close rejected (retcode=%d)", res.retcode);
      return(false);
     }
   return(true);
  }

//+------------------------------------------------------------------+
//| Scope inventory: pending orders                                  |
//+------------------------------------------------------------------+
struct UQPendingRef
  {
   ulong           ticket;
   string          symbol;
   ENUM_ORDER_TYPE type;
   double          volume;
   double          price;
  };

//+------------------------------------------------------------------+
//| Scope inventory: open positions                                  |
//+------------------------------------------------------------------+
struct UQPositionRef
  {
   ulong  ticket;
   string symbol;
   long   type;
   double volume;
   ulong  magic;
  };

//+------------------------------------------------------------------+
//| Collect every pending order inside the authorized scope.         |
//| wholeAccount=false restricts the scope to this EA's magic only,  |
//| so unrelated orders are never touched.                           |
//+------------------------------------------------------------------+
int UQCollectPending(const ulong magic, const bool wholeAccount, UQPendingRef &list[])
  {
   ArrayResize(list, 0);
   int count = 0;
   const int total = OrdersTotal();
   for(int i = 0; i < total; i++)
     {
      const ulong ticket = OrderGetTicket(i);
      if(ticket == 0)
         continue;
      if(!wholeAccount && (ulong)OrderGetInteger(ORDER_MAGIC) != magic)
         continue;

      ArrayResize(list, count + 1);
      list[count].ticket = ticket;
      list[count].symbol = OrderGetString(ORDER_SYMBOL);
      list[count].type   = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
      list[count].volume = OrderGetDouble(ORDER_VOLUME_CURRENT);
      list[count].price  = OrderGetDouble(ORDER_PRICE_OPEN);
      count++;
     }
   return(count);
  }

//+------------------------------------------------------------------+
//| Collect every open position inside the authorized scope.         |
//+------------------------------------------------------------------+
int UQCollectPositions(const ulong magic, const bool wholeAccount, UQPositionRef &list[])
  {
   ArrayResize(list, 0);
   int count = 0;
   const int total = PositionsTotal();
   for(int i = 0; i < total; i++)
     {
      const ulong ticket = PositionGetTicket(i);
      if(ticket == 0)
         continue;
      if(!wholeAccount && (ulong)PositionGetInteger(POSITION_MAGIC) != magic)
         continue;

      ArrayResize(list, count + 1);
      list[count].ticket = ticket;
      list[count].symbol = PositionGetString(POSITION_SYMBOL);
      list[count].type   = PositionGetInteger(POSITION_TYPE);
      list[count].volume = PositionGetDouble(POSITION_VOLUME);
      list[count].magic  = (ulong)PositionGetInteger(POSITION_MAGIC);
      count++;
     }
   return(count);
  }

//+------------------------------------------------------------------+
//| Account scope of the exposure this EA actually controls           |
//|                                                                  |
//| The three limits are account-equity limits, but liquidation is    |
//| restricted to this EA's own magic scope unless whole-account      |
//| liquidation is explicitly authorized. Unmanaged positions and     |
//| pending orders are counted, disclosed and - while the guard is    |
//| enabled - they block every new entry. They are never modified.    |
//+------------------------------------------------------------------+
struct UQAccountScope
  {
   int      ownPositions;
   int      ownPending;
   int      externalPositions;
   int      externalPending;
   string   externalDetail;    // symbols of the unmanaged exposure, diagnostics only
  };

//+------------------------------------------------------------------+
//| Count owned and unmanaged positions and pending orders           |
//+------------------------------------------------------------------+
bool UQAccountScopeScan(const ulong magic, UQAccountScope &out)
  {
   out.ownPositions      = 0;
   out.ownPending        = 0;
   out.externalPositions = 0;
   out.externalPending   = 0;
   out.externalDetail    = "";

   //--- without an ownership key no exposure can be attributed, so the scope
   //--- is unusable and the caller must fail closed
   if(magic == 0)
      return(false);

   string names  = "";
   int    listed = 0;

   const int positions = PositionsTotal();
   for(int i = 0; i < positions; i++)
     {
      const ulong ticket = PositionGetTicket(i);
      if(ticket == 0)
         continue;
      if((ulong)PositionGetInteger(POSITION_MAGIC) == magic)
        {
         out.ownPositions++;
         continue;
        }
      out.externalPositions++;
      const string sym = PositionGetString(POSITION_SYMBOL);
      if(StringLen(sym) > 0 && StringFind(names, sym) < 0 && listed < 5)
        {
         names  += (StringLen(names) > 0 ? "," : "") + sym;
         listed++;
        }
     }

   const int orders = OrdersTotal();
   for(int i = 0; i < orders; i++)
     {
      const ulong ticket = OrderGetTicket(i);
      if(ticket == 0)
         continue;
      if((ulong)OrderGetInteger(ORDER_MAGIC) == magic)
        {
         out.ownPending++;
         continue;
        }
      out.externalPending++;
      const string sym = OrderGetString(ORDER_SYMBOL);
      if(StringLen(sym) > 0 && StringFind(names, sym) < 0 && listed < 5)
        {
         names  += (StringLen(names) > 0 ? "," : "") + sym;
         listed++;
        }
     }

   out.externalDetail = names;
   return(true);
  }

//+------------------------------------------------------------------+
//| One-line disclosure of the liquidation scope that is enforced    |
//+------------------------------------------------------------------+
string UQScopeDisclosure(const UQAccountScope &scope, const bool blockExternal, const bool wholeAccount)
  {
   if(wholeAccount)
      return(StringFormat("WHOLE-ACCOUNT liquidation authorized: %d owned and %d unmanaged position(s), %d unmanaged order(s) are in scope.",
                          scope.ownPositions, scope.externalPositions, scope.externalPending));

   string s = StringFormat("EA-ONLY liquidation (magic scope): %d owned position(s), %d owned order(s).",
                           scope.ownPositions, scope.ownPending);
   if(scope.externalPositions > 0 || scope.externalPending > 0)
     {
      s += StringFormat(" %d unmanaged position(s) and %d unmanaged order(s)%s remain outside control, so the account-wide 5%%/8%%/10%% limits cannot be guaranteed while they are open.",
                        scope.externalPositions, scope.externalPending,
                        (StringLen(scope.externalDetail) > 0 ? " (" + scope.externalDetail + ")" : ""));
      if(!blockExternal)
         s += " The external-exposure guard is disabled by input, so new entries are not blocked by them.";
      else
         s += " New entries are blocked by the external-exposure guard.";
     }
   return(s);
  }

//+------------------------------------------------------------------+
//| Account scope of an owner reset operation                        |
//|                                                                  |
//| A reset opens a new risk cycle, so it is only accepted when this  |
//| EA holds no exposure of any kind and the liquidation state is     |
//| verified. Unmanaged exposure outside the EA scope is rejected     |
//| when the EA is required to control the whole account.              |
//+------------------------------------------------------------------+
struct UQResetScope
  {
   bool     ok;
   string   detail;
   int      ownPositions;
   int      ownPending;
   int      externalPositions;
   int      externalPending;
   bool     liquidationComplete;
  };

//+------------------------------------------------------------------+
//| Verify the account scope before an owner reset is accepted       |
//+------------------------------------------------------------------+
bool UQCheckResetScope(const ulong magic, const bool blockExternal,
                       const bool liquidationComplete, UQResetScope &out)
  {
   out.ok                  = false;
   out.detail              = "";
   out.ownPositions        = 0;
   out.ownPending          = 0;
   out.externalPositions   = 0;
   out.externalPending     = 0;
   out.liquidationComplete = liquidationComplete;

   if(liquidationComplete == false)
     {
      out.detail = "liquidation is not verified complete";
      return(false);
     }

   if(!(bool)TerminalInfoInteger(TERMINAL_CONNECTED) && !(bool)MQLInfoInteger(MQL_TESTER))
     {
      out.detail = "the terminal is not connected, so the account scope cannot be verified";
      return(false);
     }

   const int positions = PositionsTotal();
   for(int i = 0; i < positions; i++)
     {
      const ulong ticket = PositionGetTicket(i);
      if(ticket == 0)
         continue;
      if((ulong)PositionGetInteger(POSITION_MAGIC) == magic)
         out.ownPositions++;
      else
         out.externalPositions++;
     }

   const int orders = OrdersTotal();
   for(int i = 0; i < orders; i++)
     {
      const ulong ticket = OrderGetTicket(i);
      if(ticket == 0)
         continue;
      if((ulong)OrderGetInteger(ORDER_MAGIC) == magic)
         out.ownPending++;
      else
         out.externalPending++;
     }

   if(out.ownPositions > 0)
     {
      out.detail = StringFormat("%d open EA position(s) must be closed and verified first", out.ownPositions);
      return(false);
     }
   if(out.ownPending > 0)
     {
      out.detail = StringFormat("%d EA pending order(s) must be cancelled and verified first", out.ownPending);
      return(false);
     }
   if(blockExternal && (out.externalPositions > 0 || out.externalPending > 0))
     {
      out.detail = StringFormat("unmanaged external exposure is present (%d position(s), %d order(s))",
                                out.externalPositions, out.externalPending);
      return(false);
     }

   out.ok = true;
   return(true);
  }

//+------------------------------------------------------------------+
//| Authoritative re-query of one pending order ticket               |
//+------------------------------------------------------------------+
bool UQPendingExists(const ulong ticket)
  {
   return(OrderSelect(ticket));
  }

//+------------------------------------------------------------------+
//| Remaining volume of one position ticket, 0.0 when it is closed   |
//+------------------------------------------------------------------+
double UQPositionRemaining(const ulong ticket)
  {
   if(!PositionSelectByTicket(ticket))
      return(0.0);
   return(PositionGetDouble(POSITION_VOLUME));
  }

//+------------------------------------------------------------------+
//| Cancel pending orders in scope and verify each removal.          |
//| A successful request is never treated as proof of deletion:      |
//| every targeted ticket is re-queried afterwards.                  |
//+------------------------------------------------------------------+
int UQCancelPendingVerified(const ulong magic, const bool wholeAccount,
                            int &requested, int &removed, string &detail)
  {
   requested = 0;
   removed   = 0;
   detail    = "";

   UQPendingRef list[];
   requested = UQCollectPending(magic, wholeAccount, list);

   for(int i = 0; i < requested; i++)
     {
      const ulong ticket = list[i].ticket;

      //--- the order may already be gone by the time it is processed
      if(!UQPendingExists(ticket))
        {
         removed++;
         continue;
        }

      MqlTradeRequest req;
      MqlTradeResult  res;
      ZeroMemory(req);
      ZeroMemory(res);

      req.action = TRADE_ACTION_REMOVE;
      req.order  = ticket;

      const bool sent = OrderSend(req, res);
      const uint code = res.retcode;

      //--- verify the actual result instead of trusting the request
      if(UQPendingExists(ticket))
        {
         detail += StringFormat("%s(retcode=%d%s) ",
                                IntegerToString((long)ticket), (int)code,
                                (sent ? "" : ",send-failed"));
        }
      else
        {
         removed++;
        }
     }

   if(requested > 0)
      detail += StringFormat("pendingRequested=%d pendingRemoved=%d ", requested, removed);
   return(removed);
  }

//+------------------------------------------------------------------+
//| Close positions in scope and verify each closure.                |
//| A partially closed position is never counted as closed; its       |
//| remainder is retried here and, if still exposed, in the next      |
//| liquidation cycle.                                               |
//+------------------------------------------------------------------+
int UQClosePositionsVerified(const ulong magic, const bool wholeAccount,
                             const ulong deviation,
                             int &targeted, int &closed, int &partial, string &detail)
  {
   targeted = 0;
   closed   = 0;
   partial  = 0;
   detail   = "";

   UQPositionRef list[];
   targeted = UQCollectPositions(magic, wholeAccount, list);

   for(int i = 0; i < targeted; i++)
     {
      const ulong ticket = list[i].ticket;
      double      before = UQPositionRemaining(ticket);
      if(before <= 0.0)
        {
         closed++;
         continue;
        }

      string lastErr = "";

      for(int attempt = 0; attempt < UQ_CLOSE_ATTEMPTS; attempt++)
        {
         if(!PositionSelectByTicket(ticket))
            break;                              // already gone

         UQClosePosition(ticket, deviation, lastErr);

         const double after = UQPositionRemaining(ticket);
         if(after <= 0.0)
            break;                              // verified closed
         if(after < before)
            before = after;                     // partial fill: close the remainder
        }

      const double rest = UQPositionRemaining(ticket);
      if(rest <= 0.0)
        {
         closed++;
         continue;
        }

      const int vdigits = UQVolumeDigits(SymbolInfoDouble(list[i].symbol, SYMBOL_VOLUME_STEP));
      if(rest < list[i].volume)
        {
         partial++;
         detail += StringFormat("%s(partial,remaining=%s) ",
                                IntegerToString((long)ticket), DoubleToString(rest, vdigits));
        }
      else
        {
         detail += StringFormat("%s(%s) ", IntegerToString((long)ticket),
                                (StringLen(lastErr) > 0 ? lastErr : "position still open"));
        }
     }

   if(targeted > 0)
      detail += StringFormat("positionsTargeted=%d positionsClosed=%d positionsPartial=%d ",
                             targeted, closed, partial);
   return(closed);
  }

//+------------------------------------------------------------------+
//| Liquidation state machine                                        |
//|                                                                  |
//| Every cycle re-queries the broker pools. The machine reaches     |
//| LIQUIDATION_COMPLETE only when both pools are verified empty for  |
//| the authorized scope. Exhausting the bounded attempt budget       |
//| produces MANUAL_INTERVENTION while exposure remains - it never    |
//| produces a completion claim and never re-enables entries.         |
//+------------------------------------------------------------------+
class CUQLiquidator
  {
private:
   ENUM_UQ_LIQ_STATE m_state;
   ulong             m_magic;
   ulong             m_deviation;
   bool              m_wholeAccount;
   int               m_cycles;
   datetime          m_nextAttempt;
   bool              m_flatVerified;
   string            m_detail;

   bool              RateLimited(void);
   void              Schedule(const int seconds);
   bool              VerifyFlat(string &detail);

public:
   CUQLiquidator(void);
  ~CUQLiquidator(void);

   void              Init(const ulong magic, const ulong deviation, const bool wholeAccount);
   void              Arm(void);
   void              Reset(void);
   void              Service(void);

   ENUM_UQ_LIQ_STATE State(void)        const { return(m_state);                    }
   string            StateText(void)    const { return(UQLiqStateText(m_state));     }
   bool              Idle(void)         const { return(m_state == UQ_LIQ_IDLE);      }
   bool              Complete(void)     const { return(m_state == UQ_LIQ_COMPLETE);  }
   bool              Unresolved(void)   const { return(m_state == UQ_LIQ_MANUAL_INTERVENTION); }
   bool              FlatVerified(void) const { return(m_flatVerified);              }
   int               Cycles(void)       const { return(m_cycles);                    }
   string            Detail(void)       const { return(m_detail);                    }
  };

//+------------------------------------------------------------------+
CUQLiquidator::CUQLiquidator(void)
  {
   m_state        = UQ_LIQ_IDLE;
   m_magic        = 0;
   m_deviation    = 0;
   m_wholeAccount = false;
   m_cycles       = 0;
   m_nextAttempt  = 0;
   m_flatVerified = false;
   m_detail       = "";
  }

//+------------------------------------------------------------------+
CUQLiquidator::~CUQLiquidator(void)
  {
  }

//+------------------------------------------------------------------+
void CUQLiquidator::Init(const ulong magic, const ulong deviation, const bool wholeAccount)
  {
   m_magic        = magic;
   m_deviation    = deviation;
   m_wholeAccount = wholeAccount;
   Reset();
  }

//+------------------------------------------------------------------+
//| Arm the machine for a new lock event. Nothing is declared done.  |
//+------------------------------------------------------------------+
void CUQLiquidator::Arm(void)
  {
   m_state        = UQ_LIQ_CANCEL_PENDING;
   m_cycles       = 0;
   m_nextAttempt  = 0;
   m_flatVerified = false;
   m_detail       = "";
  }

//+------------------------------------------------------------------+
void CUQLiquidator::Reset(void)
  {
   m_state        = UQ_LIQ_IDLE;
   m_cycles       = 0;
   m_nextAttempt  = 0;
   m_flatVerified = false;
   m_detail       = "";
  }

//+------------------------------------------------------------------+
bool CUQLiquidator::RateLimited(void)
  {
   if(m_nextAttempt <= 0)
      return(false);
   const datetime now = UQServerNow();
   if(now <= 0)
      return(false);
   return(now < m_nextAttempt);
  }

//+------------------------------------------------------------------+
void CUQLiquidator::Schedule(const int seconds)
  {
   const datetime now = UQServerNow();
   m_nextAttempt = (now > 0) ? (datetime)((long)now + seconds) : 0;
  }

//+------------------------------------------------------------------+
//| Authoritative flat verification for the authorized scope.        |
//| An unverifiable account state is reported as unresolved.         |
//+------------------------------------------------------------------+
bool CUQLiquidator::VerifyFlat(string &detail)
  {
   if(!(bool)TerminalInfoInteger(TERMINAL_CONNECTED) && !(bool)MQLInfoInteger(MQL_TESTER))
     {
      detail += "terminal is not connected: account state is UNVERIFIED ";
      return(false);
     }

   UQPendingRef pend[];
   const int np = UQCollectPending(m_magic, m_wholeAccount, pend);
   UQPositionRef pos[];
   const int nq = UQCollectPositions(m_magic, m_wholeAccount, pos);

   if(np > 0)
     {
      detail += StringFormat("pendingRemaining=%d [", np);
      for(int i = 0; i < np; i++)
         detail += IntegerToString((long)pend[i].ticket) + " ";
      detail += "] ";
     }
   if(nq > 0)
     {
      detail += StringFormat("positionsRemaining=%d [", nq);
      for(int i = 0; i < nq; i++)
        {
         detail += StringFormat("%s(vol=%s) ", IntegerToString((long)pos[i].ticket),
                                DoubleToString(pos[i].volume,
                                               UQVolumeDigits(SymbolInfoDouble(pos[i].symbol, SYMBOL_VOLUME_STEP))));
        }
      detail += "] ";
     }

   return(np == 0 && nq == 0);
  }

//+------------------------------------------------------------------+
//| One bounded liquidation cycle: cancel, close, verify.            |
//+------------------------------------------------------------------+
void CUQLiquidator::Service(void)
  {
   if(m_state == UQ_LIQ_IDLE || m_state == UQ_LIQ_COMPLETE)
      return;
   if(RateLimited())
      return;

   m_detail = "";

   m_state = UQ_LIQ_CANCEL_PENDING;
   int    cancelReq    = 0;
   int    cancelOk     = 0;
   string cancelDetail = "";
   UQCancelPendingVerified(m_magic, m_wholeAccount, cancelReq, cancelOk, cancelDetail);
   m_detail += cancelDetail;

   m_state = UQ_LIQ_CLOSE_POSITIONS;
   int    targeted    = 0;
   int    closed      = 0;
   int    partial     = 0;
   string closeDetail = "";
   UQClosePositionsVerified(m_magic, m_wholeAccount, m_deviation, targeted, closed, partial, closeDetail);
   m_detail += closeDetail;

   m_state = UQ_LIQ_VERIFY_FLAT;
   if(VerifyFlat(m_detail))
     {
      m_state        = UQ_LIQ_COMPLETE;
      m_flatVerified = true;
      m_nextAttempt  = 0;
      PrintFormat("[UQ] LIQUIDATION COMPLETE: order and position pools verified empty for the authorized scope after %d cycle(s).",
                  m_cycles + 1);
      return;
     }

   m_cycles++;
   m_flatVerified = false;

   if(m_cycles >= UQ_MAX_LIQ_ATTEMPTS)
     {
      m_state = UQ_LIQ_MANUAL_INTERVENTION;
      Schedule(UQ_LIQ_MANUAL_RETRY_SECONDS);
      PrintFormat("[UQ] ERROR: LIQUIDATION UNRESOLVED after %d cycles. Manual intervention required; the risk lock stays active, entries stay blocked and controlled retries continue: %s",
                  m_cycles, m_detail);
      return;
     }

   m_state = UQ_LIQ_RETRY_REQUIRED;
   Schedule(UQ_LIQ_RETRY_SECONDS);
   PrintFormat("[UQ] LIQUIDATION RETRY REQUIRED (cycle %d/%d): %s",
               m_cycles, UQ_MAX_LIQ_ATTEMPTS, m_detail);
  }


//+------------------------------------------------------------------+
//| ATR trailing stop. Only ever tightens protection.                |
//+------------------------------------------------------------------+
int UQApplyAtrTrailing(const ulong magic, CUQSymbols &symbols,
                       const double atrMultiplier, const ulong deviation)
  {
   int modified = 0;
   if(!(atrMultiplier > 0.0))
      return(0);

   const int total = PositionsTotal();
   for(int i = total - 1; i >= 0; i--)
     {
      const ulong ticket = PositionGetTicket(i);
      if(ticket == 0)
         continue;
      if((ulong)PositionGetInteger(POSITION_MAGIC) != magic)
         continue;

      const string symbol = PositionGetString(POSITION_SYMBOL);
      const int    idx    = symbols.FindByName(symbol);
      if(idx < 0)
         continue;

      const double atr = symbols.AtrValue(idx);
      if(!(atr > 0.0))
         continue;

      const double point   = SymbolInfoDouble(symbol, SYMBOL_POINT);
      const long   stops   = (long)SymbolInfoInteger(symbol, SYMBOL_TRADE_STOPS_LEVEL);
      const double minDist = (double)stops * point;

      const long   ptype = PositionGetInteger(POSITION_TYPE);
      const double cur   = PositionGetDouble(POSITION_PRICE_CURRENT);
      const double oldSl = PositionGetDouble(POSITION_SL);
      if(cur <= 0.0 || point <= 0.0)
         continue;

      const double trail = atr * atrMultiplier;
      double newSl = 0.0;

      if(ptype == POSITION_TYPE_BUY)
        {
         newSl = cur - trail;
         if(cur - newSl < minDist)
            newSl = cur - minDist;
         if(oldSl > 0.0 && newSl <= oldSl + point * 0.5)
            continue;
         if(newSl >= cur)
            continue;
        }
      else
        {
         newSl = cur + trail;
         if(newSl - cur < minDist)
            newSl = cur + minDist;
         if(oldSl > 0.0 && newSl >= oldSl - point * 0.5)
            continue;
         if(newSl <= cur)
            continue;
        }

      newSl = UQNormalizePrice(symbol, newSl);
      if(newSl <= 0.0)
         continue;

      MqlTradeRequest req;
      MqlTradeResult  res;
      ZeroMemory(req);
      ZeroMemory(res);

      req.action    = TRADE_ACTION_SLTP;
      req.position  = ticket;
      req.symbol    = symbol;
      req.sl        = newSl;
      req.tp        = PositionGetDouble(POSITION_TP);
      req.magic     = magic;
      req.deviation = deviation;

      if(!OrderSend(req, res) ||
         (res.retcode != TRADE_RETCODE_DONE && res.retcode != TRADE_RETCODE_PLACED))
        {
         PrintFormat("[UQ] trailing stop update failed %s ticket=%s retcode=%d",
                     symbol, IntegerToString((long)ticket), res.retcode);
         continue;
        }

      modified++;
     }

   return(modified);
  }

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