//+------------------------------------------------------------------+
//|                                       LW_SMC_CHOCH_OCO_EA.mq5    |
//|            CHoCH -> OCO pending orders + trailing stop            |
//|                                                                  |
//| Структура рынка считается так же, как в индикаторе               |
//| LW_MarketStructure_SMC.mq5 (фрактальные swing H/L + BOS + CHoCH). |
//|                                                                  |
//| Логика:                                                          |
//|  1) На новом ЗАКРЫТОМ баре ищем последний CHoCH (Change of        |
//|     Character = пробой swing-уровня против текущего тренда).      |
//|  2) На новый CHoCH выставляем два отложенных ордера (OCO):        |
//|     - OCO_STOP : BUY STOP выше цены + SELL STOP ниже цены;        |
//|     - OCO_LIMIT: BUY LIMIT ниже цены + SELL LIMIT выше цены.      |
//|  3) Как только один ордер исполнился — второй удаляется (OCO).    |
//|  4) Выход — по трейлинг-стопу (опц. безубыток / фикс. TP).        |
//|                                                                  |
//|  ВАЖНО: MT5 не принимает отложенный ордер с ценой на "неверной"   |
//|  стороне рынка (BUY LIMIT выше цены отклоняется сервером).        |
//|  Поэтому "BUY сверху + SELL снизу" реализовано стоп-ордерами      |
//|  (OCO_STOP), а лимитные ордера возможны только в зеркальной       |
//|  геометрии (BUY ниже, SELL выше) — режим OCO_LIMIT.               |
//+------------------------------------------------------------------+
#property copyright "Lonely Wolf"
#property version   "1.01"
#property description "CHoCH (LW_MarketStructure_SMC) -> OCO pending orders (BUY above / SELL below) + trailing stop."
#property description "Detection uses closed bars only (no repaint)."

#include <Trade\Trade.mqh>

//============================== ENUMS ================================
enum ENUM_OCO_MODE
  {
   OCO_STOP  = 0,   // Пробой: BUY STOP выше + SELL STOP ниже
   OCO_LIMIT = 1    // Откат:  BUY LIMIT ниже + SELL LIMIT выше
  };

enum ENUM_SL_MODE
  {
   SL_STRUCT = 0,   // По структуре (swing-экстремум CHoCH)
   SL_FIXED  = 1    // Фиксированный в пунктах
  };

enum ENUM_SL_ANCHOR
  {
   SL_ANCHOR_NEAR = 0,   // Ближний swing (тейтовый SL)
   SL_ANCHOR_FAR  = 1    // Дальний swing (широкий SL)
  };

//============================== INPUTS ===============================
input group "=== Идентификация ==="
input long   InpMagic               = 20261023;   // Магический номер
input double InpLot                 = 0.10;       // Объём (лоты), если риск-лот выключен
input bool   InpUseRiskPercent      = false;      // Считать лот от риска (% баланса)
input double InpRiskPercent         = 1.0;        // Риск на сделку (% баланса)

input group "=== Детекция CHoCH (как в индикаторе) ==="
input int    InpSwingN              = 5;          // Фрактал: баров с каждой стороны
input bool   InpBreakOnClose        = true;       // Пробой подтверждается по CLOSE свечи
input int    InpMaxBars             = 1500;       // Сколько последних закрытых баров анализировать
input bool   InpTradeExistingSignal = false;      // Торговать CHoCH, который уже был на старте EA

input group "=== OCO: отложенные ордера ==="
input ENUM_OCO_MODE InpOCOMode      = OCO_STOP;   // Тип OCO-сетапа
input double InpOffsetPoints        = 100.0;      // Отступ ордеров от цены (пункты)
input int    InpExpireBars          = 0;          // Срок жизни ордеров (баров; 0 = не истекают)
input bool   InpCancelOnNewSignal   = true;       // Снимать прошлые ордера при новом CHoCH
input bool   InpOneSetupAtATime     = true;       // Не выставлять новый сетап, пока есть позиция
input int    InpMaxSpreadPoints     = 0;          // Макс. спред (пункты; 0 = без контроля)
input int    InpDeviationPoints     = 30;         // Допустимое отклонение цены (пункты)

