//+------------------------------------------------------------------+
//|                                                     FVG Grid.mq5 |
//|                                  Copyright 2026, Shahrukh & AI   |
//|                                                 https://mql5.io  |
//+------------------------------------------------------------------+
#property copyright   "Copyright 2026, Shahrukh & AI"
#property link        "https://mql5.io"
#property version     "5.20"
#property description "FVG Grid: Уникальные короткие комментарии + Изолированный SL и Трейлинг"

#include <Trade\Trade.mqh>
CTrade trade;
input group "--- Риск и ММ ---"
input double           InpLotSize            = 0.01;      // Размер лота для каждого ордера
input int              InpStopLoss           = 150;       // Стоп-Лосс в пунктах от границы гэпа (0 - отключен)
input int              InpTakeProfit         = 300;       // Тейк-Профит (в пунктах, 0 - отключен)
input ulong            InpMagicNumber        = 123456;    // Мэджик номер советника
input int              InpMaxSpreadPoints    = 35;        // Максимальный спред в пунктах для входа (0 - отключен)

input group "--- Детектор FVG ---"
input int              InpMaximumBars        = 400;       // Сколько бар сканировать для отрисовки
input double           InpMinimumGapPoints   = 20.0;      // Минимальный размер гэпа в пунктах
input bool             InpHideMitigated      = true;      // Скрывать протестированные гэпы
input group "--- Настройки Сетки Ордеров ---"
input double           InpOrderOffsetPoints  = 10.0;      // Смещение уровней ордеров в пунктах
input group "--- Визуализация (Пунктир) ---"
input int              InpExtensionBars      = 80;        // Длина прямоугольника в барах
input color            InpBullishGapColor    = clrGreen;  // Яркий цвет контура для Buy
input color            InpBearishGapColor    = clrRed;    // Яркий цвет контура для Sell
input color            InpMitigatedColor     = clrSilver; // Цвет для смягченных зон
input bool             InpShowLabels         = true;      // Показывать текст
input group "--- Индивидуальный Трейлинг-Стоп ---"
input bool             InpUseTrailing        = true;      // Включить трейлинг?
input int              InpTrailingStart      = 150;       // Активация трейлинга (в пунктах от безубытка гэпа)
input int              InpTrailingDist       = 50;        // Расстояние от текущей цены (в пунктах)
input int              InpTrailingStep       = 10;        // Шаг изменения стоп-лосса (в пунктах)
// Глобальные переменные
string   g_prefix = "FVGSCAN_";
datetime g_last_bar = 0;
bool     g_first_run = true; 
string   g_file_name;

// База данных отторгованных FVG в ОЗУ
string   g_traded_gaps[];

// Предварительное объявление функций
void     BuildGapsAndTrade(const int rates_copied, const datetime &time[], const double &high[], const double &low[]);
void     CheckAndPlaceFvgGrid(string gap_id, double top, double bottom, bool is_bullish);
bool     IsGridAlreadyPlaced(string gap_id);
bool     WasGapTraded(string gap_id);
void     MarkGapAsTraded(string gap_id);
void     ApplyIsolatedTrailing();
void     ModifyIsolatedGridSL(string target_comment, long position_type, double new_sl);
void     CancelLimitOrdersOnPositionClose();
bool     IsBullishMitigated(const int formation_index, const double gap_bottom, const double gap_top, const double &low[]);
bool     IsBearishMitigated(const int formation_index, const double gap_bottom, const double gap_top, const double &high[]);
void     DrawGap(const string id, const datetime start_time, const datetime end_time, const double top, const double bottom, const bool bullish, const bool mitigated);
void     LoadGapsFromFile();
void     SaveGapToFile(string gap_id);
string   GetShortUniqueId(datetime bar_time);
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(InpMaximumBars < 20 || InpMinimumGapPoints < 0.0 || InpExtensionBars < 1)
     {
      Print("Invalid scanner settings.");
      return(INIT_PARAMETERS_INCORRECT);
     }
     
   trade.SetExpertMagicNumber(InpMagicNumber);
   trade.SetMarginMode();
   g_last_bar = 0;
   g_first_run = true;
   ArrayResize(g_traded_gaps, 0);
   
   g_file_name = "FVG_Grid_Storage_" + _Symbol + "_" + EnumToString(_Period) + ".txt";
   LoadGapsFromFile();
   
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |


