//+------------------------------------------------------------------+
//|                                        SimpleVolumesStrategy.mqh |
//|                                      Copyright 2024, Yuriy Bykov |
//|                            https://www.mql5.com/ru/users/antekov |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, Yuriy Bykov"
#property link      "https://www.mql5.com/ru/articles/16452"
#property version   "1.11"

#include "../Utils/NewBarEvent.mqh"
#include "../Virtual/VirtualStrategy.mqh"

/** Описание стратегии

Входные параметры стратегии:
   - Символ
   - Период
   - Количество свечей для усреднения объемов (K)
   - Относительное отклонение от среднего для открытия первого ордера (D)
   - Относительное отклонение от среднего для открытия второго и последующих ордеров (D_add)
   - Расстояние от цены до отложенного ордера
   - Stop Loss (в пунктах)
   - Take Profit (в пунктах)
   - Время истечения отложенных ордеров (в минутах)
   - Максимальное количество одновременно отрытых ордеров (N_max)
   - Объем одного ордера

Находим количество открытых ордеров и позиций (N).
Если оно меньше N_max, то:
   - вычисляем средний тиковый объём за последние K закрытых свечей, получаем величину V_avr.
   - Если выполнено условие V > V_avr * (1 + D + N * D_add), то:
        - определяем направление изменения цены на текущей свече: если цена увеличилась,
          то будем выставлять BUY, BUY_STOP или BUY_LIMIT, а иначе - SELL, SELL_STOP или SELL_LIMIT
        - выставляем рыночный или отложенный ордер исходя из заданного в параметрах расстояния
          (0 - рыночный, >0 - отложенный стоповый, <0 - отложенный лимитный),
          времени истечения и уровнями StopLoss и TakeProfit.
*/


//+------------------------------------------------------------------+
//| Торговая стратегия с использованием тиковых объемов              |
//+------------------------------------------------------------------+
class CSimpleVolumesStrategy : public CVirtualStrategy {
protected:
   string            m_symbol;               // Символ (торговый инструмент)
   ENUM_TIMEFRAMES   m_timeframe;            // Период графика (таймфрейм)

   //---  Параметры сигнала к открытию
   int               m_signalPeriod;         // Количество свечей для усреднения объемов
   double            m_signalDeviation;      // Относ. откл. от среднего для открытия первого ордера
   double            m_signaAddlDeviation;   // Относ. откл. от среднего для открытия второго и последующих ордеров

   //---  Параметры отложенных ордеров
   int               m_openDistance;         // Расстояние от цены до отлож. ордера
   double            m_stopLevel;            // Stop Loss (в пунктах)
   double            m_takeLevel;            // Take Profit (в пунктах)
   int               m_ordersExpiration;     // Время истечения отложенных ордеров (в минутах)

   //---  Параметры управление капиталом
   int               m_maxCountOfOrders;     // Макс. количество одновременно отрытых ордеров

   CSymbolInfo       *m_symbolInfo;          // Объект для получения информации о свойствах символа

   int               m_iVolumesHandle;       // Хэндл индикатора тиковых объемов
   double            m_volumes[];            // Массив-приемник значений индикатора (самих объемов)

   //--- Методы
   int               SignalForOpen();        // Сигнал для открытия отложенных ордеров
   void              OpenBuyOrder();         // Открытие ордера BUY_STOP
   void              OpenSellOrder();        // Открытие ордера SELL_STOP
   double            ArrayAverage(
      const double &array[]);                // Среднее значение массива чисел

public:
   //--- Публичные методы
                     CSimpleVolumesStrategy(string p_params); // Конструктор

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

   virtual void      Tick() override;        // Обработчик события OnTick
   virtual void      Save() override;        // Сохранение состояния
   virtual bool      Load() override;        // Загрузка состояния

   // Замена названий символов
   virtual bool      SymbolsReplace(CHashMap<string, string> &p_symbolsMap);
};