input group "=== Стоп-лосс / тейк-профит ==="
input ENUM_SL_MODE InpSLMode        = SL_STRUCT;  // Режим Stop Loss
input ENUM_SL_ANCHOR InpSLAnchor    = SL_ANCHOR_FAR; // Опора структурного SL (где стоит стоп)
input int    InpSLBufferPoints      = 30;         // Буфер SL за swing-экстремум (пункты)
input double InpSLFallbackPoints    = 500.0;      // Резервный SL (пункты), если нет валидной структуры (0 = не входить)
input double InpMaxSLPoints         = 1500.0;     // Макс. ширина SL (пункты; 0 = без ограничения)
input double InpSLPoints            = 500.0;      // Фикс. SL от входа (пункты) для режима SL_FIXED
input double InpTPPoints            = 0.0;        // TP от входа (пункты; 0 = без TP)
input bool   InpAllowNoSL           = false;      // ВНИМАНИЕ: разрешить вход без SL (риск)

input group "=== Трейлинг-стоп ==="
input bool   InpUseTrailing         = true;       // Трейлинг-стоп
input int    InpTrailStartPoints    = 300;        // Старт трейлинга при такой прибыли (пункты)
input int    InpTrailDistPoints     = 200;        // Дистанция трейлинга (пункты)
input int    InpTrailStepPoints     = 10;         // Мин. шаг перемещения SL (пункты)
input bool   InpUseBreakEven        = false;      // Перевод в безубыток
input int    InpBETriggerPoints     = 200;        // Прибыль для перевода в безубыток (пункты)
input int    InpBEBufferPoints      = 10;         // Смещение SL за цену входа (пункты)

input group "=== Прочее ==="
input bool   InpVerboseLog          = true;       // Подробный лог

//============================== TYPES ================================
struct SChochEvent
  {
   datetime time;         // время бара подтверждения CHoCH
   int      dir;          // +1 = бычий CHoCH (разворот вверх), -1 = медвежий
   double   level;        // пробитый swing-уровень
   double   oppLevel;     // противоположный swing (вторая опора для SL)
   bool     oppValid;     // противоположный swing найден
  };

struct SSymbolMetrics
  {
   double point;
   int    digits;
   double tickSize;
   double tickValue;
   double volMin;
   double volMax;
   double volStep;
   double stopsLevel;     // в цене
   double freezeLevel;    // в цене
   bool   valid;
  };

//============================== GLOBALS ==============================
CTrade        trade;
SSymbolMetrics g_sym;
datetime      g_lastBarTime    = 0;
datetime      g_lastSignalTime = 0;
ulong         g_ticketBuy      = 0;   // тикеты текущего OCO-сетапа
ulong         g_ticketSell     = 0;

//============================== INIT =================================
int OnInit()
  {
   if(InpLot <= 0.0 && !InpUseRiskPercent)
     {
      Print("LW_SMC_CHOCH_OCO_EA: InpLot must be > 0 (или включите риск-лот)");
      return INIT_PARAMETERS_INCORRECT;
     }
   if(InpSwingN < 1 || InpMaxBars < InpSwingN * 2 + 10)
     {
      Print("LW_SMC_CHOCH_OCO_EA: invalid detection inputs");
      return INIT_PARAMETERS_INCORRECT;
     }
   if(InpSLMode == SL_FIXED && InpSLPoints <= 0.0)
     {
      Print("LW_SMC_CHOCH_OCO_EA: InpSLPoints must be > 0 in SL_FIXED mode");
      return INIT_PARAMETERS_INCORRECT;
     }

   trade.SetExpertMagicNumber(InpMagic);
   trade.SetDeviationInPoints(InpDeviationPoints);
   trade.SetTypeFillingBySymbol(_Symbol);
   trade.SetAsyncMode(false);

   RefreshSymbolMetrics();

   if(InpSLMode == SL_STRUCT && InpAllowNoSL)
      Print("LW_SMC_CHOCH_OCO_EA: WARNING - SL по структуре может отсутствовать, вход без SL разрешён (InpAllowNoSL=true).");
   if(!InpUseTrailing && !InpUseBreakEven && InpTPPoints <= 0.0)
      Print("LW_SMC_CHOCH_OCO_EA: WARNING - выход не управляется: трейлинг/безубыток выключены и TP=0.");
   if(InpOCOMode == OCO_LIMIT)
      Print("LW_SMC_CHOCH_OCO_EA: OCO_LIMIT - BUY LIMIT ниже цены, SELL LIMIT выше цены (зеркальная геометрия).");

   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   // Отложенные ордера намеренно не удаляем: ими управляет OCO и срок жизни.
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnTick()
  {
   ManageOCO();        // OCO: снятие парного ордера + истечение
   ManageTrailing();   // трейлинг-стоп / безубыток

   datetime bt = (datetime)SeriesInfoInteger(_Symbol, PERIOD_CURRENT, SERIES_LASTBAR_DATE);
   if(bt == g_lastBarTime)
      return;
   g_lastBarTime = bt;

   RefreshSymbolMetrics();
   ProcessNewBar();
  }

//============================== SYMBOL METRICS ========================
void RefreshSymbolMetrics()
  {
   g_sym.point      = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   g_sym.digits     = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   g_sym.tickSize   = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   if(g_sym.tickSize <= 0.0)
      g_sym.tickSize = g_sym.point;
   g_sym.tickValue  = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   g_sym.volMin     = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   g_sym.volMax     = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   g_sym.volStep    = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   g_sym.stopsLevel = (double)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL)  * g_sym.point;
   g_sym.freezeLevel= (double)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_FREEZE_LEVEL) * g_sym.point;
   g_sym.valid      = (g_sym.point > 0.0);
  }

