Adwizard/Virtual/VirtualSymbolReceiver.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+
//|                                        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.00"

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

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

//+------------------------------------------------------------------+
//| ;0AA A8<2>;L=>3> ?>;CG0B5;O                                     |
//+------------------------------------------------------------------+
class CVirtualSymbolReceiver : public CReceiver {
   string            m_symbol;         // !8<2>;
   CVirtualOrder     *m_orders[];      // 0AA82 >B:@KBKE 28@BC0;L=KE ?>78F89
   
   bool              m_isNetting;      // -B> =5BB8=3-AGQB?

   double            m_minMargin;      // 8=8<0;L=0O <0@60 4;O >B:@KB8O

   CPositionInfo     m_position;       // 1J5:B 4;O ?>;CG5=8O A2>9AB2 @K=>G=KE ?>78F89
   CSymbolInfo       m_symbolInfo;     // 1J5:B 4;O ?>;CG5=8O A2>9AB2 A8<2>;0
   CTrade            m_trade;          // 1J5:B 4;O A>25@H5=8O B>@3>2KE >?5@0F89

   double            MarketVolume();   // 1JQ< >B:@KBKE @K=>G=KE ?>78F89
   double            VirtualVolume();  // 1JQ< >B:@KBKE 28@BC0;L=KE ?>78F89
   bool              IsTradeAllowed(); // ">@3>2;O ?> A8<2>;C 4>ABC?=0?

   // 5>1E>48<0O @07=8F0 >1JQ<>2
   double            DiffVolume(double marketVolume, double virtualVolume);

   // >@@5:F8O >1J5<0 =0 =5>1E>48<CN @07=8FC
   bool              Correct(double oldVolume, double diffVolume);

   // A?><>30B5;L=K5 <5B>4K >B:@KB8O
   bool              ClearOpen(double diffVolume);
   bool              AddBuy(double volume);
   bool              AddSell(double volume);

   // A?><>30B5;L=K5 <5B>4K 70:@KB8O
   bool              CloseBuyPartial(double volume);
   bool              CloseSellPartial(double volume);
   bool              CloseHedgingPartial(double volume, ENUM_POSITION_TYPE type);
   bool              CloseFull();

   // @>25@:0 <0@68=0;L=KE B@51>20=89
   bool              FreeMarginCheck(double volume, ENUM_ORDER_TYPE type);

public:
                     CVirtualSymbolReceiver(string p_symbol);  // >=AB@C:B>@
   bool              operator==(const string symbol) {// ?5@0B>@ A@02=5=8O ?> 8<5=8 A8<2>;0
      return m_symbol == symbol;
   }
   void              Open(CVirtualOrder *p_order);    //  538AB@0F8O >B:@KB8O 28@BC0;L=>9 ?>78F88
   void              Close(CVirtualOrder *p_order);   //  538AB@0F8O 70:@KB8O 28@BC0;L=>9 ?>78F88

   virtual bool      Correct() override;              // >@@5:B8@>2:0 >B:@KBKE >1JQ<>2
};


//+------------------------------------------------------------------+
//| >=AB@C:B>@                                                      |
//+------------------------------------------------------------------+
CVirtualSymbolReceiver::CVirtualSymbolReceiver(string p_symbol) :
   m_symbol(p_symbol),
   m_minMargin(100) {
   if(!m_symbolInfo.Name(m_symbol)) {
      PrintFormat(__FUNCTION__"#%s | ERROR: This symbol not found. Trade operations are disabled.", m_symbol);
      m_minMargin = -1;
   }
   ArrayResize(m_orders, 0, 128);
   m_trade.SetExpertMagicNumber(s_magic);
}

//+------------------------------------------------------------------+
//|  538AB@0F8O >B:@KB8O 28@BC0;L=>9 ?>78F88                         |
//+------------------------------------------------------------------+
void CVirtualSymbolReceiver::Open(CVirtualOrder *p_order) {
   APPEND(m_orders, p_order); // >102;O5< ?>78F8N 2 <0AA82
   m_isChanged = true;        // #AB0=02;8205< D;03 87<5=5=89
}

//+------------------------------------------------------------------+
//|  538AB@0F8O 70:@KB8O 28@BC0;L=>9 ?>78F88                         |
//+------------------------------------------------------------------+
void CVirtualSymbolReceiver::Close(CVirtualOrder *p_order) {
   REMOVE(m_orders, p_order); // #40;O5< ?>78F8N 87 <0AA820
   m_isChanged = true;        // #AB0=02;8205< D;03 87<5=5=89
}

//+------------------------------------------------------------------+
//| >@@5:B8@>2:0 >B:@KBKE >1JQ<>2                                   |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::Correct() {
   bool res = true;
   if(m_isChanged && IsTradeAllowed()) {
      double marketVolume = MarketVolume();
      double virtualVolume = VirtualVolume();
      double diffVolume = DiffVolume(marketVolume, virtualVolume);

      // A;8 5ABL =5>1E>48<>ABL :>@@5:F88 >1J5<0, B> 2K?>;=O5< 5Q
      if(MathAbs(diffVolume) > 0.001) {
         res = Correct(marketVolume, diffVolume);
         if(res) {
            PrintFormat(__FUNCTION__"#%s | CORRECTED %.2f -> %.2f", m_symbol, marketVolume, virtualVolume);
         }
      }
      m_isChanged = !res;
   }
   return res;
}

//+------------------------------------------------------------------+
//| 1JQ< >B:@KBKE @K=>G=KE ?>78F89                                  |
//+------------------------------------------------------------------+
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;
}