//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   ObjectsDeleteAll(0, g_prefix);
   ChartRedraw(0);
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   datetime current_bar_time = iTime(_Symbol, _Period, 0);
   if(current_bar_time == 0) return;

   double high[], low[];
   datetime time[];
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(time, true);
   
   int copied_time = CopyTime(_Symbol, _Period, 0, InpMaximumBars, time);
   int copied_high = CopyHigh(_Symbol, _Period, 0, InpMaximumBars, high);
   int copied_low  = CopyLow(_Symbol, _Period, 0, InpMaximumBars, low);
   
   if(copied_time < 10 || copied_high < 10 || copied_low < 10) return;
   int rates_total = MathMin(copied_time, MathMin(copied_high, copied_low));

   // 1. Сканирование и выставление новых сеток на открытии бара
   if(current_bar_time != g_last_bar || g_first_run)
     {
      g_last_bar = current_bar_time;
      BuildGapsAndTrade(rates_total, time, high, low);


     }
     
   // 2. Контроль закрытия рыночных ордеров и очистка оставшихся лимиток текущего гэпа
   CancelLimitOrdersOnPositionClose();
   
   // 3. Индивидуальный трейлинг-стоп отдельно для каждого гэпа
   if(InpUseTrailing)
     {
      ApplyIsolatedTrailing();
     }
  }

//+------------------------------------------------------------------+
//| ОБРАБОТКА ИЗМЕНЕНИЙ ГРАФИКА                                      |
//+------------------------------------------------------------------+
void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
  {
   if(id == CHARTEVENT_CLICK || id == CHARTEVENT_CHART_CHANGE)
     {
      double high[], low[];
      datetime time[];
      ArraySetAsSeries(high, true);
      ArraySetAsSeries(low, true);
      ArraySetAsSeries(time, true);
      
      int copied_time = CopyTime(_Symbol, _Period, 0, InpMaximumBars, time);
      int copied_high = CopyHigh(_Symbol, _Period, 0, InpMaximumBars, high);
      int copied_low  = CopyLow(_Symbol, _Period, 0, InpMaximumBars, low);
      
      if(copied_time >= 10 && copied_high >= 10 && copied_low >= 10)
        {
         int rates_total = MathMin(copied_time, MathMin(copied_high, copied_low));
         BuildGapsAndTrade(rates_total, time, high, low);


        }
     }
  }

//+------------------------------------------------------------------+
//| Генерация короткого ID для соблюдения лимита в 31 символ коммента|
//+------------------------------------------------------------------+
string GetShortUniqueId(datetime bar_time)
  {
   // Используем последние 6 цифр таймштампа (этого достаточно для уникальности в рамках файла)
   ulong long_id = (ulong)bar_time;
   return IntegerToString((int)(long_id % 1000000));
  }