//============================== MAIN LOGIC ===========================
void ProcessNewBar()
  {
   if(!g_sym.valid)
      return;

   SChochEvent ev;
   if(!FindLastCHoCH(ev))
      return;                                  // в окне анализа CHoCH нет

   if(g_lastSignalTime == 0)
     {
      if(!InpTradeExistingSignal)
        {
         g_lastSignalTime = ev.time;           // сигналы до старта EA не торгуем
         if(InpVerboseLog)
            PrintFormat("LW_SMC_CHOCH_OCO_EA: старт, CHoCH %s пропущен (InpTradeExistingSignal=false)",
                        TimeToString(ev.time, TIME_DATE | TIME_MINUTES));
         return;
        }
     }
   else
      if(ev.time == g_lastSignalTime)
         return;                               // этот CHoCH уже обработан

   g_lastSignalTime = ev.time;

   if(!IsTradeAllowed())
      return;

   if(InpOneSetupAtATime && CountOurPositions() > 0)
     {
      if(InpVerboseLog)
         PrintFormat("LW_SMC_CHOCH_OCO_EA: CHoCH %s пропущен - открыта позиция",
                     TimeToString(ev.time, TIME_DATE | TIME_MINUTES));
      return;
     }

   if(InpCancelOnNewSignal)
      CancelAllOurPendings();

   if(InpMaxSpreadPoints > 0)
     {
      double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      if(ask > 0.0 && bid > 0.0)
        {
         double spreadPts = (ask - bid) / g_sym.point;
         if(spreadPts > InpMaxSpreadPoints)
           {
            PrintFormat("LW_SMC_CHOCH_OCO_EA: CHoCH %s пропущен - спред %.1f > %.1f пт",
                        TimeToString(ev.time, TIME_DATE | TIME_MINUTES), spreadPts, (double)InpMaxSpreadPoints);
            return;
           }
        }
     }

   PlaceOCO(ev);
  }

