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

#include <Trade\SymbolInfo.mqh>

//+------------------------------------------------------------------+
//| Предварительные определения классов                              |
//+------------------------------------------------------------------+
class CVirtualOrder;
class CVirtualReceiver;
class CVirtualStrategy;

#include "../Utils/SymbolsMonitor.mqh"
#include "VirtualReceiver.mqh"
#include "VirtualStrategy.mqh"

// Структура для чтения/записи из БД 
// основных свойств виртуального ордера/позиции
struct VirtualOrderStruct {
   string            strategyHash;
   int               strategyIndex;
   ulong             ticket;
   string            symbol;
   double            lot;
   ENUM_ORDER_TYPE   type;
   datetime          openTime;
   double            openPrice;
   double            stopLoss;
   double            takeProfit;
   datetime          closeTime;
   double            closePrice;
   datetime          expiration;
   string            comment;
   double            point;
};

//+------------------------------------------------------------------+
//| Класс виртуальных ордеров и позиций                              |
//+------------------------------------------------------------------+
class CVirtualOrder {
private:
//--- Статические поля
   static ulong      s_count;          // Счётчик всех созданных объектов CVirtualOrder
   static ulong      s_ticket;
   CSymbolInfo       *m_symbolInfo;    // Объект для получения свойств символов

//--- Связанные объекты получателя и стратегии
   CSymbolsMonitor   *m_symbols;
   CVirtualReceiver  *m_receiver;
   CVirtualStrategy  *m_strategy;

//--- Свойства ордера (позиции)
   ulong             m_id;             // ID
   ulong             m_ticket;         // Тикет
   string            m_symbol;         // Символ
   double            m_lot;            // Объем
   ENUM_ORDER_TYPE   m_type;           // Тип
   double            m_openPrice;      // Цена открытия
   double            m_stopLoss;       // Уровень StopLoss
   double            m_takeProfit;     // Уровень TakeProfit
   string            m_comment;        // Комментарий
   datetime          m_expiration;     // Время истечения

   datetime          m_openTime;       // Время открытия

//--- Свойства закрытого ордера (позиции)
   double            m_closePrice;     // Цена закрытия
   datetime          m_closeTime;      // Время закрытия
   string            m_closeReason;    // Причина закрытия

   double            m_point;          // Величина пункта

   bool              m_isStopLoss;     // Признак срабатывания StopLoss
   bool              m_isTakeProfit;   // Признак срабатывания TakeProfit
   bool              m_isExpired;      // Признак истечения времени

//--- Частные методы
   bool              CheckClose();     // Проверка условий закрытия
   bool              CheckTrigger();   // Проверка срабатывания отложенного ордера

public:
                     CVirtualOrder(
      CVirtualStrategy *p_strategy
   );                                  // Конструктор