//+------------------------------------------------------------------+
//| Сканирование истории, построение объектов и выставление ордеров   |
//+------------------------------------------------------------------+
void BuildGapsAndTrade(const int rates_copied, const datetime &time[], const double &high[], const double &low[])
  {
   ObjectsDeleteAll(0, g_prefix);
   
   const int seconds = PeriodSeconds(_Period);
   const int bar_seconds = (seconds > 0 ? seconds : 60);
   
   const int oldest = MathMin(InpMaximumBars, rates_copied - 3);
   if(oldest < 1) return; 

   for(int index = oldest; index >= 1; index--)
     {
      const double bullish_size = low[index] - high[index + 2];
      const double bearish_size = low[index + 2] - high[index];
      const datetime end_time = time[index] + (datetime)(bar_seconds * InpExtensionBars);
      
      // Генерируем компактный ID, который гарантированно не обрежется в комментарии ордера
      const string short_id = GetShortUniqueId(time[index]);

      // 1. Проверяем Бычьи гэпы (Buy зоны)
      if(bullish_size >= InpMinimumGapPoints * _Point)
        {
         const double top = low[index];
         const double bottom = high[index + 2];
         const bool mitigated = IsBullishMitigated(index, bottom, top, low);
         
         if(!mitigated || !InpHideMitigated)
            DrawGap(short_id + "_B", time[index + 2], end_time, top, bottom, true, mitigated);
            
         if(!mitigated)
            CheckAndPlaceFvgGrid(short_id + "_B", top, bottom, true);
        }
        
      // 2. Проверяем Медвежьи гэпы (Sell зоны)
      if(bearish_size >= InpMinimumGapPoints * _Point)
        {
         const double top = low[index + 2];
         const double bottom = high[index];
         const bool mitigated = IsBearishMitigated(index, bottom, top, high);
         
         if(!mitigated || !InpHideMitigated)
            DrawGap(short_id + "_S", time[index + 2], end_time, top, bottom, false, mitigated);
            
         if(!mitigated)
            CheckAndPlaceFvgGrid(short_id + "_S", top, bottom, false);
        }


     }

   if(g_first_run) g_first_run = false; 
   ChartRedraw(0);
  }