//+------------------------------------------------------------------+
//| Поиск последнего CHoCH на закрытых барах                          |
//| (логика BOS/CHoCH повторяет индикатор LW_MarketStructure_SMC)      |
//+------------------------------------------------------------------+
bool FindLastCHoCH(SChochEvent &ev)
  {
   int need = InpMaxBars + InpSwingN * 2 + 10;

   MqlRates rates[];
   ArraySetAsSeries(rates, false);
   int n = CopyRates(_Symbol, PERIOD_CURRENT, 0, need, rates);
   if(n < InpSwingN * 2 + 10)
      return false;

   int last = n - 2;                        // последний ЗАКРЫТЫЙ бар (без repaint)
   if(last < InpSwingN * 2)
      return false;

   int start = (int)MathMax((double)InpSwingN, (double)(last - InpMaxBars + 1));

//--- Pass 1: фрактальные swing-экстремумы (как в индикаторе)
   char sh[], sl[];
   ArrayResize(sh, n);
   ArrayResize(sl, n);
   ArrayInitialize(sh, 0);
   ArrayInitialize(sl, 0);

   for(int i = start; i <= last - InpSwingN; i++)
     {
      bool isHigh = true, isLow = true;
      for(int k = 1; k <= InpSwingN; k++)
        {
         if(rates[i].high <= rates[i - k].high || rates[i].high <= rates[i + k].high)
            isHigh = false;
         if(rates[i].low  >= rates[i - k].low  || rates[i].low  >= rates[i + k].low)
            isLow  = false;
        }
      if(isHigh)
         sh[i] = 1;
      if(isLow)
         sl[i] = 1;
     }

//--- Pass 2: BOS / CHoCH
   bool   found = false;
   int    trend = 0;                        //  1 = up, -1 = down, 0 = neutral
   double refHigh = 0.0, refLow = 0.0;
   int    refHighBar = -1, refLowBar = -1;
   bool   haveHigh = false, haveLow = false;

   for(int i = start + InpSwingN; i <= last; i++)
     {
      int j = i - InpSwingN;                // swing подтверждён на баре j

      if(sh[j] == 1)
        {
         refHigh    = rates[j].high;
         refHighBar = j;
         haveHigh   = true;
        }
      if(sl[j] == 1)
        {
         refLow    = rates[j].low;
         refLowBar = j;
         haveLow   = true;
        }

      double upPx   = InpBreakOnClose ? rates[i].close : rates[i].high;
      double downPx = InpBreakOnClose ? rates[i].close : rates[i].low;

      if(haveHigh && upPx > refHigh)         // бычий пробой
        {
         bool isBOS = (trend != -1);         // против нисходящего тренда = CHoCH
         if(!isBOS)
           {
            ev.time     = rates[i].time;
            ev.dir      = 1;
            ev.level    = refHigh;
            ev.oppLevel = refLow;
            ev.oppValid = haveLow;
            found       = true;
           }
         trend    = 1;
         haveHigh = false;                   // уровень израсходован
        }
      else
         if(haveLow && downPx < refLow)      // медвежий пробой
           {
            bool isBOS = (trend != 1);       // против восходящего тренда = CHoCH
            if(!isBOS)
              {
               ev.time     = rates[i].time;
               ev.dir      = -1;
               ev.level    = refLow;
               ev.oppLevel = refHigh;
               ev.oppValid = haveHigh;
               found       = true;
              }
            trend   = -1;
            haveLow = false;
           }
     }

   return found;
  }

