Adwizard/Virtual/VirtualSymbolReceiver.mqh

//+------------------------------------------------------------------+
//|                                        VirtualSymbolReceiver.mqh |
//|                                 Copyright 2022-2025, Yuriy Bykov |
//|                            https://www.mql5.com/ru/users/antekov |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022-2025, Yuriy Bykov"
#property link      "https://www.mql5.com/ru/users/antekov"
#property version   "1.01"

#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>

#include "../Base/Receiver.mqh"
#include "../Utils/Macros.mqh"
#include "../Utils/SymbolsMonitor.mqh"
#include "Money.mqh"
#include "VirtualOrder.mqh"

//+------------------------------------------------------------------+
//| Класс символьного получателя                                     |
//+------------------------------------------------------------------+
class CVirtualSymbolReceiver : public CReceiver {
   string            m_symbol;         // Символ
   CVirtualOrder*    m_orders[];      // Массив открытых виртуальных позиций

   bool              m_isNetting;      // Это неттинг-счёт?

   double            m_minMargin;      // Минимальная маржа для открытия

   CPositionInfo     m_position;       // Объект для получения свойств рыночных позиций
   CSymbolInfo*      m_symbolInfo;     // Объект для получения свойств символа
   CTrade            m_trade;          // Объект для совершения торговых операций

   double            MarketVolume();   // Объём открытых рыночных позиций
   double            VirtualVolume();  // Объём открытых виртуальных позиций
   bool              IsTradeAllowed(); // Торговля по символу доступна?

   // Необходимая разница объёмов
   double            DiffVolume(double marketVolume, double virtualVolume);

   // Коррекция объема на необходимую разницу
   bool              Correct(double oldVolume, double diffVolume);

   // Вспомогательные методы открытия
   bool              ClearOpen(double diffVolume);
   bool              AddBuy(double volume);
   bool              AddSell(double volume);

   // Вспомогательные методы закрытия
   bool              CloseBuyPartial(double volume);
   bool              CloseSellPartial(double volume);
   bool              CloseHedgingPartial(double volume, ENUM_POSITION_TYPE type);
   bool              CloseFull();

   // Проверка маржинальных требований
   bool              FreeMarginCheck(double volume, ENUM_ORDER_TYPE type);

   double StopLoss(ENUM_POSITION_TYPE type, double volume, double price, double availLoss);

public:
   CVirtualSymbolReceiver(string p_symbol);  // Конструктор
   bool              operator==(const string symbol) {// Оператор сравнения по имени символа
      return m_symbol == symbol;
   }
   void              Open(CVirtualOrder *p_order);    // Регистрация открытия виртуальной позиции
   void              Close(CVirtualOrder *p_order);   // Регистрация закрытия виртуальной позиции

   virtual bool      Correct() override;              // Корректировка открытых объёмов
   virtual bool      CorrectSL(ulong ticket, double availLoss);
   static   double            s_slPercent;
   static   double            s_tpPercent;

   double m_marketVolume;
};

double CVirtualSymbolReceiver::s_slPercent = 0;
double CVirtualSymbolReceiver::s_tpPercent = 0;


//+------------------------------------------------------------------+
//| Конструктор                                                      |
//+------------------------------------------------------------------+
CVirtualSymbolReceiver::CVirtualSymbolReceiver(string p_symbol) :
   m_symbol(p_symbol),
   m_minMargin(100) {
   m_symbolInfo = CSymbolsMonitor::Instance()[m_symbol];
   ArrayResize(m_orders, 0, 128);
   m_trade.SetExpertMagicNumber(s_magic);
   s_slPercent = CVirtualReceiver::s_slPercent;
   s_tpPercent = CVirtualReceiver::s_tpPercent;
}

//+------------------------------------------------------------------+
//| Регистрация открытия виртуальной позиции                         |
//+------------------------------------------------------------------+
void CVirtualSymbolReceiver::Open(CVirtualOrder *p_order) {
   APPEND(m_orders, p_order); // Добавляем позицию в массив
   m_isChanged = true;        // Устанавливаем флаг изменений
}

//+------------------------------------------------------------------+
//| Регистрация закрытия виртуальной позиции                         |
//+------------------------------------------------------------------+
void CVirtualSymbolReceiver::Close(CVirtualOrder *p_order) {
   REMOVE(m_orders, p_order); // Удаляем позицию из массива
   m_isChanged = true;        // Устанавливаем флаг изменений
}

