//+------------------------------------------------------------------+
//|                                               FVG_Detector.mq5   |
//|                                   Expert Advisor para MT5        |
//|                      Detección y Visualización de Fair Value Gaps|
//+------------------------------------------------------------------+
#property copyright "FVG Visual Detector"
#property link      ""
#property version   "1.00"
#property description "Expert Advisor exclusivo para detectar y dibujar Fair Value Gaps"
#property description "NO ejecuta trades - Solo análisis visual"
#property strict

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#include "..\\Utils\\MetricSaver.mqh"
#include <TSN\\MQLArticles\\Utils\\TFManager.mqh>


/* Codigo hecho por ia Claude Sonnet 4.6
Promt:
Desarrolla un BOT (Expert Advisor) para MetaTrader 5 (MT5) que EXCLUSIVAMENTE detecte y dibuje Fair Value Gaps (FVG) en el gráfico.
 ⚠️ Este BOT NO debe ejecutar operaciones, NO debe abrir/cerrar trades y NO debe funcionar como indicador. Su única función es análisis visual mediante dibujo en el gráfico
 . Requisitos técnicos obligatorios: Implementado como Expert Advisor (EA) en MQL5. Detección y dibujo de FVG alcistas y bajistas.
 Funcionamiento rápido, eficiente y altamente optimizado. Capaz de trabajar con datos históricos y en tiempo real.
 Configuración personalizable desde el panel del BOT: Colores de los FVG. Opacidad / transparencia.
 Grosor y estilo de los rectángulos. Activar o desactivar FVG alcistas o bajistas. Timeframe de análisis. Aspectos visuales:
  Los FVG deben dibujarse como zonas (rectángulos) claras y limpias. Evitar redibujados innecesarios. El BOT debe actualizar los FVG solo cuando sea necesario.
  Buenas prácticas de desarrollo: Código limpio, modular y bien comentado. Uso eficiente de OnInit, OnTick y manejo de objetos gráficos.
   Optimización de loops y cálculos para mínimo consumo de CPU.
  Usa todo tu conocimiento avanzado en MQL5, optimización y Smart Money Concepts para crear un BOT profesional, estable y rápido,
  enfocado únicamente en dibujar Fair Value Gaps.
*/

//+------------------------------------------------------------------+
//| INPUTS - Configuración Personalizable                            |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|  CFvgFast.mqh  —  Fair Value Gap · Zero-alloc · Flat arrays      |
//|  Mismo estilo que CFvgBar: Create / Set / SetGraphic / OnNewBar  |
//|  Sin clases internas · Sin new/delete · Arrays estáticos         |
//+------------------------------------------------------------------+
#property strict

#ifndef FVG_MAX
  #define FVG_MAX  200
#endif

//──────────────────────────────────────────────────────────────────
//  Zona FVG — 40 bytes, sin strings dinámicos
//──────────────────────────────────────────────────────────────────
struct FVGZone
{
   double   hi;
   double   lo;
   datetime t;
   bool     active;
   bool     bullish;
};

//──────────────────────────────────────────────────────────────────
//  CFvgFast
//──────────────────────────────────────────────────────────────────
class CFvgFast
{
private:
   //--- arrays planos en el heap del objeto (no BSS, pero un solo alloc en Create)
   FVGZone  m_bull[FVG_MAX];
   FVGZone  m_bear[FVG_MAX];

   int      m_bull_n;
   int      m_bear_n;
   int      m_bull_head;   // circular overwrite
   int      m_bear_head;
   long     m_bull_total;  // total insertados (para saber si circular)
   long     m_bear_total;

   //--- nearest (actualizado 1x barra, leído N veces por EA)
   int      m_near_bull;
   int      m_near_bear;

   //--- config
   string   m_symbol;
   ENUM_TIMEFRAMES m_tf;
   string   m_prefix;
   int      m_lookback;
   double   m_min_gap;    // en precio, ya convertido
   bool     m_draw;