//============================== OCO PLACEMENT ========================
void PlaceOCO(const SChochEvent &ev)
  {
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   if(ask <= 0.0 || bid <= 0.0)
      return;

   g_ticketBuy  = 0;                        // новая группа: старые танкеты недействительны
   g_ticketSell = 0;

   double point   = g_sym.point;
   double minDist = MathMax(g_sym.stopsLevel, g_sym.point);
   double off     = InpOffsetPoints * point;
   if(off < minDist)                        // соблюдаем Stops Level
      off = minDist;

   double buyPx, sellPx;
   if(InpOCOMode == OCO_STOP)
     {
      buyPx  = ask + off;                   // BUY STOP выше цены
      sellPx = bid - off;                   // SELL STOP ниже цены
     }
   else
     {
      buyPx  = ask - off;                   // BUY LIMIT ниже цены
      sellPx = bid + off;                   // SELL LIMIT выше цены
     }
   buyPx  = NormalizeDouble(buyPx,  g_sym.digits);
   sellPx = NormalizeDouble(sellPx, g_sym.digits);

   string cmt = "CHOCH_" + (string)(long)ev.time;

//--- BUY сторона
   double buySL = 0.0;
   bool   buySLok = BuildSL(1, buyPx, ev, buySL);
   if(buySLok || InpAllowNoSL)
     {
      double buyTP = BuildTP(1, buyPx);
      double lot   = CalcLot(buyPx, buySL);
      if(lot > 0.0)
        {
         bool ok = (InpOCOMode == OCO_STOP)
                   ? trade.BuyStop(lot, buyPx, _Symbol, buySL, buyTP, ORDER_TIME_GTC, 0, cmt)
                   : trade.BuyLimit(lot, buyPx, _Symbol, buySL, buyTP, ORDER_TIME_GTC, 0, cmt);
         if(ok && trade.ResultRetcode() == TRADE_RETCODE_DONE)
           {
            g_ticketBuy = trade.ResultOrder();
            if(InpVerboseLog)
               PrintFormat("LW_SMC_CHOCH_OCO_EA: %s BUY %.2f @ %.5f SL %.5f TP %.5f #%I64u",
                           (InpOCOMode == OCO_STOP ? "BUY STOP" : "BUY LIMIT"),
                           lot, buyPx, buySL, buyTP, g_ticketBuy);
           }
         else
            PrintFormat("LW_SMC_CHOCH_OCO_EA: BUY pending failed: %d %s",
                        trade.ResultRetcode(), trade.ResultComment());
        }
     }
   else
      PrintFormat("LW_SMC_CHOCH_OCO_EA: BUY ордер не выставлен - нет валидного SL (структура и резерв = 0)");

//--- SELL сторона
   double sellSL = 0.0;
   bool   sellSLok = BuildSL(-1, sellPx, ev, sellSL);
   if(sellSLok || InpAllowNoSL)
     {
      double sellTP = BuildTP(-1, sellPx);
      double lot    = CalcLot(sellPx, sellSL);
      if(lot > 0.0)
        {
         bool ok = (InpOCOMode == OCO_STOP)
                   ? trade.SellStop(lot, sellPx, _Symbol, sellSL, sellTP, ORDER_TIME_GTC, 0, cmt)
                   : trade.SellLimit(lot, sellPx, _Symbol, sellSL, sellTP, ORDER_TIME_GTC, 0, cmt);
         if(ok && trade.ResultRetcode() == TRADE_RETCODE_DONE)
           {
            g_ticketSell = trade.ResultOrder();
            if(InpVerboseLog)
               PrintFormat("LW_SMC_CHOCH_OCO_EA: %s SELL %.2f @ %.5f SL %.5f TP %.5f #%I64u",
                           (InpOCOMode == OCO_STOP ? "SELL STOP" : "SELL LIMIT"),
                           lot, sellPx, sellSL, sellTP, g_ticketSell);
           }
         else
            PrintFormat("LW_SMC_CHOCH_OCO_EA: SELL pending failed: %d %s",
                        trade.ResultRetcode(), trade.ResultComment());
        }
     }
   else
      PrintFormat("LW_SMC_CHOCH_OCO_EA: SELL ордер не выставлен - нет валидного SL (структура и резерв = 0)");

   if(InpVerboseLog)
      PrintFormat("LW_SMC_CHOCH_OCO_EA: CHoCH %s (%s) level %.5f -> OCO %s",
                  TimeToString(ev.time, TIME_DATE | TIME_MINUTES),
                  (ev.dir > 0 ? "bullish" : "bearish"), ev.level,
                  (InpOCOMode == OCO_STOP ? "stops" : "limits"));
  }

//============================== SL / TP ==============================
//+------------------------------------------------------------------+
//| SL: фиксированный или по структуре.                               |
//| Для BUY берём опору НИЖЕ входа, для SELL — ВЫШЕ входа;            |
//| из валидных опор (пробитый swing и противоположный swing)         |
//| выбираем ближнюю (тейтовую) или дальнюю (широкую) по InpSLAnchor. |
//| Если валидной опоры нет — резервный SL в пунктах (если задан).    |
//+------------------------------------------------------------------+
//| Ограничение ширины SL: если структурная опора слишком далеко,     |
//| SL подрезается до InpMaxSLPoints.                                 |
//+------------------------------------------------------------------+
double CapSL(const int dir, const double entry, const double sl)
  {
   if(InpMaxSLPoints <= 0.0 || sl <= 0.0)
      return sl;

   double maxD = InpMaxSLPoints * g_sym.point;
   if(MathAbs(entry - sl) <= maxD)
      return sl;

   return (dir > 0) ? (entry - maxD) : (entry + maxD);
  }