//+------------------------------------------------------------------+
//| Корректировка открытых объёмов                                   |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::Correct() {
   bool res = true;
   if(m_isChanged && IsTradeAllowed()) {
      double marketVolume = MarketVolume();
      double virtualVolume = VirtualVolume();
      double diffVolume = DiffVolume(marketVolume, virtualVolume);

      // Если есть необходимость коррекции объема, то выполняем её
      if(MathAbs(diffVolume) > 0.001) {
         res = Correct(marketVolume, diffVolume);
         if(res) {
            PrintFormat(__FUNCTION__"#%s | CORRECTED %.2f -> %.2f", m_symbol, marketVolume, virtualVolume);
         }
      }
      //res &= CorrectSL();

      m_isChanged = !res;
   }
   return res;
};


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CVirtualSymbolReceiver::StopLoss(ENUM_POSITION_TYPE type, double volume, double price, double availLoss) {
   if(price == 0.0) {
      price = (type == POSITION_TYPE_BUY ?
               SymbolInfoDouble(m_symbol, SYMBOL_BID)
               : SymbolInfoDouble(m_symbol, SYMBOL_ASK));
   }
   double tickValue = m_symbolInfo.TickValueLoss();
   double point = m_symbolInfo.Point();
   double sl = availLoss / (tickValue * volume) * point;
   if(sl > point) {
      if(type == POSITION_TYPE_BUY) {
         sl = price - sl;
      } else if(type == POSITION_TYPE_SELL) {
         sl = price + sl;
      }
   }
   return NormalizeDouble(sl, m_symbolInfo.Digits());
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::CorrectSL(ulong ticket, double availLoss) {
   bool res = true;
   CPositionInfo p;

   if(p.SelectByTicket(ticket)) {
      string symbol = p.Symbol();
      ulong magic = p.Magic();

      if(magic == s_magic && symbol == m_symbol) {
         ENUM_POSITION_TYPE type = p.PositionType();
         double bid = m_symbolInfo.Bid();
         double ask = m_symbolInfo.Ask();
         double sl = StopLoss(type, p.Volume(), p.PriceOpen(), availLoss);
         double stopLoss = p.StopLoss();
         double point = m_symbolInfo.Point();

         if(MathAbs(sl - stopLoss) > point * 0.5) {
            if((type == POSITION_TYPE_BUY && sl > bid) || (type == POSITION_TYPE_SELL && sl < ask)) {
               res = m_trade.PositionClose(p.Ticket());
               if(res) {
                  PrintFormat(__FUNCTION__" | CLOSE for SET SL: %s [#%I64u] %.5f -> %.5f", m_symbol, p.Ticket(), stopLoss, sl);
               } else {
                  PrintFormat(__FUNCTION__" | ERROR CLOSE for SET SL: %.5f -> %.5f, code: %d", stopLoss, sl, GetLastError());
               }
            } else {
               res = m_trade.PositionModify(p.Ticket(), sl, p.TakeProfit());
               if(res) {
                  PrintFormat(__FUNCTION__" | SET SL: %s [#%I64u] %.5f -> %.5f", m_symbol, p.Ticket(), stopLoss, sl);
               } else {
                  PrintFormat(__FUNCTION__" | ERROR SET SL: %.5f -> %.5f, code: %d", stopLoss, sl, GetLastError());
               }
            }
         }

      }

   }

   return res;
}

//+------------------------------------------------------------------+
//| Объём открытых рыночных позиций                                  |
//+------------------------------------------------------------------+
double CVirtualSymbolReceiver::MarketVolume() {
   double volume = 0;
   string symbol;
   ulong magic;
   int type;

   CPositionInfo p;

   for(int i = 0; i < PositionsTotal(); i++) {
      if(p.SelectByIndex(i)) {
         symbol = p.Symbol();
         magic = p.Magic();
         type = (int) p.PositionType();

         if(magic == s_magic && symbol == m_symbol) {
            volume += p.Volume() * (-(type) * 2 + 1);
         }
      }
   }
   return volume;
}

//+------------------------------------------------------------------+
//| Объём открытых витруальных позиций                               |
//+------------------------------------------------------------------+
double CVirtualSymbolReceiver::VirtualVolume() {
   double volume = 0;
   FOREACH(m_orders) volume += CMoney::Volume(m_orders[i]);
   return volume;
}

//+------------------------------------------------------------------+
//| Торговля по символу доступна?                                    |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::IsTradeAllowed() {
   return (true
           && m_minMargin > 0
           && m_symbolInfo.TradeMode() == SYMBOL_TRADE_MODE_FULL
          );
}