   //--- visual
   color    m_col_bull;
   color    m_col_bear;
   ENUM_LINE_STYLE m_style;
   bool     m_fill;
   int      m_border_w;
   bool     m_extend;
   int      m_extend_bars;

   //──────── helpers privados ────────

   string _Name(bool bull, int idx)
   {
      return m_prefix + (bull ? "B" : "S") + IntegerToString(idx);
   }

   void _DrawZone(int idx, bool bull)
   {
      if(!m_draw) return;
      FVGZone z = bull ? m_bull[idx] : m_bear[idx];
      if(!z.active) return;

      string   nm  = _Name(bull, idx);
      color    c   = bull ? m_col_bull : m_col_bear;
      datetime t1  = z.t;
      datetime t2  = m_extend
                     ? z.t + (datetime)PeriodSeconds(m_tf) * m_extend_bars
                     : 0;

      if(ObjectFind(0, nm) < 0)
         ObjectCreate(0, nm, OBJ_RECTANGLE, 0, t1, z.hi, t2, z.lo);
      else
      {
         ObjectSetInteger(0, nm, OBJPROP_TIME,  0, t1);
         ObjectSetInteger(0, nm, OBJPROP_TIME,  1, t2);
         ObjectSetDouble (0, nm, OBJPROP_PRICE, 0, z.hi);
         ObjectSetDouble (0, nm, OBJPROP_PRICE, 1, z.lo);
      }
      ObjectSetInteger(0, nm, OBJPROP_COLOR,      c);
      ObjectSetInteger(0, nm, OBJPROP_STYLE,      m_style);
      ObjectSetInteger(0, nm, OBJPROP_WIDTH,      m_border_w);
      ObjectSetInteger(0, nm, OBJPROP_FILL,       m_fill);
      ObjectSetInteger(0, nm, OBJPROP_BACK,       true);
      ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, nm, OBJPROP_HIDDEN,     true);
   }

   void _DeleteZone(int idx, bool bull)
   {
      if(!m_draw) return;
      ObjectDelete(0, _Name(bull, idx));
   }

   void _Insert(const FVGZone &z)
   {
      if(z.bullish)
      {
         int i = m_bull_head;
         if(m_bull_total >= FVG_MAX) _DeleteZone(i, true);
         m_bull[i] = z;
         _DrawZone(i, true);
         m_bull_head = (m_bull_head + 1) % FVG_MAX;
         if(m_bull_n < FVG_MAX) m_bull_n++;
         m_bull_total++;
      }
      else
      {
         int i = m_bear_head;
         if(m_bear_total >= FVG_MAX) _DeleteZone(i, false);
         m_bear[i] = z;
         _DrawZone(i, false);
         m_bear_head = (m_bear_head + 1) % FVG_MAX;
         if(m_bear_n < FVG_MAX) m_bear_n++;
         m_bear_total++;
      }
   }

   //--- Detección O(1): lee 3 velas, evalúa gap
   void _Detect(int shift)
   {
      double hi[3], lo[3];
      datetime t[1];
      if(CopyHigh(m_symbol, m_tf, shift,   3, hi) < 3) return;
      if(CopyLow (m_symbol, m_tf, shift,   3, lo) < 3) return;
      if(CopyTime(m_symbol, m_tf, shift+1, 1, t)  < 1) return;

      //--- Bull FVG: low[0] > high[2]
      if(lo[0] > hi[2] && (lo[0] - hi[2]) >= m_min_gap)
      {
         FVGZone z;
         z.hi = lo[0]; z.lo = hi[2]; z.t = t[0];
         z.active = true; z.bullish = true;
         _Insert(z);
      }
      //--- Bear FVG: high[0] < low[2]
      if(hi[0] < lo[2] && (lo[2] - hi[0]) >= m_min_gap)
      {
         FVGZone z;
         z.hi = lo[2]; z.lo = hi[0]; z.t = t[0];
         z.active = true; z.bullish = false;
         _Insert(z);
      }
   }

   //--- Mitigación O(n), solo comparaciones de double
   void _Mitigate(double price)
   {
      int n = (int)MathMin(m_bull_n, FVG_MAX);
      for(int i = 0; i < n; i++)
      {
         if(!m_bull[i].active) continue;
        if(price <= m_bull[i].hi && price >= m_bull[i].lo)
         {
            m_bull[i].active = false;
            _DeleteZone(i, true);
         }
      }
      n = (int)MathMin(m_bear_n, FVG_MAX);
      for(int i = 0; i < n; i++)
      {
         if(!m_bear[i].active) continue;
         if(price >= m_bear[i].lo && price <= m_bear[i].hi)
         {
            m_bear[i].active = false;
            _DeleteZone(i, false);
         }
      }
   }

   //--- Nearest O(n), 1x barra
   void _UpdateNearest(double price)
   {
      double best_b = DBL_MAX, best_s = DBL_MAX;
      m_near_bull = -1;
      m_near_bear = -1;

      int n = (int)MathMin(m_bull_n, FVG_MAX);
      for(int i = 0; i < n; i++)
      {
         if(!m_bull[i].active) continue;
         double d = MathAbs(price - (m_bull[i].hi + m_bull[i].lo) * 0.5);
         if(d < best_b) { best_b = d; m_near_bull = i; }
      }
      n = (int)MathMin(m_bear_n, FVG_MAX);
      for(int i = 0; i < n; i++)
      {
         if(!m_bear[i].active) continue;
         double d = MathAbs(price - (m_bear[i].hi + m_bear[i].lo) * 0.5);
         if(d < best_s) { best_s = d; m_near_bear = i; }
      }
   }