//+------------------------------------------------------------------+
//| Функция выставления 3-х ордеров со СВОИМ индивидуальным Стоп-Лоссом|
//+------------------------------------------------------------------+
void CheckAndPlaceFvgGrid(string gap_id, double top, double bottom, bool is_bullish)
{
if(InpMaxSpreadPoints > 0)
{
int current_spread = (int)SymbolInfoInteger(_Symbol, SYMBOL_SPREAD);
if(current_spread > InpMaxSpreadPoints) return;
}
if(IsGridAlreadyPlaced(gap_id) || WasGapTraded(gap_id)) return;
double center = NormalizeDouble((top + bottom) * 0.5, _Digits);
double offset = InpOrderOffsetPoints * _Point;
double grid_levels[3];
if(is_bullish)
{
grid_levels[0] = NormalizeDouble(top + offset, _Digits);
grid_levels[1] = NormalizeDouble(center + offset, _Digits);
grid_levels[2] = NormalizeDouble(bottom + offset, _Digits);
}
else
{
grid_levels[0] = NormalizeDouble(top - offset, _Digits);
grid_levels[1] = NormalizeDouble(center - offset, _Digits);
grid_levels[2] = NormalizeDouble(bottom - offset, _Digits);
}
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
// Комментарий теперь короткий и уникальный (Пример: FVG_123456_B)
string comment = StringFormat("FVG_%s", gap_id);
bool grid_placed = false;
// Вычисляем Стоп-Лосс для каждого ордера от дальней границы гэпа
double common_sl = 0;
if(InpStopLoss > 0)
{
if(is_bullish)
common_sl = NormalizeDouble(bottom - InpStopLoss * _Point, _Digits);
else
common_sl = NormalizeDouble(top + InpStopLoss * _Point, _Digits);
}
for(int i = 0; i < 3; i++)
{
if(is_bullish)
{
double tp = (InpTakeProfit > 0) ? NormalizeDouble(grid_levels[i] + InpTakeProfit * _Point, _Digits) : 0;
if(ask <= grid_levels[i])
{
if(trade.Buy(InpLotSize, _Symbol, ask, common_sl, tp, comment)) grid_placed = true;
}
else
{
if(trade.BuyLimit(InpLotSize, grid_levels[i], _Symbol, common_sl, tp, ORDER_TIME_GTC, 0, comment)) grid_placed = true;
}
}
else // BEARISH FVG (SELL)
{
double tp = (InpTakeProfit > 0) ? NormalizeDouble(grid_levels[i] - InpTakeProfit * _Point, _Digits) : 0;
if(bid >= grid_levels[i])
{
if(trade.Sell(InpLotSize, _Symbol, bid, common_sl, tp, comment)) grid_placed = true;
}
else
{
if(trade.SellLimit(InpLotSize, grid_levels[i], _Symbol, common_sl, tp, ORDER_TIME_GTC, 0, comment)) grid_placed = true;
}
}
}
if(grid_placed)
{
MarkGapAsTraded(gap_id);
}
}
//+------------------------------------------------------------------+
//| Функция отмены лимиток ТОЛЬКО при закрытии позиций этого гэпа    |
//+------------------------------------------------------------------+
void CancelLimitOrdersOnPositionClose()
{
int total_gaps = ArraySize(g_traded_gaps);
if(total_gaps == 0) return;
if(!HistorySelect(0, TimeCurrent())) return;
int total_deals = HistoryDealsTotal();
for(int g = 0; g < total_gaps; g++)
{
string gap_id = g_traded_gaps[g];
string target_comment = "FVG_" + gap_id;
bool has_open_positions = false;
bool has_limit_orders = false;
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
// Безопасное чтение свойств позиции в MQL5 по индексу
if(PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_MAGIC) == InpMagicNumber)
{
if(PositionGetString(POSITION_COMMENT) == target_comment)
{
has_open_positions = true;
break;
}
}
}
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
ulong ticket = OrderGetTicket(i);
if(ticket > 0 && OrderGetInteger(ORDER_MAGIC) == InpMagicNumber)
{
if(OrderGetString(ORDER_COMMENT) == target_comment)
{
long type = OrderGetInteger(ORDER_TYPE);
if(type == ORDER_TYPE_BUY_LIMIT || type == ORDER_TYPE_SELL_LIMIT)
{
has_limit_orders = true;
break;
}
}
}
}
if(has_limit_orders && !has_open_positions)
{
bool was_executed_and_closed = false;
for(int d = total_deals - 1; d >= 0; d--)
{
ulong deal_ticket = HistoryDealGetTicket(d);
if(deal_ticket > 0 && HistoryDealGetInteger(deal_ticket, DEAL_MAGIC) == InpMagicNumber)
{
if(HistoryDealGetString(deal_ticket, DEAL_COMMENT) == target_comment)
{
was_executed_and_closed = true;
break;
}
}
}
if(was_executed_and_closed)
{
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
ulong ticket = OrderGetTicket(i);
if(ticket > 0 && OrderGetInteger(ORDER_MAGIC) == InpMagicNumber)
{
if(OrderGetString(ORDER_COMMENT) == target_comment)
{
long type = OrderGetInteger(ORDER_TYPE);
if(type == ORDER_TYPE_BUY_LIMIT || type == ORDER_TYPE_SELL_LIMIT)
{
trade.OrderDelete(ticket);
Print("Лимитный ордер удален. Причина: Исполненные позиции данного FVG закрылись.");
}
}
}
}
}
}
}
}
//+------------------------------------------------------------------+
//| Индивидуальный трейлинг-стоп отдельно для каждого гэпа           |
//+------------------------------------------------------------------+
void ApplyIsolatedTrailing()
{
int total_gaps = ArraySize(g_traded_gaps);
if(total_gaps == 0) return;
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
for(int g = 0; g < total_gaps; g++)
{
string gap_id = g_traded_gaps[g];
string target_comment = "FVG_" + gap_id;
double total_vol_buy = 0, total_vol_sell = 0;
double weighted_price_buy = 0, weighted_price_sell = 0;
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
if(PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_MAGIC) == InpMagicNumber)
{
if(PositionGetString(POSITION_COMMENT) == target_comment)
{
double vol  = PositionGetDouble(POSITION_VOLUME);
double open = PositionGetDouble(POSITION_PRICE_OPEN);
long type   = PositionGetInteger(POSITION_TYPE);
if(type == POSITION_TYPE_BUY)
{
weighted_price_buy += open * vol;
total_vol_buy      += vol;
}
if(type == POSITION_TYPE_SELL)
{
weighted_price_sell += open * vol;
total_vol_sell      += vol;
}
}
}
}
if(total_vol_buy > 0)
{
double breakeven_buy = weighted_price_buy / total_vol_buy;
if(bid - breakeven_buy >= InpTrailingStart * _Point)
{
double new_sl = NormalizeDouble(bid - InpTrailingDist * _Point, _Digits);
if(new_sl > breakeven_buy)
ModifyIsolatedGridSL(target_comment, POSITION_TYPE_BUY, new_sl);
}
}
if(total_vol_sell > 0)
{
double breakeven_sell = weighted_price_sell / total_vol_sell;
if(breakeven_sell - ask >= InpTrailingStart * _Point)
{
double new_sl = NormalizeDouble(ask + InpTrailingDist * _Point, _Digits);
if(new_sl < breakeven_sell)
ModifyIsolatedGridSL(target_comment, POSITION_TYPE_SELL, new_sl);
}
}
}
}
//+------------------------------------------------------------------+
//| Модификация Стоп-Лосса внутри изолированной сетки конкретного FVG|
//+------------------------------------------------------------------+
void ModifyIsolatedGridSL(string target_comment, long position_type, double new_sl)
{
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i);
if(ticket > 0 && PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_MAGIC) == InpMagicNumber)
{
if(PositionGetString(POSITION_COMMENT) == target_comment && PositionGetInteger(POSITION_TYPE) == position_type)
{
double current_sl = PositionGetDouble(POSITION_SL);
if(position_type == POSITION_TYPE_BUY)
{
if(current_sl == 0 || (new_sl - current_sl >= InpTrailingStep * _Point))
trade.PositionModify(ticket, new_sl, PositionGetDouble(POSITION_TP));
}
else if(position_type == POSITION_TYPE_SELL)
{
if(current_sl == 0 || (current_sl - new_sl >= InpTrailingStep * _Point))
trade.PositionModify(ticket, new_sl, PositionGetDouble(POSITION_TP));
}
}
}
}
}
//+------------------------------------------------------------------+
//| Исторический учет отторгованных зон                              |
//+------------------------------------------------------------------+
bool WasGapTraded(string gap_id)
{
int size = ArraySize(g_traded_gaps);
for(int i = 0; i < size; i++)
if(g_traded_gaps[i] == gap_id) return(true);
return(false);
}
void MarkGapAsTraded(string gap_id)
{
int size = ArraySize(g_traded_gaps);
for(int i = 0; i < size; i++) if(g_traded_gaps[i] == gap_id) return;
ArrayResize(g_traded_gaps, size + 1);
g_traded_gaps[size] = gap_id;
SaveGapToFile(gap_id);
}
//+------------------------------------------------------------------+
//| РАБОТА С ФАЙЛАМИ (Запись/Чтение с диска)                         |
//+------------------------------------------------------------------+
void SaveGapToFile(string gap_id)
{
int file_handle = FileOpen(g_file_name, FILE_WRITE|FILE_READ|FILE_TXT|FILE_ANSI);
if(file_handle != INVALID_HANDLE)
{
FileSeek(file_handle, 0, SEEK_END);
FileWriteString(file_handle, gap_id + "\r\n");
FileClose(file_handle);
}
}
void LoadGapsFromFile()
{
if(!FileIsExist(g_file_name)) return;
int file_handle = FileOpen(g_file_name, FILE_READ|FILE_TXT|FILE_ANSI);
if(file_handle != INVALID_HANDLE)
{
while(!FileIsEnding(file_handle))
{
// Исправлено: Сдвиг указателя (параметр 0) предотвращает бесконечный цикл
string line = FileReadString(file_handle, 0);
StringTrimLeft(line);
StringTrimRight(line);
if(line != "")
{
int size = ArraySize(g_traded_gaps);
ArrayResize(g_traded_gaps, size + 1);
g_traded_gaps[size] = line;
}
}
FileClose(file_handle);
Print("Успешно загружено ", ArraySize(g_traded_gaps), " ID зон FVG из дискового файла хранилища.");
}
}
//+------------------------------------------------------------------+
//| Проверка: были ли уже выставлены ордера по ID данного гэпа       |
//+------------------------------------------------------------------+
bool IsGridAlreadyPlaced(string gap_id)
{
string target_comment = "FVG_" + gap_id;
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
ulong ticket = OrderGetTicket(i);
if(ticket > 0 && OrderGetInteger(ORDER_MAGIC) == InpMagicNumber && OrderGetString(ORDER_COMMENT) == target_comment)
return(true);
}
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i);
if(ticket > 0 && PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_MAGIC) == InpMagicNumber && PositionGetString(POSITION_COMMENT) == target_comment)
return(true);
}
return(false);
}
//+------------------------------------------------------------------+
//| Проверка на смягчение бычьего гэпа                               |