                    ~CVirtualOrder() {
      if(!!m_symbolInfo) delete m_symbolInfo;
   }

//--- Методы проверки состояния позиции (ордера)
   bool              IsOpen() {        // Ордер открыт?
      return(this.m_openTime > 0 && this.m_closeTime == 0);
   };
   bool              IsClosed() {      // Ордер закрыт?
      return(this.m_openTime > 0 && this.m_closeTime > 0);
   };
   bool              IsMarketOrder() { // Это рыночная позиция?
      return IsOpen() && (m_type == ORDER_TYPE_BUY || m_type == ORDER_TYPE_SELL);
   }
   bool              IsPendingOrder() {// Это отложенный ордер?
      return IsOpen() && (m_type == ORDER_TYPE_BUY_LIMIT
                          || m_type == ORDER_TYPE_BUY_STOP
                          || m_type == ORDER_TYPE_SELL_LIMIT
                          || m_type == ORDER_TYPE_SELL_STOP);
   }
   bool              IsBuyOrder() {    // Это открытая позиция BUY?
      return IsOpen() && (m_type == ORDER_TYPE_BUY
                          || m_type == ORDER_TYPE_BUY_LIMIT
                          || m_type == ORDER_TYPE_BUY_STOP);
   }
   bool              IsSellOrder() {   // Это открытая позиция SELL?
      return IsOpen() && (m_type == ORDER_TYPE_SELL
                          || m_type == ORDER_TYPE_SELL_LIMIT
                          || m_type == ORDER_TYPE_SELL_STOP);
   }
   bool              IsStopOrder() {   // Это отложенный STOP-ордер?
      return IsOpen() && (m_type == ORDER_TYPE_BUY_STOP || m_type == ORDER_TYPE_SELL_STOP);
   }
   bool              IsLimitOrder() {  // Это отложенный LIMIT-ордер?
      return IsOpen() && (m_type == ORDER_TYPE_BUY_LIMIT || m_type == ORDER_TYPE_SELL_LIMIT);
   }

//--- Методы получения свойств позиции (ордера)
   ulong             Id() {            // ID
      return m_id;
   }
   ulong             Ticket() {        // Тикет
      return m_ticket;
   }
   CStrategy         *Strategy() {
      return m_strategy;
   }
   ENUM_ORDER_TYPE   Type() {
      return m_type;
   }
   string            TypeName() {
      string s = StringSubstr(EnumToString(m_type), 11);
      StringReplace(s, "_", " ");
      return s;
   }
   double            Lot() {
      return m_lot;
   }
   double            Volume() {        // Объем с направлением
      return IsBuyOrder() ? m_lot : (IsSellOrder() ? -m_lot : 0);
   }
   double            Profit();         // Текущая прибыль
   double            ClosedProfit();

   string            Symbol() {        // Символ
      return m_symbol;
   }
   double            OpenPrice() {
      return m_openPrice;
   }
   datetime          OpenTime() {
      return m_openTime;
   }
   double            ClosePrice() {
      return m_closePrice;
   }
   datetime          CloseTime() {
      return m_closeTime;
   }
   double            FittedBalance() {
      return m_strategy.FittedBalance();
   }
   double            StopLoss() {
      return m_stopLoss;
   }
   void              StopLoss(double value) {
      m_stopLoss = value;
   }
   double            TakeProfit() {
      return m_takeProfit;
   }
   void              TakeProfit(double value) {
      m_takeProfit = value;
   }

//--- Методы обработки позиций (ордеров)
   bool              CVirtualOrder::Open(string symbol,
                                         ENUM_ORDER_TYPE type,
                                         double lot,
                                         double price,
                                         double sl = 0,
                                         double tp = 0,
                                         string comment = "",
                                         datetime expiration = 0,
                                         bool inPoints = false); // Открытие позиции (ордера)

   void              Expiration(datetime p_expiration) {
      if(IsOpen()) {
         m_expiration = p_expiration;
      }
   }

   void              Tick();     // Обработка тика для позиции (ордера)
   void              Close();    // Закрытие позиции (ордера)
   void              Clear() {
      m_lot = 0;
   }

   virtual void      Load(const VirtualOrderStruct &o);   // Загрузка состояния
   virtual void      Save(VirtualOrderStruct &o);   // Сохранение состояния

   static void       Reset() {
      s_count = 0;
   }

   // Есть ли открытые рыночные виртуальные позиции?
   static bool       HasMarket(CVirtualOrder* &p_orders[]);

   string            operator~();         // Преобразование объекта в строку
};

// Инициализация статических полей класса
ulong                CVirtualOrder::s_count = 0;
ulong                CVirtualOrder::s_ticket = 0;

//+------------------------------------------------------------------+
//| Конструктор                                                      |
//+------------------------------------------------------------------+
CVirtualOrder::CVirtualOrder(CVirtualStrategy *p_strategy) :
// Список инициализации
   m_id(++s_count),  // Новый идентификатор = счётчик объектов + 1
   m_ticket(0),
   m_receiver(CVirtualReceiver::Instance()),
   m_strategy(p_strategy),
   m_symbol(""),
   m_lot(0),
   m_type(-1),
   m_openPrice(0),
   m_stopLoss(0),
   m_takeProfit(0),
   m_openTime(0),
   m_comment(""),
   m_expiration(0),
   m_closePrice(0),
   m_closeTime(0),
   m_closeReason(""),
   m_point(0) {
   PrintFormat(__FUNCTION__ + "#%d | CREATED VirtualOrder", m_id);
   m_symbolInfo = NULL;
   m_symbols = CSymbolsMonitor::Instance();
}