public:

   CFvgFast() :
      m_bull_n(0), m_bear_n(0),
      m_bull_head(0), m_bear_head(0),
      m_bull_total(0), m_bear_total(0),
      m_near_bull(-1), m_near_bear(-1),
      m_lookback(500), m_min_gap(0.0),
      m_draw(true), m_fill(true),
      m_col_bull(clrLimeGreen), m_col_bear(clrCrimson),
      m_style(STYLE_SOLID), m_border_w(1),
      m_extend(true), m_extend_bars(40),
      m_prefix("FVG_") {}

   //──────────────────────────────────────────────────────────────
   //  API pública — mismo estilo que CFvgBar
   //──────────────────────────────────────────────────────────────

   //--- 1. Create: asigna símbolo y timeframe
   void Create(string symbol, ENUM_TIMEFRAMES tf)
   {
      m_symbol = symbol;
      m_tf     = tf;
   }

   //--- 2. SetGraphic: visual (equivalente a fvg.SetGrapich(...))
   void SetGraphic(color    col_bull      = clrLimeGreen,
                   color    col_bear      = clrCrimson,
                   ENUM_LINE_STYLE style  = STYLE_SOLID,
                   bool     fill          = true,
                   int      border_w      = 1,
                   bool     extend        = true,
                   int      extend_bars   = 40,
                   string   prefix        = "FVG_")
   {
      m_col_bull    = col_bull;
      m_col_bear    = col_bear;
      m_style       = style;
      m_fill        = fill;
      m_border_w    = border_w;
      m_extend      = extend;
      m_extend_bars = extend_bars;
      m_prefix      = prefix;
   }

   //--- 3. Set: config lógica + arranca historial
   //         min_gap_points: 0 = sin filtro
   void Set(int lookback        = 500,
            double min_gap_pts  = 0.0,
            bool draw           = true)
   {
      m_draw     = draw;
      m_lookback = lookback;
      m_min_gap  = min_gap_pts * SymbolInfoDouble(m_symbol, SYMBOL_POINT);

      // Reset
      m_bull_n = m_bear_n = 0;
      m_bull_head = m_bear_head = 0;
      m_bull_total = m_bear_total = 0;
      m_near_bull = m_near_bear = -1;

      // Limpiar objetos anteriores
      for(int i = ObjectsTotal(0) - 1; i >= 0; i--)
      {
         string nm = ObjectName(0, i);
         if(StringFind(nm, m_prefix) == 0)
            ObjectDelete(0, nm);
      }

      // Carga histórica
      int bars = MathMin(m_lookback, Bars(m_symbol, m_tf) - 3);
      for(int s = bars; s >= 1; s--)
         _Detect(s);

      double price = SymbolInfoDouble(m_symbol, SYMBOL_BID);
      _Mitigate(price);
      _UpdateNearest(price);
   }

   //--- 4. OnNewBar: llama en cada cierre de vela
   void OnNewBar()
   {
      _Detect(1);
      double price = SymbolInfoDouble(m_symbol, SYMBOL_BID);
      _Mitigate(price);
      _UpdateNearest(price);
   }

   //--- 5. OnTick (opcional): solo mitigación intra-barra
   void OnTick()
   {
      double price = SymbolInfoDouble(m_symbol, SYMBOL_BID);
      _Mitigate(price);
   }

   //--- 6. Deinit
   void Deinit()
   {
      for(int i = ObjectsTotal(0) - 1; i >= 0; i--)
      {
         string nm = ObjectName(0, i);
         if(StringFind(nm, m_prefix) == 0)
            ObjectDelete(0, nm);
      }
   }

   //--- Acceso al nearest (lectura O(1))
   bool GetNearestBull(FVGZone &out)
   {
      if(m_near_bull < 0) return false;
      out = m_bull[m_near_bull];
      return out.active;
   }

   bool GetNearestBear(FVGZone &out)
   {
      if(m_near_bear < 0) return false;
      out = m_bear[m_near_bear];
      return out.active;
   }

   bool IsInsideBull(double price)
   {
      if(m_near_bull < 0) return false;
      return m_bull[m_near_bull].active &&
             price >= m_bull[m_near_bull].lo &&
             price <= m_bull[m_near_bull].hi;
   }

   bool IsInsideBear(double price)
   {
      if(m_near_bear < 0) return false;
      return m_bear[m_near_bear].active &&
             price >= m_bear[m_near_bear].lo &&
             price <= m_bear[m_near_bear].hi;
   }

   int CountBull() const { return m_bull_n; }
   int CountBear() const { return m_bear_n; }
};


 
//+------------------------------------------------------------------+
int8_t  idx_ctrl_d1   = INVALID_INDEX;
int8_t  idx_ctrl_curr = INVALID_INDEX;
 