//+------------------------------------------------------------------+
//| 1JQ< >B:@KBKE 28B@C0;L=KE ?>78F89                               |
//+------------------------------------------------------------------+
double CVirtualSymbolReceiver::VirtualVolume() {
   double volume = 0;
   FOREACH(m_orders) volume += CMoney::Volume(m_orders[i]);
   return volume;
}

//+------------------------------------------------------------------+
//| ">@3>2;O ?> A8<2>;C 4>ABC?=0?                                    |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::IsTradeAllowed() {
   return (true
           && m_minMargin > 0
           && m_symbolInfo.TradeMode() == SYMBOL_TRADE_MODE_FULL
          );
}

//+------------------------------------------------------------------+
//| 5>1E>48<0O @07=8F0 >1JQ<>2                                      |
//+------------------------------------------------------------------+
double CVirtualSymbolReceiver::DiffVolume(double marketVolume, double virtualVolume) {
// >;CG05< 3@0=8G=K5 7=0G5=8O 4>?CAB8<KE >1J<>2
   double minLot = MathMax(0.01, m_symbolInfo.LotsMin());
   double maxLot = m_symbolInfo.LotsMax();
   double lotStep = MathMax(0.01, m_symbolInfo.LotsStep());

// 0E>48<, =0 A:>;L:> =04> 87<5=8BL >1JQ< >B:@KBKE ?>78F89 ?> A8<2>;C
   double oldVolume = marketVolume;
   double newVolume = virtualVolume;
   int ratio = 0;

// @>25@O5<, GB> =>2K9 >1J5< C:;04K205BAO 2 4>?CAB8<K5 @0<:8
   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;
      }
   }
// 0 A:>;L:> =04> 87<5=8BL >B:@KBK9 >1J5<
   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;
}

//+------------------------------------------------------------------+
//| >@@5:F8O >1J5<0 =0 =5>1E>48<CN @07=8FC                          |
//+------------------------------------------------------------------+
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;
}

//+------------------------------------------------------------------+
//| B:@KB85 @K=>G=>9 ?>78F88 BUY 8;8 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)) {
      PrintFormat(__FUNCTION__"#%s | OPEN %s %.2f", m_symbol, (diffVolume > 0 ? "BUY" : "SELL"), volume);

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

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

   return res;
}

//+------------------------------------------------------------------+
//| B:@KB85 4>?>;=8B5;L=>3> >1JQ<0 BUY                              |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::AddBuy(double volume) {
   return ClearOpen(volume);
}

//+------------------------------------------------------------------+
//| B:@KB85 4>?>;=8B5;L=>3> >1JQ<0 SELL                                                                 |
//+------------------------------------------------------------------+
bool CVirtualSymbolReceiver::AddSell(double volume) {
   return ClearOpen(-volume);
}

//+------------------------------------------------------------------+
//| '0AB8G=>5 70:@KB85 >1JQ<0 BUY ?> A8<2>;C                         |
//+------------------------------------------------------------------+
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);
      }
   }

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

//+------------------------------------------------------------------+
//| '0AB8G=>5 70:@KB85 >1JQ<0 SELL ?> A8<2>;C                        |
//+------------------------------------------------------------------+
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;
}

//+------------------------------------------------------------------+
//| '0AB8G=>5 70:@KB85 BUY 8;8 SELL ?> A8<2>;C =0 AG5B5 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;
}

//+------------------------------------------------------------------+
//| >;=>5 70:@KB85 >1JQ<0 ?> A8<2>;C                                |
//+------------------------------------------------------------------+
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;
}

//+------------------------------------------------------------------+
//| @>25@:0 <0@68=0;L=KE B@51>20=89                                 |
//+------------------------------------------------------------------+
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);
//-- 5A;8 45=53 =5 E20B05B
   if(free_margin < 0) {
      PrintFormat(__FUNCTION__" | ERROR: Not enough money for %s %.2f, %s",
                  (type == OP_BUY) ? "BUY" : "SELL", volume, m_symbol);
      return(false);
   }
//-- ?@>25@:0 ?@>H;0 CA?5H=>
   return(true);
#endif

#ifdef __MQL5__
//--- ?>;CG8< F5=C >B:@KB8O
   MqlTick mqltick;
   SymbolInfoTick(m_symbol, mqltick);
   double price = mqltick.ask;
   if(type == ORDER_TYPE_SELL) {
      price = mqltick.bid;
   }
//--- 7=0G5=8O =5>1E>48<>9 8 A2>1>4=>9 <0@68
   double margin, free_margin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
//--- 2K7>25< DC=:F8N ?@>25@:8
   if(!OrderCalcMargin(type, m_symbol, volume, price, margin)) {
      //--- GB>-B> ?>H;> =5 B0:, A>>1I8< 8 25@=5< false
      PrintFormat(__FUNCTION__" | ERROR: Can't calc margin via OrderCalcMargin(), code=%d", GetLastError());
      return(false);
   }
//--- 5A;8 =5 E20B05B A@54AB2 =0 ?@>2545=85 >?5@0F88
   if(margin > free_margin) {
      //--- A>>1I8< >1 >H81:5 8 25@=5< false
      PrintFormat(__FUNCTION__" | ERROR: Not enough money for %s %.2f, %s",
                  (type == ORDER_TYPE_BUY) ? "BUY" : "SELL", volume, m_symbol);
      return(false);
   }
//--- ?@>25@:0 ?@>H;0 CA?5H=>
   return(true);
#endif
}
//+------------------------------------------------------------------+