//+------------------------------------------------------------------+
//| Открытие виртуальной позиции (ордера)                            |
//+------------------------------------------------------------------+
bool CVirtualOrder::Open(string symbol,         // Символ
                         ENUM_ORDER_TYPE type,  // Тип (BUY или SELL)
                         double lot,            // Объём
                         double price = 0,      // Цена открытия
                         double sl = 0,         // Уровень StopLoss (цена или пункты)
                         double tp = 0,         // Уровень TakeProfit (цена или пункты)
                         string comment = "",   // Комментарий
                         datetime expiration = 0,  // Время истечения
                         bool inPoints = false  // Уровни SL и TP заданы в пунктах?
                        ) {
   if(IsOpen()) { // Если позиция уже открыта, то ничего не делаем
      PrintFormat(__FUNCTION__ "#%d | ERROR: Order is opened already!", m_id);
      return false;
   }

// Получаем от монитора символов указатель на информационный объект для нужного символа
   m_symbolInfo = m_symbols[symbol];

   if(!!m_symbolInfo) {
      //m_symbolInfo.RefreshRates();  // Обновляем информацию о текущих ценах

      // Инициализируем свойства позиции
      m_ticket = ++s_ticket;
      m_openPrice = price;
      m_symbol = symbol;
      m_lot = lot;
      m_openTime = TimeCurrent();
      m_closeTime = 0;
      m_type = type;
      m_comment = comment;
      m_expiration = expiration;

      // Открываемая позиция (ордер) не является закрытой по SL, TP или истечению
      m_isStopLoss = false;
      m_isTakeProfit = false;
      m_isExpired = false;

      m_point = m_symbolInfo.Point();

      double bid = m_symbolInfo.Bid();
      double ask = m_symbolInfo.Ask();
      double spread = ((ask - bid) / m_point);

      //m_symbolInfo.Spread();

      // В зависимости от направления устанавливаем цену открытия и уровни SL и TP.
      // Если SL и TP заданы в пунктах, то предварительно вычисляем их ценовые уровни
      // относительно цены открытия
      if(IsBuyOrder()) {
         if(type == ORDER_TYPE_BUY) {
            m_openPrice = ask;
         }
         m_stopLoss = (sl > 0 ? (inPoints ? m_openPrice - sl * m_point - spread * m_point : sl) : 0);
         m_takeProfit = (tp > 0 ? (inPoints ? m_openPrice + tp * m_point : tp) : 0);
      } else if(IsSellOrder()) {
         if(type == ORDER_TYPE_SELL) {
            m_openPrice = bid;
         }
         m_stopLoss = (sl > 0 ? (inPoints ? m_openPrice + sl * m_point : sl) : 0);
         m_takeProfit = (tp > 0 ? (inPoints ? m_openPrice - tp * m_point - spread * m_point : tp) : 0);
      }

      // Оповещаем получатель и стратегию, что позиция (ордер) открыта
      m_receiver.OnOpen(&this);
      m_strategy.OnOpen(&this);

      PrintFormat(__FUNCTION__"#%d | OPEN %s: %s %s %.2f | Price=%.5f | SL=%.5f | TP=%.5f | %s | %s",
                  m_id, (IsMarketOrder() ? "Market" : "Pending"), StringSubstr(EnumToString(type), 11),
                  m_symbol, m_lot, m_openPrice, m_stopLoss, m_takeProfit, m_comment,
                  (m_expiration ? TimeToString(m_expiration) : "-"));

      return true;
   } else {
      PrintFormat(__FUNCTION__"#%d | ERROR: Can't find symbol %s for "
                  "OPEN %s: %s %s %.2f | Price=%.5f | SL=%.5f | TP=%.5f | %s | %s",
                  m_id, m_symbol, (IsMarketOrder() ? "Market" : "Pending"), StringSubstr(EnumToString(type), 11),
                  m_symbol, m_lot, m_openPrice, m_stopLoss, m_takeProfit, m_comment,
                  (m_expiration ? TimeToString(m_expiration) : "-"));
      return false;
   }
}