//+------------------------------------------------------------------+
bool BuildSL(const int dir, const double entry, const SChochEvent &ev, double &sl)
  {
   sl = 0.0;
   double point   = g_sym.point;
   double minDist = MathMax(g_sym.stopsLevel, g_sym.point);

   if(InpSLMode == SL_FIXED)
     {
      double d = InpSLPoints * point;
      if(d < minDist)
         d = minDist;
      sl = (dir > 0) ? entry - d : entry + d;
      sl = NormalizeDouble(sl, g_sym.digits);
      return true;
     }

   double anchors[2];
   int    cnt = 0;
   if(ev.level > 0.0)
      anchors[cnt++] = ev.level;
   if(ev.oppValid && ev.oppLevel > 0.0)
      anchors[cnt++] = ev.oppLevel;

   double buf   = InpSLBufferPoints * point;
   bool   found = false;

   for(int k = 0; k < cnt; k++)
     {
      double cand = (dir > 0) ? (anchors[k] - buf) : (anchors[k] + buf);

      if(dir > 0)
        {
         if(cand > entry - minDist)          // опора выше/слишком близко к входу
            continue;
         if(!found || (InpSLAnchor == SL_ANCHOR_FAR ? (cand < sl) : (cand > sl)))
           {
            sl    = cand;
            found = true;
           }
        }
      else
        {
         if(cand < entry + minDist)
            continue;
         if(!found || (InpSLAnchor == SL_ANCHOR_FAR ? (cand > sl) : (cand < sl)))
           {
            sl    = cand;
            found = true;
           }
        }
     }

   if(!found)
     {
      // Структурной опоры нет (цена уже ушла от swing): резервный SL в пунктах.
      if(InpSLFallbackPoints <= 0.0)
         return false;
      double d = InpSLFallbackPoints * point;
      if(d < minDist)
         d = minDist;
      sl = CapSL(dir, entry, (dir > 0) ? entry - d : entry + d);
      sl = NormalizeDouble(sl, g_sym.digits);
      return true;
     }

   sl = CapSL(dir, entry, sl);
   sl = NormalizeDouble(sl, g_sym.digits);
   return true;
  }

//+------------------------------------------------------------------+
double BuildTP(const int dir, const double entry)
  {
   if(InpTPPoints <= 0.0)
      return 0.0;
   double d = InpTPPoints * g_sym.point;
   double tp = (dir > 0) ? entry + d : entry - d;
   return NormalizeDouble(tp, g_sym.digits);
  }

//============================== SIZING ===============================
double NormalizeLot(double lot)
  {
   double step = (g_sym.volStep > 0.0) ? g_sym.volStep : 0.01;
   lot = MathRound(lot / step) * step;
   if(lot < g_sym.volMin)
      lot = g_sym.volMin;
   if(lot > g_sym.volMax)
      lot = g_sym.volMax;
   return NormalizeDouble(lot, 3);
  }

//+------------------------------------------------------------------+
double CalcLot(const double entry, const double sl)
  {
   if(!InpUseRiskPercent || sl <= 0.0)
      return NormalizeLot(InpLot);

   double slDist = MathAbs(entry - sl);
   if(slDist <= 0.0 || g_sym.tickSize <= 0.0 || g_sym.tickValue <= 0.0)
      return NormalizeLot(InpLot);

   double balance    = AccountInfoDouble(ACCOUNT_BALANCE);
   double riskMoney  = balance * InpRiskPercent / 100.0;
   double lossPerLot = (slDist / g_sym.tickSize) * g_sym.tickValue;
   if(lossPerLot <= 0.0)
      return NormalizeLot(InpLot);

   return NormalizeLot(riskMoney / lossPerLot);
  }

//============================== OCO MANAGEMENT ======================
int CollectOurPendings(ulong &tickets[])
  {
   ArrayResize(tickets, 0);
   int cnt = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      ulong ticket = OrderGetTicket(i);
      if(ticket == 0)
         continue;
      if(!IsOurPending(ticket))
         continue;
      cnt++;
      ArrayResize(tickets, cnt);
      tickets[cnt - 1] = ticket;
     }
   return cnt;
  }