//+------------------------------------------------------------------+
//| Конструктор                                                      |
//+------------------------------------------------------------------+
CSimpleVolumesStrategy::CSimpleVolumesStrategy(string p_params) {
   m_params = p_params;
   m_symbol = ReadString(p_params);
   m_timeframe = (ENUM_TIMEFRAMES) ReadLong(p_params);
   m_signalPeriod = (int) ReadLong(p_params);
   m_signalDeviation = ReadDouble(p_params);
   m_signaAddlDeviation = ReadDouble(p_params);
   m_openDistance = (int) ReadLong(p_params);
   m_stopLevel = ReadDouble(p_params);
   m_takeLevel = ReadDouble(p_params);
   m_ordersExpiration = (int) ReadLong(p_params);
   m_maxCountOfOrders = (int) ReadLong(p_params);

   if(IsValid()) {
      CVirtualReceiver::Get(GetPointer(this), m_orders, m_maxCountOfOrders);

      // Загружаем индикатор для получения тиковых объемов
      m_iVolumesHandle = iVolumes(m_symbol, m_timeframe, VOLUME_TICK);

      // Если индикатор загружен успешно
      if(m_iVolumesHandle != INVALID_HANDLE) {

         // Устанавливаем размер массива-приемника тиковых объемов и нужную адресацию
         ArrayResize(m_volumes, m_signalPeriod);
         ArraySetAsSeries(m_volumes, true);

         // Регистрируем обработчик события нового бара на минимальном таймфрейме
         //IsNewBar(m_symbol, PERIOD_M1);

         m_symbolInfo = CSymbolsMonitor::Instance()[m_symbol];
      } else {
         // Иначе устанавливаем ошибочное состояние объекта
         SetInvalid(__FUNCTION__, "Can't load iVolumes()");
      }
   }
}

//+------------------------------------------------------------------+
//| Преобразование объекта в строку                                  |
//+------------------------------------------------------------------+
string CSimpleVolumesStrategy::operator~() {
   return StringFormat("%s(%s)", typename(this), m_params);
}