//+------------------------------------------------------------------+
//| Закрытие позиции                                                 |
//+------------------------------------------------------------------+
void CVirtualOrder::Close() {
   if(IsOpen()) { // Если позиция открыта
      // Определяем причину закрытия для вывода в лог
      string closeReason = "";

      if(m_isStopLoss) {
         closeReason += "[SL]";
      } else if(m_isTakeProfit) {
         closeReason += "[TP]";
      } else if(m_isExpired) {
         closeReason += "[EX]";
      } else {
         closeReason += "[CL]";
      }

      PrintFormat(__FUNCTION__ + "#%d | CLOSE %s: %s %s %.2f | Profit=%.2f %s | %s",
                  m_id, (IsMarketOrder() ? "Market" : "Pending"), StringSubstr(EnumToString(m_type), 11),
                  m_symbol, m_lot, Profit(), closeReason, m_comment);

      m_closeTime = TimeCurrent();  // Время закрытия позиции

      // Запоминаем цену закрытия в зависимости от типа
      if(m_type == ORDER_TYPE_BUY) {
         m_closePrice = m_symbolInfo.Bid();
      } else if(m_type == ORDER_TYPE_SELL) {
         m_closePrice = m_symbolInfo.Ask();
      } else {
         m_closePrice = 0;
      }

      // Оповещаем получатель и стратегию, что позиция (ордер) закрыта
      m_receiver.OnClose(&this);
      m_strategy.OnClose(&this);
   }
}