//+------------------------------------------------------------------+
//| Необходимая разница объёмов                                      |
//+------------------------------------------------------------------+
double CVirtualSymbolReceiver::DiffVolume(double marketVolume, double virtualVolume) {
// Получаем граничные значения допустимых объмов
   double minLot = MathMax(0.01, m_symbolInfo.LotsMin());
   double maxLot = m_symbolInfo.LotsMax();
   double lotStep = MathMax(0.01, m_symbolInfo.LotsStep());

// Находим, на сколько надо изменить объём открытых позиций по символу
   double oldVolume = marketVolume;
   double newVolume = virtualVolume;
   int ratio = 0;

// Проверяем, что новый объем укладывается в допустимые рамки
   if(MathAbs(newVolume) > maxLot) {
      newVolume = maxLot * MathAbs(newVolume) / newVolume;
   }

   if(MathAbs(newVolume) < minLot && MathAbs(newVolume) > 0) {
      if(MathAbs(newVolume) < 0.5 * minLot) {
         newVolume = 0;
      } else {
         newVolume = minLot * MathAbs(newVolume) / newVolume;
      }
   }
// На сколько надо изменить открытый объем
   double diffVolume = newVolume - oldVolume;
   int digits = 2;

   if (lotStep >= 0.1 && lotStep < 1.0) {
      digits = 1;
   } else if (lotStep >= 1.0) {
      digits = 0;
   }

   if(oldVolume == 0) {
      if (minLot >= 0.1 && lotStep < 1.0) {
         digits = 1;
      } else if (minLot >= 1.0) {
         digits = 0;
      }
   }

   diffVolume = NormalizeDouble(diffVolume, digits);

   ratio = (int) MathRound(MathAbs(diffVolume) / lotStep);
   if(MathAbs(ratio * lotStep - MathAbs(diffVolume)) > 0.0000001) {
      diffVolume = ratio * lotStep * MathAbs(diffVolume) / diffVolume;
   }

   return diffVolume;
}

//+------------------------------------------------------------------+
//| Коррекция объема на необходимую разницу                          |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::Correct(double oldVolume, double diffVolume) {
   bool res = false;

   double volume = MathAbs(diffVolume);

   if(oldVolume > 0) { // Have BUY position
      if(diffVolume > 0) { // New BUY position
         res = AddBuy(volume);
      } else if(diffVolume < 0) { // New SELL position
         if(volume < oldVolume) {
            res = CloseBuyPartial(volume);
         } else {
            res = CloseFull();

            if(res && volume > oldVolume) {
               res = AddSell(volume - oldVolume);
            }
         }
      }
   } else if(oldVolume < 0) { // Have SELL position
      if(diffVolume < 0) { // New SELL position
         res = AddSell(volume);
      } else if(diffVolume > 0) { // New BUY position
         if(volume < -oldVolume) {
            res = CloseSellPartial(volume);
         } else {
            res = CloseFull();

            if(res && volume > -oldVolume) {
               res = AddBuy(volume + oldVolume);
            }
         }
      }
   } else { // No old position
      res = ClearOpen(diffVolume);
   }

   return res;
}

//+------------------------------------------------------------------+
//| Открытие рыночной позиции BUY или SELL                           |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::ClearOpen(double diffVolume) {
   double volume = MathAbs(diffVolume);
   double minLot = MathAbs(m_symbolInfo.LotsMin());

   if(minLot < 1e-12 || volume < minLot) {
      return true;
   }

   bool res = true;
   ENUM_ORDER_TYPE type = (diffVolume > 0 ? ORDER_TYPE_BUY : ORDER_TYPE_SELL);

   if(FreeMarginCheck(volume, type)) {
      double sl = 0;
      PrintFormat(__FUNCTION__"#%s | OPEN %s %.2f, sl=%.5f", m_symbol, (diffVolume > 0 ? "BUY" : "SELL"), volume, sl);

      if(diffVolume > 0) {
         res = m_trade.Buy(volume, m_symbol, 0, sl);
      } else {
         res = m_trade.Sell(volume, m_symbol, 0, sl);
      }

      if(!res) {
         PrintFormat(__FUNCTION__"#%s | ERROR: %d, Result Code: %d", m_symbol, _LastError, m_trade.ResultRetcode());
      }
   }

   return res;
}

//+------------------------------------------------------------------+
//| Открытие дополнительного объёма BUY                              |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::AddBuy(double volume) {
   return ClearOpen(volume);
}

//+------------------------------------------------------------------+
//| Открытие дополнительного объёма SELL                                                                 |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::AddSell(double volume) {
   return ClearOpen(-volume);
}

//+------------------------------------------------------------------+
//| Частичное закрытие объёма BUY по символу                         |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::CloseBuyPartial(double volume) {
   bool res = true;

   PrintFormat(__FUNCTION__"#%s | CLOSE BUY partial | volume = %.2f", m_symbol, volume);

   if(volume > 0) {
      if(m_isNetting) {
         res = m_trade.Sell(volume, m_symbol, 0, 0, 0);
      } else {
         res = CloseHedgingPartial(volume, POSITION_TYPE_BUY);
      }
      //res &= CorrectSL();
   }

   if(!res) {
      PrintFormat(__FUNCTION__"#%s | ERROR: %d, Result Code: %d", m_symbol, _LastError, m_trade.ResultRetcode());
      ResetLastError();
   }
   return res;
}