CFvgFast fvg;   // ← mismo estilo que tu "CFvgBar fvg;"
TSN::CNewBarManager g_new_bar_manager;
//+------------------------------------------------------------------+
int OnInit()
{
   CMetricsSave::Start(FILE_CODE4);
 
   g_new_bar_manager.GetPosExecute(PERIOD_D1,  idx_ctrl_d1);
   g_new_bar_manager.GetPosExecute(_Period,     idx_ctrl_curr);
 
   //--- 1. Create
   fvg.Create(_Symbol, _Period);
 
   //--- 2. SetGraphic (colores, estilo, extensión)
   fvg.SetGraphic(
      clrLimeGreen,   // bull
      clrCrimson,     // bear
      STYLE_SOLID,    // borde
      true,           // fill
      1,              // border width
      true,           // extend
      40,             // barras extensión
      "FVG_"          // prefijo
   );
 
   //--- 3. Set (lookback, min gap en puntos, dibujar)
   fvg.Set(500, 0.0, true);
 
   Print("Init OK | Bull: ", fvg.CountBull(), " | Bear: ", fvg.CountBear());
   return INIT_SUCCEEDED;
}
 
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   fvg.Deinit();
   CMetricsSave::Destroy();
}
 
//+------------------------------------------------------------------+
void OnTick()
{
   const datetime curr_time = TimeCurrent();
   g_new_bar_manager.Execute(curr_time);
 
   if(CNewBarManager_IsNewBarM1(g_new_bar_manager) &&
      CNewBarManager_IsNewBar(g_new_bar_manager, idx_ctrl_curr))
   {
      const bool new_day = CNewBarManager_IsNewBar(g_new_bar_manager, idx_ctrl_d1);
      fvg.OnNewBar();   // ← idéntico a tu "fvg.OnNewBar();"
   }
}