//+------------------------------------------------------------------+
//| Расчет текущей прибыли позиции                                   |
//+------------------------------------------------------------------+
double CVirtualOrder::Profit() {
   double profit = 0;
   if(IsMarketOrder()) {   // Если это открытая рыночная виртуальная позиция
      //m_symbolInfo.Name(m_symbol);     // Выбираем нужный символ
      //m_symbolInfo.RefreshRates();     // Обновляем информацию о текущих ценах

      // Текущая цена, по которой можно закрыть позицию
      double closePrice = (m_type == ORDER_TYPE_BUY) ? m_symbolInfo.Bid() : m_symbolInfo.Ask();

      // Прибыль в виде разности цен открытия и закрытия
      if(m_type == ORDER_TYPE_BUY) {
         profit = closePrice - m_openPrice;
      } else {
         profit = m_openPrice - closePrice;
      }

      if(m_point > 1e-10) {   // Если известен размер пункта, то
         // Пересчитываем прибыль из разности цен в денежное выражение для объёма в 1 лот
         if(profit > 0) {
            profit = profit / m_point * m_symbolInfo.TickValueProfit();
         } else {
            profit = profit / m_point * m_symbolInfo.TickValueLoss();
         }
      } else {
         PrintFormat(__FUNCTION__ + "#%d | ERROR: Point for %s is undefined", m_id, m_symbol);
         m_point = m_symbolInfo.Point();
      }
      // Пересчитываем прибыль для объёма позиции
      profit *= m_lot;
   }

   return profit;
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CVirtualOrder::ClosedProfit() {
   double profit = 0;
   if(IsClosed()) {

      // Если это открытая рыночная виртуальная позиция
      //s_symbolInfo.Name(m_symbol);     // Выбираем нужный символ
      //s_symbolInfo.RefreshRates();     // Обновляем информацию о текущих ценах

      // Текущая цена, по которой можно закрыть позицию
      double closePrice = m_closePrice;

      // Прибыль в виде разности цен открытия и закрытия
      if(m_type == ORDER_TYPE_BUY) {
         profit = closePrice - m_openPrice;
      } else if(m_type == ORDER_TYPE_SELL) {
         profit = m_openPrice - closePrice;
      }

      if(m_point > 1e-10) {   // Если известен размер пункта, то
         // Пересчитываем прибыль из разности цен в денежное выражение для объёма в 1 лот
         if(profit > 0) {
            profit = profit / m_point * m_symbolInfo.TickValueProfit();
         } else {
            profit = profit / m_point * m_symbolInfo.TickValueLoss();
         }
      } else {
         PrintFormat(__FUNCTION__ + "#%d | ERROR: Point for %s is undefined", m_id, m_symbol);
         m_point = m_symbolInfo.Point();
      }
      // Пересчитываем прибыль для объёма позиции
      profit *= m_lot;
   }

   return profit;
}

//+------------------------------------------------------------------+
//| Проверка необходимости закрытия по SL, TP или EX                 |
//+------------------------------------------------------------------+
bool CVirtualOrder::CheckClose() {
   if(IsMarketOrder()) {               // Если это открытая рыночная виртуальная позиция, то
      //s_symbolInfo.Name(m_symbol);     // Выбираем нужный символ
      //s_symbolInfo.RefreshRates();     // Обновляем информацию о текущих ценах

      // Текущая цена, по которой можно закрыть позицию
      double closePrice = (m_type == ORDER_TYPE_BUY) ? m_symbolInfo.Bid() : m_symbolInfo.Ask();
      //double spread = m_symbolInfo.Spread();
      //double lastHigh = iHigh(m_symbol, PERIOD_M1, 1);
      //double lastLow = iLow(m_symbol, PERIOD_M1, 1) + spread;

      bool res = false;
      // Проверяем, что цена достигла SL или TP
      if(m_type == ORDER_TYPE_BUY) {
         m_isStopLoss = (m_stopLoss > 0 && closePrice <= m_stopLoss);
         m_isTakeProfit = (m_takeProfit > 0 && (closePrice >= m_takeProfit
                                                //|| lastHigh >= m_takeProfit
                                               ));
      } else if(m_type == ORDER_TYPE_SELL) {
         m_isStopLoss = (m_stopLoss > 0 && closePrice >= m_stopLoss);
         m_isTakeProfit = (m_takeProfit > 0 && (closePrice <= m_takeProfit
                                                // || lastLow <= m_takeProfit
                                               ));
      }

      // Был ли достигнут SL или TP?
      res = (m_isStopLoss || m_isTakeProfit);

      if(res) {
         PrintFormat(__FUNCTION__ + "#%d | %s REACHED at %.5f: %.5f | %.5f, Profit=%.2f | %s",
                     m_id, (m_isStopLoss ? "SL" : "TP"), closePrice, m_stopLoss, m_takeProfit,
                     Profit(), m_comment);
         return true;
      }
   } else if(IsPendingOrder()) {    // Если это виртуальный отложенный ордер
      // Проверяем, было ли достигнуто время истечения, если оно задано
      if(m_expiration > 0 && m_expiration < TimeCurrent()) {
         m_isExpired = true;
         return true;
      }
   }

   return false;
}

//+------------------------------------------------------------------+
//| Обработка тика одного виртуального ордера (позиции)              |
//+------------------------------------------------------------------+
void CVirtualOrder::Tick() {
   if(IsOpen()) {  // Если это открытая виртуальная позиция или ордер
      if(CheckClose()) {  // Проверяем, достигнуты ли уровни SL или TP или время истечения
         Close();         // Закрываем при достижении
      } else if (IsPendingOrder()) {   // Если это отложенный ордер
         CheckTrigger();  // Проверяем его срабатывание
      }
   }
}

//+------------------------------------------------------------------+
//| Проверка срабатывания отложенного ордера                         |
//+------------------------------------------------------------------+
bool CVirtualOrder::CheckTrigger() {
   if(IsPendingOrder()) {
      //m_symbolInfo.Name(m_symbol);     // Выбираем нужный символ
      //m_symbolInfo.RefreshRates();     // Обновляем информацию о текущих ценах
      double bid = m_symbolInfo.Bid();
      double ask = m_symbolInfo.Ask();
      double spread = ((ask - bid) / m_point);

      double price = (IsBuyOrder()) ? ask : bid;


      // Если цена дошла до уровней открытия, то превращаем ордер в позицию
      if(false
            || (m_type == ORDER_TYPE_BUY_LIMIT && price <= m_openPrice)
            || (m_type == ORDER_TYPE_BUY_STOP  && price >= m_openPrice)
        ) {
         PrintFormat(__FUNCTION__"#%d | OPEN %s at %.5f -> BUY at %.5f (Spread: %.0f)",
                     m_id, StringSubstr(EnumToString(m_type), 11), m_openPrice, price, spread);
         m_type = ORDER_TYPE_BUY;
      } else if(false
                || (m_type == ORDER_TYPE_SELL_LIMIT && price >= m_openPrice)
                || (m_type == ORDER_TYPE_SELL_STOP  && price <= m_openPrice)
               ) {
         PrintFormat(__FUNCTION__"#%d | OPEN %s at %.5f -> SELL at %.5f (Spread: %.0f)",
                     m_id, StringSubstr(EnumToString(m_type), 11), m_openPrice, price, spread);
         m_type = ORDER_TYPE_SELL;
      }

      // Если ордер превратился в позицию
      if(IsMarketOrder()) {
         m_openPrice = price; // Запоминаем цену открытия

         // Оповещаем получатель и стратегию, что открыта позиция
         m_receiver.OnOpen(&this);
         m_strategy.OnOpen(&this);
         return true;
      }
   }
   return false;
}

//+------------------------------------------------------------------+
//| Сохранение состояния                                             |
//+------------------------------------------------------------------+
void CVirtualOrder::Save(VirtualOrderStruct &o) {
   o.ticket = m_ticket;
   o.symbol = m_symbol;
   o.lot = m_lot;
   o.type = m_type;
   o.openPrice = m_openPrice;
   o.stopLoss = m_stopLoss;
   o.takeProfit = m_takeProfit;
   o.openTime = m_openTime;
   o.closePrice = m_closePrice;
   o.closeTime = m_closeTime;
   o.expiration = m_expiration;
   o.comment = m_comment;
   o.point = m_point;
}


//+------------------------------------------------------------------+
//| Загрузка состояния                                               |
//+------------------------------------------------------------------+
void CVirtualOrder::Load(const VirtualOrderStruct &o) {
   m_ticket = o.ticket;
   m_symbol = o.symbol;
   m_lot = o.lot;
   m_type = o.type;
   m_openPrice = o.openPrice;
   m_stopLoss = o.stopLoss;
   m_takeProfit = o.takeProfit;
   m_openTime = o.openTime;
   m_closePrice = o.closePrice;
   m_closeTime = o.closeTime;
   m_expiration = o.expiration;
   m_comment = o.comment;
   m_point = o.point;

   PrintFormat(__FUNCTION__" | %s", ~this);

   s_ticket = MathMax(s_ticket, m_ticket);
   
   m_symbolInfo = m_symbols[m_symbol];

// Оповещаем получатель и стратегию, что позиция (ордер) открыта
   if(IsOpen()) {
      m_receiver.OnOpen(&this);
      m_strategy.OnOpen(&this);
   } else {
      m_receiver.OnClose(&this);
      m_strategy.OnClose(&this);
   }
}

//+------------------------------------------------------------------+
//| Есть ли открытые рыночные виртуальные позиции?                               |
//+------------------------------------------------------------------+
bool CVirtualOrder::HasMarket(CVirtualOrder *&p_orders[]) {
   FOREACH(p_orders) if (p_orders[i].IsMarketOrder()) return true;
   return false;
}

//+------------------------------------------------------------------+
//| Преобразование объекта в строку                                  |
//+------------------------------------------------------------------+
string CVirtualOrder::operator~() {
   if(IsOpen()) {
      return StringFormat("#%d %s %s %.2f in %s at %.5f (%.5f, %.5f). %s, %f",
                          m_id, TypeName(), m_symbol, m_lot,
                          TimeToString(m_openTime), m_openPrice,
                          m_stopLoss, m_takeProfit,
                          TimeToString(m_closeTime), m_closePrice);
   } else {
      return StringFormat("#%d --- ", m_id);
   }

}
//+------------------------------------------------------------------+