//+------------------------------------------------------------------+
//| "Tick" event handler function                                    |
//+------------------------------------------------------------------+
void CSimpleVolumesStrategy::Tick() override {
   if(IsNewBar(m_symbol, PERIOD_M1)) {
// Если их количество меньше допустимого
      if(m_ordersTotal < m_maxCountOfOrders) {
         // Получаем сигнал на открытие
         int signal = SignalForOpen();

         if(signal == 1 /* || m_ordersTotal < 1 */) {          // Если сигнал на покупку, то
            OpenBuyOrder();         // открываем ордер BUY_STOP
         } else if(signal == -1) {  // Если сигнал на продажу, то
            OpenSellOrder();        // открываем ордер SELL_STOP
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Замена названий символов                                         |
//+------------------------------------------------------------------+
bool CSimpleVolumesStrategy::SymbolsReplace(CHashMap<string, string> &p_symbolsMap) {
// Если в словаре есть ключ, совпадающий с текущим символом
   if(p_symbolsMap.ContainsKey(m_symbol)) {
      string targetSymbol; // Целевой символ

      // Если целевой символ для текущего успешно получен из словаря
      if(p_symbolsMap.TryGetValue(m_symbol, targetSymbol)) {
         // Обновляем текущий символ
         m_symbol = targetSymbol;
      }
   }

   return true;
}

//+------------------------------------------------------------------+
//| Сигнал для открытия отложенных ордеров                           |
//+------------------------------------------------------------------+
int CSimpleVolumesStrategy::SignalForOpen() {
// По-умолчанию сигнала на открытие нет
   int signal = 0;

// Копируем значения объемов из индикаторного буфера в массив-приёмник
   int res = CopyBuffer(m_iVolumesHandle, 0, 0, m_signalPeriod, m_volumes);

// Если скопировалось нужное количество чисел
   if(res == m_signalPeriod) {
      // Вычисляем их среднее значение
      double avrVolume = ArrayAverage(m_volumes);

      // Если текущий объем превысил заданный уровень, то
      if(m_volumes[0] > avrVolume * (1 + m_signalDeviation + m_ordersTotal * m_signaAddlDeviation)) {
         // если цена открытия свечи меньше текущей цены (закрытия), то
         if(iOpen(m_symbol, m_timeframe, 0) < iClose(m_symbol, m_timeframe, 0)) {
            signal = 1; // сигнал на покупку
         } else {
            signal = -1; // иначе - сигнал на продажу
         }
      }
   }

   return signal;
}

//+------------------------------------------------------------------+
//| Открытие ордера BUY                                              |
//+------------------------------------------------------------------+
void CSimpleVolumesStrategy::OpenBuyOrder() {
// Обновляем информацию о текущих ценах для символа
//m_symbolInfo.Name(m_symbol);
//m_symbolInfo.RefreshRates();

// Берем необходимую нам информацию о символе и ценах
   double point = m_symbolInfo.Point();
   int digits = m_symbolInfo.Digits();
   double bid = m_symbolInfo.Bid();
   double ask = m_symbolInfo.Ask();
   int spread = (int) ((ask - bid) / point); //m_symbolInfo.Spread();

// Сделаем, чтобы расстояние открытия было не меньше спреда
   int distance = MathMax(MathAbs(m_openDistance), spread) * (m_openDistance < 0 ? -1 : 1);

// Цена открытия
   double price = ask + distance * point;

// Уровни StopLoss и TakeProfit
   double sl = NormalizeDouble(price - m_stopLevel * point, digits);
   double tp = NormalizeDouble(price + (m_takeLevel + spread) * point, digits);

// Время истечения
   datetime expiration = TimeCurrent() + m_ordersExpiration * 60;

   bool res = false;
   for(int i = 0; i < m_maxCountOfOrders; i++) {   // Перебираем все виртуальные позиции
      if(!m_orders[i].IsOpen()) {                  // Если нашли не открытую, то открываем
         if(m_openDistance > 0) {
            // Устанавливаем отложенный ордер SELL STOP
            res = m_orders[i].Open(m_symbol, ORDER_TYPE_BUY_STOP, m_fixedLot,
                                   NormalizeDouble(price, digits),
                                   NormalizeDouble(sl, digits),
                                   NormalizeDouble(tp, digits),
                                   "", expiration);

         } else if(m_openDistance < 0) {
            // Устанавливаем отложенный ордер SELL LIMIT
            res = m_orders[i].Open(m_symbol, ORDER_TYPE_BUY_LIMIT, m_fixedLot,
                                   NormalizeDouble(price, digits),
                                   NormalizeDouble(sl, digits),
                                   NormalizeDouble(tp, digits),
                                   "", expiration);

         } else {
            // Открытие виртуальной позиции SELL
            res = m_orders[i].Open(m_symbol, ORDER_TYPE_BUY, m_fixedLot,
                                   0,
                                   NormalizeDouble(sl, digits),
                                   NormalizeDouble(tp, digits));

         }
         break; // и выходим
      }
   }

   if(!res) {
      PrintFormat(__FUNCTION__" | ERROR opening BUY virtual order", 0);
   }
}

//+------------------------------------------------------------------+
//| Открытие ордера SELL                                             |
//+------------------------------------------------------------------+
void CSimpleVolumesStrategy::OpenSellOrder() {
// Обновляем информацию о текущих ценах для символа
//m_symbolInfo.Name(m_symbol);
//m_symbolInfo.RefreshRates();

// Берем необходимую нам информацию о символе и ценах
   double point = m_symbolInfo.Point();
   int digits = m_symbolInfo.Digits();
   double bid = m_symbolInfo.Bid();
   double ask = m_symbolInfo.Ask();
   int spread = (int) ((ask - bid) / point); //m_symbolInfo.Spread();

// Сделаем, чтобы расстояние открытия было не меньше спреда
   int distance = MathMax(MathAbs(m_openDistance), spread) * (m_openDistance < 0 ? -1 : 1);

// Цена открытия
   double price = bid - distance * point;

// Уровни StopLoss и TakeProfit
   double sl = NormalizeDouble(price + m_stopLevel * point, digits);
   double tp = NormalizeDouble(price - (m_takeLevel + spread) * point, digits);

// Время истечения
   datetime expiration = TimeCurrent() + m_ordersExpiration * 60;

   bool res = false;
   for(int i = 0; i < m_maxCountOfOrders; i++) {   // Перебираем все виртуальные позиции
      if(!m_orders[i].IsOpen()) {                  // Если нашли не открытую, то открываем
         if(m_openDistance > 0) {
            // Устанавливаем отложенный ордер SELL STOP
            res = m_orders[i].Open(m_symbol, ORDER_TYPE_SELL_STOP, m_fixedLot,
                                   NormalizeDouble(price, digits),
                                   NormalizeDouble(sl, digits),
                                   NormalizeDouble(tp, digits),
                                   "", expiration);

         } else if(m_openDistance < 0) {
            // Устанавливаем отложенный ордер SELL LIMIT
            res = m_orders[i].Open(m_symbol, ORDER_TYPE_SELL_LIMIT, m_fixedLot,
                                   NormalizeDouble(price, digits),
                                   NormalizeDouble(sl, digits),
                                   NormalizeDouble(tp, digits),
                                   "", expiration);

         } else {
            // Открытие виртуальной позиции SELL

            res = m_orders[i].Open(m_symbol, ORDER_TYPE_SELL, m_fixedLot,
                                   0,
                                   NormalizeDouble(sl, digits),
                                   NormalizeDouble(tp, digits));
         }
         break;   // и выходим
      }
   }

   if(!res) {
      PrintFormat(__FUNCTION__" | ERROR opening SELL virtual order", 0);
   }
}


//+------------------------------------------------------------------+
//| Среднее значение массива чисел со второго элемента               |
//+------------------------------------------------------------------+
double CSimpleVolumesStrategy::ArrayAverage(const double &array[]) {
   double s = 0;
   int total = ArraySize(array) - 1;
   for(int i = 1; i <= total; i++) {
      s += array[i];
   }

   return s / MathMax(1, total);
}

//+------------------------------------------------------------------+
//| Сохранение состояния                                             |
//+------------------------------------------------------------------+
void CSimpleVolumesStrategy::Save() {
   double avrVolume = ArrayAverage(m_volumes);

// Сформируем общую часть ключа с типом и хешем стратегии
   string key = "CSimpleVolumesStrategy[" + this.Hash() + "]";

// Сохраняем средний тиковый объём
   CStorage::Set(key + ".avrVolume", avrVolume);

// Сохраняем массив тиковых объёмов
   CStorage::Set(key + ".m_volumes", m_volumes);

// Вызываем метод базового класса (для сохранения виртуальных позиций)
   CVirtualStrategy::Save();
}

//+------------------------------------------------------------------+
//| Загрузка состояния                                               |
//+------------------------------------------------------------------+
bool CSimpleVolumesStrategy::Load() {
   bool res = true;

   double avrVolume = 0;

// Сформируем общую часть ключа с типом и хешем стратегии
   string key = "CSimpleVolumesStrategy[" + this.Hash() + "]";

// Загружаем массив тиковых объёмов
   res &= CStorage::Get(key + ".avrVolume", avrVolume);

// Загружаем массив тиковых объёмов
   res &= CStorage::Get(key + ".m_volumes", m_volumes);

// Вызываем метод базового класса (для загрузки виртуальных позиций)
   res &= CVirtualStrategy::Load();

   return res;
}
//+------------------------------------------------------------------+