//+------------------------------------------------------------------+
bool IsOurPending(const ulong ticket)
  {
   if(ticket == 0)
      return false;
   if(!OrderSelect(ticket))
      return false;
   if(OrderGetString(ORDER_SYMBOL) != _Symbol)
      return false;
   if(OrderGetInteger(ORDER_MAGIC) != InpMagic)
      return false;

   ENUM_ORDER_TYPE t = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
   return (t == ORDER_TYPE_BUY_LIMIT      || t == ORDER_TYPE_SELL_LIMIT ||
           t == ORDER_TYPE_BUY_STOP       || t == ORDER_TYPE_SELL_STOP  ||
           t == ORDER_TYPE_BUY_STOP_LIMIT || t == ORDER_TYPE_SELL_STOP_LIMIT);
  }

//+------------------------------------------------------------------+
int CountOurPositions()
  {
   int cnt = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(ticket == 0)
         continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol)
         continue;
      if(PositionGetInteger(POSITION_MAGIC) != InpMagic)
         continue;
      cnt++;
     }
   return cnt;
  }

//+------------------------------------------------------------------+
bool GroupHasPosition(const string grp)
  {
   if(grp == "")
      return false;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(ticket == 0)
         continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol)
         continue;
      if(PositionGetInteger(POSITION_MAGIC) != InpMagic)
         continue;
      if(PositionGetString(POSITION_COMMENT) == grp)
         return true;
     }
   return false;
  }

//+------------------------------------------------------------------+
void DeletePending(const ulong ticket)
  {
   if(ticket == 0)
      return;
   if(!IsOurPending(ticket))
      return;                                // ордер уже исполнен/снят — не трогаем
   if(!trade.OrderDelete(ticket))
      PrintFormat("LW_SMC_CHOCH_OCO_EA: OrderDelete #%I64u failed: %d %s",
                  ticket, trade.ResultRetcode(), trade.ResultComment());
   else
      if(InpVerboseLog)
         PrintFormat("LW_SMC_CHOCH_OCO_EA: снят отложенный ордер #%I64u (OCO)", ticket);
  }

//+------------------------------------------------------------------+
void CancelAllOurPendings()
  {
   ulong tickets[];
   int cnt = CollectOurPendings(tickets);
   for(int k = 0; k < cnt; k++)
      DeletePending(tickets[k]);
  }

//+------------------------------------------------------------------+
void ManageOCO()
  {
//--- (a) точная связка по тикетам текущего сетапа: сработал один -> снять второй
   if(g_ticketBuy != 0 && g_ticketSell != 0)
     {
      bool buyFilled  = PositionSelectByTicket(g_ticketBuy);
      bool sellFilled = PositionSelectByTicket(g_ticketSell);
      if(buyFilled && !sellFilled)
        {
         DeletePending(g_ticketSell);
         g_ticketSell = 0;
        }
      else
         if(sellFilled && !buyFilled)
           {
            DeletePending(g_ticketBuy);
            g_ticketBuy = 0;
           }
     }

   ulong tickets[];
   int cnt = CollectOurPendings(tickets);
   if(cnt == 0)
      return;

//--- (b)/(c)/(d) страховки и срок жизни
   for(int k = 0; k < cnt; k++)
     {
      ulong ticket = tickets[k];
      if(!OrderSelect(ticket))
         continue;

      string grp = OrderGetString(ORDER_COMMENT);

      // (b) по группе уже открыта позиция -> это исполненный OCO, снимаем остаток
      if(GroupHasPosition(grp))
        {
         DeletePending(ticket);
         continue;
        }

      // (c) срок жизни ордера истёк
      if(InpExpireBars > 0)
        {
         datetime setup = (datetime)OrderGetInteger(ORDER_TIME_SETUP);
         if(TimeCurrent() - setup >= (long)InpExpireBars * PeriodSeconds())
           {
            DeletePending(ticket);
            continue;
           }
        }

      // (d) страховка после рестарта EA: позиция есть, а связка неизвестна
      if(InpOneSetupAtATime && CountOurPositions() > 0)
         DeletePending(ticket);
     }
  }