//+------------------------------------------------------------------+
//| Частичное закрытие объёма SELL по символу                        |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::CloseSellPartial(double volume) {
   bool res = true;

   PrintFormat(__FUNCTION__"#%s | CLOSE SELL partial | volume = %.2f", m_symbol, volume);

   if(volume > 0) {
      if(m_isNetting) {
         res &= m_trade.Buy(volume, m_symbol, 0, 0, 0);
      } else {
         res &= CloseHedgingPartial(volume, POSITION_TYPE_SELL);
      }
   }

   if(!res) {
      PrintFormat(__FUNCTION__"#%s | ERROR: %d, Result Code: %d", m_symbol, _LastError, m_trade.ResultRetcode());
      ResetLastError();
   }
   return res;
}

//+------------------------------------------------------------------+
//| Частичное закрытие BUY или SELL по символу на счете Hedge        |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::CloseHedgingPartial(double volume, ENUM_POSITION_TYPE type) {
   bool res = true;

   ulong ticket;
   double positionVolume;

   for(int i = 0; i < PositionsTotal(); i++) {
      if (m_position.SelectByIndex(i)) {
         ticket = m_position.Ticket();

         if(m_position.Magic() == s_magic && m_position.Symbol() == m_symbol && m_position.PositionType() == type) {
            positionVolume = m_position.Volume();

            if(volume > 0) {
               if(positionVolume <= volume) {
                  res &= m_trade.PositionClose(ticket);
                  volume -= positionVolume;
               } else {
                  res &= m_trade.PositionClosePartial(ticket, volume);
                  volume = 0;
                  break;
               }
            } else {
               break;
            }
         }
      }
   }

   if(volume > 0) {
      res = false;
   }
   return res;
}

//+------------------------------------------------------------------+
//| Полное закрытие объёма по символу                                |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::CloseFull() {
   bool res = true;

   ulong ticket;
   bool found = true;

   while(found && !IsStopped()) {
      found = false;
      for(int i = 0; i < PositionsTotal(); i++) {
         if (m_position.SelectByIndex(i)) {
            if(m_position.Magic() == s_magic && (m_position.Symbol() == m_symbol)) {
               found = true;
               ticket = m_position.Ticket();
               res &= m_trade.PositionClose(ticket);
               break;
            }
         }
      }
      if(!res) {
         found = false;
      }
   }
   return res;
}

//+------------------------------------------------------------------+
//| Проверка маржинальных требований                                 |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::FreeMarginCheck(double volume, ENUM_ORDER_TYPE type) {
   double freeMarginLevel = AccountInfoDouble(ACCOUNT_MARGIN_LEVEL);

   if (freeMarginLevel != 0 && freeMarginLevel < m_minMargin) {
      PrintFormat(__FUNCTION__" | Margin level (%.2f) is less than minimum required (%.2f)",
                  freeMarginLevel, m_minMargin);
      return false;
   }

#ifdef __MQL4__
   double free_margin = AccountFreeMarginCheck(m_symbol, type, volume);
//-- если денег не хватает
   if(free_margin < 0) {
      PrintFormat(__FUNCTION__" | ERROR: Not enough money for %s %.2f, %s",
                  (type == OP_BUY) ? "BUY" : "SELL", volume, m_symbol);
      return(false);
   }
//-- проверка прошла успешно
   return(true);
#endif

#ifdef __MQL5__
//--- получим цену открытия
   MqlTick mqltick;
   SymbolInfoTick(m_symbol, mqltick);
   double price = mqltick.ask;
   if(type == ORDER_TYPE_SELL) {
      price = mqltick.bid;
   }
//--- значения необходимой и свободной маржи
   double margin, free_margin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
//--- вызовем функцию проверки
   if(!OrderCalcMargin(type, m_symbol, volume, price, margin)) {
      //--- что-то пошло не так, сообщим и вернем false
      PrintFormat(__FUNCTION__" | ERROR: Can't calc margin via OrderCalcMargin(), code=%d", GetLastError());
      return(false);
   }
//--- если не хватает средств на проведение операции
   if(margin > free_margin) {
      //--- сообщим об ошибке и вернем false
      PrintFormat(__FUNCTION__" | ERROR: Not enough money for %s %.2f, %s",
                  (type == ORDER_TYPE_BUY) ? "BUY" : "SELL", volume, m_symbol);
      return(false);
   }
//--- проверка прошла успешно
   return(true);
#endif
}
//+------------------------------------------------------------------+