//+------------------------------------------------------------------+
bool IsBullishMitigated(const int formation_index, const double gap_bottom, const double gap_top, const double &low[])
{
for(int index = formation_index - 1; index >= 0; index--)
if(low[index] <= gap_bottom)
return(true);
return(false);
}
//+------------------------------------------------------------------+
//| Проверка на смягчение медвежьего гэпа                             |

//+------------------------------------------------------------------+
bool IsBearishMitigated(const int formation_index, const double gap_bottom, const double gap_top, const double &high[])
{
for(int index = formation_index - 1; index >= 0; index--)
if(high[index] >= gap_top)
return(true);
return(false);
}
//+------------------------------------------------------------------+
//| Отрисовка пунктирных прямоугольников без заливки                 |

//+------------------------------------------------------------------+
void DrawGap(const string id, const datetime start_time, const datetime end_time,
const double top, const double bottom, const bool bullish, const bool mitigated)
{
const string rectangle_name = g_prefix + "BOX_" + id;
color base_color = (mitigated ? InpMitigatedColor : (bullish ? InpBullishGapColor : InpBearishGapColor));
if(!ObjectCreate(0, rectangle_name, OBJ_RECTANGLE, 0, start_time, top, end_time, bottom))
return;
ObjectSetInteger(0, rectangle_name, OBJPROP_COLOR, base_color);
ObjectSetInteger(0, rectangle_name, OBJPROP_STYLE, STYLE_DOT);
ObjectSetInteger(0, rectangle_name, OBJPROP_WIDTH, 1);
ObjectSetInteger(0, rectangle_name, OBJPROP_FILL, false);
ObjectSetInteger(0, rectangle_name, OBJPROP_BACK, true);
ObjectSetInteger(0, rectangle_name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, rectangle_name, OBJPROP_HIDDEN, true);
if(!InpShowLabels) return;
const string label_name = g_prefix + "TEXT_" + id;
const double label_price = (top + bottom) * 0.5;
if(ObjectCreate(0, label_name, OBJ_TEXT, 0, start_time, label_price))
{
string label = (bullish ? "Bullish FVG" : "Bearish FVG");
if(mitigated) label += "  filled";
ObjectSetString(0, label_name, OBJPROP_TEXT, label);
ObjectSetString(0, label_name, OBJPROP_FONT, "Arial");
ObjectSetInteger(0, label_name, OBJPROP_FONTSIZE, 8);
ObjectSetInteger(0, label_name, OBJPROP_COLOR, mitigated ? clrGray : (bullish ? clrForestGreen : clrFireBrick));
ObjectSetInteger(0, label_name, OBJPROP_ANCHOR, ANCHOR_LEFT);
ObjectSetInteger(0, label_name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, label_name, OBJPROP_HIDDEN, true);
}

}