//============================== TRAILING ==============================
void ManageTrailing()
  {
   if(!InpUseTrailing && !InpUseBreakEven)
      return;

   double point  = g_sym.point;
   int    digits = g_sym.digits;
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   if(bid <= 0.0 || ask <= 0.0)
      return;

   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(ticket == 0)
         continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol)
         continue;
      if(PositionGetInteger(POSITION_MAGIC) != InpMagic)
         continue;

      ENUM_POSITION_TYPE pt = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
      double entry = PositionGetDouble(POSITION_PRICE_OPEN);
      double sl    = PositionGetDouble(POSITION_SL);
      double tp    = PositionGetDouble(POSITION_TP);

      double price     = (pt == POSITION_TYPE_BUY) ? bid : ask;
      double profitPts = (pt == POSITION_TYPE_BUY) ? (bid - entry) / point
                                                   : (entry - ask) / point;
      double bestSL    = sl;

      if(pt == POSITION_TYPE_BUY)
        {
         if(InpUseBreakEven && profitPts >= InpBETriggerPoints)
           {
            double be = NormalizeDouble(entry + InpBEBufferPoints * point, digits);
            if(be > bestSL)
               bestSL = be;
           }
         if(InpUseTrailing && profitPts >= InpTrailStartPoints)
           {
            double tr = NormalizeDouble(price - InpTrailDistPoints * point, digits);
            if(tr > bestSL)
               bestSL = tr;
           }

         double maxSL = NormalizeDouble(price - MathMax(g_sym.stopsLevel, point), digits);
         if(bestSL > maxSL)
            bestSL = maxSL;                                        // Stops Level
         if(tp > 0.0 && bestSL > tp - point)
            bestSL = NormalizeDouble(tp - point, digits);          // SL ниже TP
         if(bestSL <= 0.0)
            continue;
         if(sl > 0.0 && bestSL <= sl + InpTrailStepPoints * point)
            continue;                                              // шаг перемещения
         if(sl == 0.0 || bestSL > sl)
            if(!trade.PositionModify(ticket, bestSL, tp))
               PrintFormat("LW_SMC_CHOCH_OCO_EA: BUY SL modify #%I64u failed: %d %s",
                           ticket, trade.ResultRetcode(), trade.ResultComment());
        }
      else
        {
         if(InpUseBreakEven && profitPts >= InpBETriggerPoints)
           {
            double be = NormalizeDouble(entry - InpBEBufferPoints * point, digits);
            if(bestSL == 0.0 || be < bestSL)
               bestSL = be;
           }
         if(InpUseTrailing && profitPts >= InpTrailStartPoints)
           {
            double tr = NormalizeDouble(price + InpTrailDistPoints * point, digits);
            if(bestSL == 0.0 || tr < bestSL)
               bestSL = tr;
           }

         double minSL = NormalizeDouble(price + MathMax(g_sym.stopsLevel, point), digits);
         if(bestSL == 0.0 || bestSL < minSL)
            bestSL = minSL;                                        // Stops Level
         if(tp > 0.0 && bestSL < tp + point)
            bestSL = NormalizeDouble(tp + point, digits);          // SL выше TP
         if(bestSL <= 0.0)
            continue;
         if(sl > 0.0 && bestSL >= sl - InpTrailStepPoints * point)
            continue;                                              // шаг перемещения
         if(sl == 0.0 || bestSL < sl)
            if(!trade.PositionModify(ticket, bestSL, tp))
               PrintFormat("LW_SMC_CHOCH_OCO_EA: SELL SL modify #%I64u failed: %d %s",
                           ticket, trade.ResultRetcode(), trade.ResultComment());
        }
     }
  }

//============================== COMMON ===============================
bool IsTradeAllowed()
  {
   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
     {
      Print("LW_SMC_CHOCH_OCO_EA: trading is disabled in the terminal");
      return false;
     }
   if(!MQLInfoInteger(MQL_TRADE_ALLOWED))
     {
      Print("LW_SMC_CHOCH_OCO_EA: trading is disabled for this EA");
      return false;
     }
   if(!AccountInfoInteger(ACCOUNT_TRADE_ALLOWED))
     {
      Print("LW_SMC_CHOCH_OCO_EA: trading is disabled for this account");
      return false;
     }
   if(!AccountInfoInteger(ACCOUNT_TRADE_EXPERT))
     {
      Print("LW_SMC_CHOCH_OCO_EA: automated trading is disabled for this account");
      return false;
     }
   return true;
  }
//+------------------------------------------------------------------+