//+------------------------------------------------------------------+
//|                                                      ORB.mq5     |
//|                        Copyright 2025 © YourRealName            |
//|                                       https://www.mql5.com       |
//+------------------------------------------------------------------+
#property copyright "© 2025 YourRealName"
#property link      "https://www.mql5.com/en/users/yourprofile"
#property version   "2.10"
#property description "Opening Range Breakout (ORB) Indicator with DST support"
#property indicator_chart_window
#property indicator_plots 0


//+------------------------------------------------------------------+
//| Enumeraciones                                                     |
//+------------------------------------------------------------------+
enum ENUM_ORB_PERIOD
{
   ORB_5MIN = 5,       // 5 minutos
   ORB_15MIN = 15,     // 15 minutos  
   ORB_30MIN = 30,     // 30 minutos
   ORB_CUSTOM = 0      // Personalizado
};

enum ENUM_MARKET_SESSION
{
   SESSION_CUSTOM = 0,            // Personalizado
   SESSION_SYDNEY = 1,            // Sydney (00:00-06:00 UTC)
   SESSION_TOKYO = 2,             // Tokyo (00:00-06:00 UTC)
   SESSION_LONDON = 3,            // London (08:00-16:30 UTC)
   SESSION_NEWYORK = 4,           // New York (14:30-21:00 UTC)
   SESSION_FRANKFURT = 5          // Frankfurt (08:00-16:30 UTC)
};

enum ENUM_TIMEZONE
{
   GMT_MINUS_11_MIDWAY = 0,        // (GMT -11:00) Midway Island
   GMT_MINUS_11_SAMOA = 1,         // (GMT -11:00) Samoa
   GMT_MINUS_10_HAWAII = 2,        // (GMT -10:00) Hawaii
   GMT_MINUS_8_ALASKA = 3,         // (GMT -8:00) Alaska
   GMT_MINUS_7_ARIZONA = 4,        // (GMT -7:00) Arizona
   GMT_MINUS_7_BAJA = 5,           // (GMT -7:00) Baja California
   GMT_MINUS_7_PACIFIC = 6,        // (GMT -7:00) Pacific Time (US & Canada)
   GMT_MINUS_6_CHIHUAHUA = 7,      // (GMT -6:00) Chihuahua, La Paz, Mazatlan
   GMT_MINUS_6_GUADALAJARA = 8,    // (GMT -6:00) Guadalajara, Mexico City, Monterrey
   GMT_MINUS_6_MOUNTAIN = 9,       // (GMT -6:00) Mountain Time (US & Canada)
   GMT_MINUS_5_BOGOTA = 10,        // (GMT -5:00) Bogota, Lima, Quito
   GMT_MINUS_5_CENTRAL_AMERICA = 11, // (GMT -5:00) Central America
   GMT_MINUS_5_CENTRAL_US = 12,    // (GMT -5:00) Central Time (US & Canada)
   GMT_MINUS_5_SASKATCHEWAN = 13,  // (GMT -5:00) Saskatchewan
   GMT_MINUS_4_ASUNCION = 14,      // (GMT -4:00) Asuncion
   GMT_MINUS_4_CARACAS = 15,       // (GMT -4:00) Caracas
   GMT_MINUS_4_CUIABA = 16,        // (GMT -4:00) Cuiaba
   GMT_MINUS_4_EASTERN_US = 17,    // (GMT -4:00) Eastern Time (US & Canada)
   GMT_MINUS_4_GEORGETOWN = 18,    // (GMT -4:00) Georgetown, La Paz, Manaus, San Juan
   GMT_MINUS_4_INDIANA = 19,       // (GMT -4:00) Indiana (East)
   GMT_MINUS_4_SANTIAGO = 20,      // (GMT -4:00) Santiago
   GMT_MINUS_3_ATLANTIC = 21,      // (GMT -3:00) Atlantic Time (Canada)
   GMT_MINUS_3_BRASILIA = 22,      // (GMT -3:00) Brasilia
   GMT_MINUS_3_BUENOS_AIRES = 23,  // (GMT -3:00) Buenos Aires
   GMT_MINUS_3_CAYENNE = 24,       // (GMT -3:00) Cayenne, Fortaleza
   GMT_MINUS_3_MONTEVIDEO = 25,    // (GMT -3:00) Montevideo
   GMT_MINUS_2_30_NEWFOUNDLAND = 26, // (GMT -2:30) Newfoundland
   GMT_MINUS_2_GREENLAND = 27,     // (GMT -2:00) Greenland
   GMT_MINUS_1_CAPE_VERDE = 28,    // (GMT -1:00) Cape Verde Is.
   GMT_0_AZORES = 29,              // (GMT) Azores
   GMT_0_UTC = 30,                 // (GMT) Coordinated Universal Time
   GMT_0_MONROVIA = 31,            // (GMT) Monrovia, Reykjavik
   GMT_PLUS_1_CASABLANCA = 32,     // (GMT +1:00) Casablanca
   GMT_PLUS_1_DUBLIN = 33,         // (GMT +1:00) Dublin, Edinburgh, Lisbon, London
   GMT_PLUS_1_LAGOS = 34,          // (GMT +1:00) Lagos
   GMT_PLUS_1_WEST_AFRICA = 35,    // (GMT +1:00) West Central Africa
   GMT_PLUS_2_AMSTERDAM = 36,      // (GMT +2:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna
   GMT_PLUS_2_BELGRADE = 37,       // (GMT +2:00) Belgrade, Bratislava, Budapest, Ljubljana, Prague
   GMT_PLUS_2_BRUSSELS = 38,       // (GMT +2:00) Brussels, Copenhagen, Madrid, Paris
   GMT_PLUS_2_CAIRO = 39,          // (GMT +2:00) Cairo
   GMT_PLUS_2_JOHANNESBURG = 40,   // (GMT +02:00) Johannesburg
   GMT_PLUS_2_SARAJEVO = 41,       // (GMT +2:00) Sarajevo, Skopje, Warsaw, Zagreb
   GMT_PLUS_2_WINDHOEK = 42,       // (GMT +2:00) Windhoek
   GMT_PLUS_3_AMMAN = 43,          // (GMT +3:00) Amman
   GMT_PLUS_3_BAGHDAD = 44,        // (GMT +3:00) Baghdad
   GMT_PLUS_3_BEIRUT = 45,         // (GMT +3:00) Beirut
   GMT_PLUS_3_DAMASCUS = 46,       // (GMT +3:00) Damascus
   GMT_PLUS_3_HELSINKI = 47,       // (GMT +3:00) Helsinki, Kyiv, Riga, Sofia, Tallinn, Vilnius
   GMT_PLUS_3_ISTANBUL = 48,       // (GMT +3:00) Istanbul
   GMT_PLUS_3_JERUSALEM = 49,      // (GMT +3:00) Jerusalem
   GMT_PLUS_3_KUWAIT = 50,         // (GMT +3:00) Kuwait, Riyadh
   GMT_PLUS_3_MOSCOW = 51,         // (GMT +3:00) Moscow, St. Petersburg, Volgograd
   GMT_PLUS_3_NAIROBI = 52,        // (GMT +3:00) Nairobi
   GMT_PLUS_3_30_TEHRAN = 53,      // (GMT +3:30) Tehran
   GMT_PLUS_4_ABU_DHABI = 54,      // (GMT +4:00) Abu Dhabi, Dubai, Muscat
   GMT_PLUS_4_BAKU = 55,           // (GMT +4:00) Baku
   GMT_PLUS_4_30_KABUL = 56,       // (GMT +4:30) Kabul
   GMT_PLUS_5_EKATERINBURG = 57,   // (GMT +5:00) Ekaterinburg
   GMT_PLUS_5_KARACHI = 58,        // (GMT +5:00) Karachi
   GMT_PLUS_5_30_CHENNAI = 59,     // (GMT +5:30) Chennai, Kolkata, Mumbai, New Delhi
   GMT_PLUS_5_30_COLOMBO = 60,     // (GMT +5:30) Colombo
   GMT_PLUS_5_45_KATHMANDU = 61,   // (GMT +5:45) Kathmandu
   GMT_PLUS_6_DHAKA = 62,          // (GMT +6:00) Dhaka
   GMT_PLUS_6_30_YANGON = 63,      // (GMT +6:30) Yangon (Rangoon)
   GMT_PLUS_7_BANGKOK = 64,        // (GMT +7:00) Bangkok, Hanoi, Jakarta
   GMT_PLUS_8_BEIJING = 65,        // (GMT +8:00) Beijing, Chongqing, Hong Kong, Urumqi
   GMT_PLUS_8_MANILA = 66,         // (GMT +08:00) Manila
   GMT_PLUS_8_SINGAPORE = 67,      // (GMT +8:00) Singapore
   GMT_PLUS_9_OSAKA = 68,          // (GMT +9:00) Osaka, Sapporo, Tokyo
   GMT_PLUS_9_SEOUL = 69,          // (GMT +9:00) Seoul
   GMT_PLUS_9_30_ADELAIDE = 70,    // (GMT +9:30) Adelaide
   GMT_PLUS_10_BRISBANE = 71,      // (GMT +10:00) Brisbane
   GMT_PLUS_10_CANBERRA = 72,      // (GMT +10:00) Canberra, Melbourne, Sydney
   GMT_PLUS_10_VLADIVOSTOK = 73,   // (GMT +10:00) Vladivostok
   GMT_PLUS_11_SOLOMON = 74,       // (GMT +11:00) Solomon Is., New Caledonia
   GMT_PLUS_12_AUCKLAND = 75,      // (GMT +12:00) Auckland, Wellington
   GMT_PLUS_12_ENIWETOK = 76       // (GMT +12:00) Eniwetok, Kwajalein
};

//+------------------------------------------------------------------+
//| Inputs del Indicador                                             |
//+------------------------------------------------------------------+
input group "=== Configuración ORB ==="
input ENUM_ORB_PERIOD InpORBPeriod = ORB_5MIN;                    // ORB period
input ENUM_MARKET_SESSION InpMarketSession = SESSION_NEWYORK;     // Market session
input string InpCustomTime = "08:00-08:05";                        // Custom time (only if Custom)
input ENUM_TIMEZONE InpTimeZone = GMT_MINUS_5_BOGOTA;             // GMT time zone
input bool InpAlertBreakoutsOnly = false;                         // Alerts only on confirmed breakouts
input bool InpDebugMode = false;                                   // DEBUG MODE

input group "=== Visualización ==="
input bool InpShowLabels = true;                                  // Show ORB labels
input bool InpShowPreviousDays = true;                            // Show previous days' ORBs
input bool InpShowPriceTargets = true;                            // Show basic targets (50%, 100%)
input bool InpShowExtendedTargets = false;                        // Show extended targets
input bool InpShowFibTargets = false;                             // Show Fibonacci targets (27.2%, 61.8%)
input bool InpShowMidPoint = false;                               // Show midpoint
input bool InpShowShadedBox = true;                               // ENABLE/DISABLE shaded box
input int InpBoxBorderSize = 2;                                   // Box border thickness
input int InpMaxDaysBack = 5;                                     // Maximum days back

input group "=== Breakout Detection ==="
input bool InpUseVolumeConfirmation = false;                      // Use volume confirmation
input int InpVolumePeriod = 20;                                   // Period for volume SMA

input group "=== Colores y Estilo ==="
input color InpORBHighColor = clrLimeGreen;                       // ORB High line color
input color InpORBLowColor = clrRed;                              // ORB Low line color
input color InpShadeColor = clrTeal;                              // Shaded box color
input color InpBorderColor = clrDarkSlateGray;                    // Box border color
input color InpTarget50Color = clrMagenta;                        // 50% target color
input color InpTarget100Color = clrBlue;                          // 100% target color
input color InpTargetOtherColor = clrTeal;                        // Other targets color
input color InpFibColor = clrOrange;                              // Fibonacci targets color
input color InpMidPointColor = clrGray;                           // Midpoint color
input int InpLineWidth = 2;                                       // Line thickness
input ENUM_LINE_STYLE InpLineStyle = STYLE_SOLID;                 // Line style


//+------------------------------------------------------------------+
//| Estructura para datos ORB                                        |
//+------------------------------------------------------------------+
struct ORBData
{
   datetime date;
   double high;
   double low;
   double range;
   datetime startTime;
   datetime endTime;
   datetime candleTime;
   bool calculated;
   int barsFound;
   bool isFirstCandleMode;
   // 🔹 NUEVOS CAMPOS PARA BREAKOUT TRACKING
   bool inBreakout;
   int breakoutDirection; // 1 = alcista, -1 = bajista, 0 = none
   datetime breakoutTime;
   double breakoutPrice;
};

//+------------------------------------------------------------------+
//| Estructura para configuración de sesión                          |
//+------------------------------------------------------------------+
struct SessionConfig
{
   string name;
   string startTime;
   string endTime;
   double timezoneOffset;
   bool isDST; // 🔹 NUEVO: Indicador de horario de verano
};

//+------------------------------------------------------------------+
//| Estructura para datos de breakout                                |
//+------------------------------------------------------------------+
struct BreakoutData
{
   bool highCross;
   bool lowCross;
   bool highCrossBO;
   bool lowCrossBO;
   bool isRetestOrbHigh;
   bool isRetestOrbLow;
   bool failedRetest;
   bool volumeSpike;
};

//+------------------------------------------------------------------+
//| Variables Globales                                               |
//+------------------------------------------------------------------+
ORBData orbDataArray[];
string orbPrefix = "ORB_";
int orbPeriodMinutes = 15;
int chartTimeframeMinutes = 0;
SessionConfig currentSession;
bool currentInBreakout = false;
datetime lastAlertTime = 0;

// 🔹 NUEVAS VARIABLES PARA TRACKING DE BREAKOUTS
double volumeSMA[];
int volumePeriod = 20;

//+------------------------------------------------------------------+
//| Función auxiliar para debug                                      |
//+------------------------------------------------------------------+
void DebugPrint(string message)
{
   if(InpDebugMode)
      Print("🔍 [ORB DEBUG] ", message);
}

//+------------------------------------------------------------------+
//| 🔹 NUEVA FUNCIÓN: Detectar si una fecha está en horario de verano |
//+------------------------------------------------------------------+
bool IsDaylightSavingTime(datetime date, ENUM_MARKET_SESSION session)
{
   MqlDateTime dt;
   TimeToStruct(date, dt);
   
   switch(session)
   {
      case SESSION_NEWYORK:
         // Estados Unidos: segundo domingo de marzo hasta primer domingo de noviembre
         return IsUSADaylightSavingTime(dt);
         
      case SESSION_LONDON:
      case SESSION_FRANKFURT:
         // Europa: último domingo de marzo hasta último domingo de octubre
         return IsEuropeDaylightSavingTime(dt);
         
      case SESSION_SYDNEY:
         // Australia: primer domingo de octubre hasta primer domingo de abril (inverso)
         return IsAustraliaDaylightSavingTime(dt);
         
      case SESSION_TOKYO:
         // Japón no usa horario de verano
         return false;
         
      default:
         return false;
   }
}

//+------------------------------------------------------------------+
//| 🔹 NUEVA FUNCIÓN: DST para Estados Unidos                        |
//+------------------------------------------------------------------+
bool IsUSADaylightSavingTime(const MqlDateTime &dt)
{
   // Segundo domingo de marzo hasta primer domingo de noviembre
   
   // Antes de marzo = horario estándar
   if(dt.mon < 3) return false;
   
   // Después de noviembre = horario estándar
   if(dt.mon > 11) return false;
   
   // Diciembre = horario estándar
   if(dt.mon == 12) return false;
   
   // Entre abril y octubre = horario de verano
   if(dt.mon >= 4 && dt.mon <= 10) return true;
   
   // Marzo: segundo domingo
   if(dt.mon == 3)
   {
      int secondSunday = GetNthSunday(dt.year, 3, 2);
      return dt.day >= secondSunday;
   }
   
   // Noviembre: primer domingo
   if(dt.mon == 11)
   {
      int firstSunday = GetNthSunday(dt.year, 11, 1);
      return dt.day < firstSunday;
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| 🔹 NUEVA FUNCIÓN: DST para Europa                               |
//+------------------------------------------------------------------+
bool IsEuropeDaylightSavingTime(const MqlDateTime &dt)
{
   // Último domingo de marzo hasta último domingo de octubre
   
   // Antes de marzo = horario estándar
   if(dt.mon < 3) return false;
   
   // Después de octubre = horario estándar
   if(dt.mon > 10) return false;
   
   // Entre abril y septiembre = horario de verano
   if(dt.mon >= 4 && dt.mon <= 9) return true;
   
   // Marzo: último domingo
   if(dt.mon == 3)
   {
      int lastSunday = GetLastSunday(dt.year, 3);
      return dt.day >= lastSunday;
   }
   
   // Octubre: último domingo
   if(dt.mon == 10)
   {
      int lastSunday = GetLastSunday(dt.year, 10);
      return dt.day < lastSunday;
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| 🔹 NUEVA FUNCIÓN: DST para Australia                            |
//+------------------------------------------------------------------+
bool IsAustraliaDaylightSavingTime(const MqlDateTime &dt)
{
   // Primer domingo de octubre hasta primer domingo de abril (inverso)
   
   // Entre noviembre y marzo = horario de verano
   if(dt.mon >= 11 || dt.mon <= 3)
   {
      if(dt.mon >= 11) return true; // Nov-Dic
      if(dt.mon <= 2) return true;  // Ene-Feb
      
      // Marzo: primer domingo
      if(dt.mon == 3)
      {
         int firstSunday = GetNthSunday(dt.year, 3, 1);
         return dt.day < firstSunday;
      }
   }
   
   // Octubre: primer domingo
   if(dt.mon == 10)
   {
      int firstSunday = GetNthSunday(dt.year, 10, 1);
      return dt.day >= firstSunday;
   }
   
   // Entre mayo y septiembre = horario estándar
   return false;
}

//+------------------------------------------------------------------+
//| 🔹 NUEVA FUNCIÓN: Obtener el N-ésimo domingo de un mes          |
//+------------------------------------------------------------------+
int GetNthSunday(int year, int month, int n)
{
   datetime firstDay = StringToTime(StringFormat("%04d.%02d.01", year, month));
   MqlDateTime dt;
   TimeToStruct(firstDay, dt);
   
   // Encontrar el primer domingo
   int daysToFirstSunday = (7 - dt.day_of_week) % 7;
   int firstSunday = 1 + daysToFirstSunday;
   
   // Calcular el N-ésimo domingo
   return firstSunday + (n - 1) * 7;
}

//+------------------------------------------------------------------+
//| 🔹 NUEVA FUNCIÓN: Obtener el último domingo de un mes           |
//+------------------------------------------------------------------+
int GetLastSunday(int year, int month)
{
   // Último día del mes
   datetime lastDay = StringToTime(StringFormat("%04d.%02d.01", year, month + 1)) - 86400;
   MqlDateTime dt;
   TimeToStruct(lastDay, dt);
   
   // Retroceder hasta el domingo
   return dt.day - dt.day_of_week;
}

//+------------------------------------------------------------------+
//| Obtener offset de zona horaria                                   |
//+------------------------------------------------------------------+
double GetTimezoneOffset()
{
   switch(InpTimeZone)
   {
      case GMT_MINUS_11_MIDWAY:       return -11.0;
      case GMT_MINUS_11_SAMOA:        return -11.0;
      case GMT_MINUS_10_HAWAII:       return -10.0;
      case GMT_MINUS_8_ALASKA:        return -8.0;
      case GMT_MINUS_7_ARIZONA:       return -7.0;
      case GMT_MINUS_7_BAJA:          return -7.0;
      case GMT_MINUS_7_PACIFIC:       return -7.0;
      case GMT_MINUS_6_CHIHUAHUA:     return -6.0;
      case GMT_MINUS_6_GUADALAJARA:   return -6.0;
      case GMT_MINUS_6_MOUNTAIN:      return -6.0;
      case GMT_MINUS_5_BOGOTA:        return -5.0;
      case GMT_MINUS_5_CENTRAL_AMERICA: return -5.0;
      case GMT_MINUS_5_CENTRAL_US:    return -5.0;
      case GMT_MINUS_5_SASKATCHEWAN:  return -5.0;
      case GMT_MINUS_4_ASUNCION:      return -4.0;
      case GMT_MINUS_4_CARACAS:       return -4.0;
      case GMT_MINUS_4_CUIABA:        return -4.0;
      case GMT_MINUS_4_EASTERN_US:    return -4.0;
      case GMT_MINUS_4_GEORGETOWN:    return -4.0;
      case GMT_MINUS_4_INDIANA:       return -4.0;
      case GMT_MINUS_4_SANTIAGO:      return -4.0;
      case GMT_MINUS_3_ATLANTIC:      return -3.0;
      case GMT_MINUS_3_BRASILIA:      return -3.0;
      case GMT_MINUS_3_BUENOS_AIRES:  return -3.0;
      case GMT_MINUS_3_CAYENNE:       return -3.0;
      case GMT_MINUS_3_MONTEVIDEO:    return -3.0;
      case GMT_MINUS_2_30_NEWFOUNDLAND: return -2.5;
      case GMT_MINUS_2_GREENLAND:     return -2.0;
      case GMT_MINUS_1_CAPE_VERDE:    return -1.0;
      case GMT_0_AZORES:              return 0.0;
      case GMT_0_UTC:                 return 0.0;
      case GMT_0_MONROVIA:            return 0.0;
      case GMT_PLUS_1_CASABLANCA:     return 1.0;
      case GMT_PLUS_1_DUBLIN:         return 1.0;
      case GMT_PLUS_1_LAGOS:          return 1.0;
      case GMT_PLUS_1_WEST_AFRICA:    return 1.0;
      case GMT_PLUS_2_AMSTERDAM:      return 2.0;
      case GMT_PLUS_2_BELGRADE:       return 2.0;
      case GMT_PLUS_2_BRUSSELS:       return 2.0;
      case GMT_PLUS_2_CAIRO:          return 2.0;
      case GMT_PLUS_2_JOHANNESBURG:   return 2.0;
      case GMT_PLUS_2_SARAJEVO:       return 2.0;
      case GMT_PLUS_2_WINDHOEK:       return 2.0;
      case GMT_PLUS_3_AMMAN:          return 3.0;
      case GMT_PLUS_3_BAGHDAD:        return 3.0;
      case GMT_PLUS_3_BEIRUT:         return 3.0;
      case GMT_PLUS_3_DAMASCUS:       return 3.0;
      case GMT_PLUS_3_HELSINKI:       return 3.0;
      case GMT_PLUS_3_ISTANBUL:       return 3.0;
      case GMT_PLUS_3_JERUSALEM:      return 3.0;
      case GMT_PLUS_3_KUWAIT:         return 3.0;
      case GMT_PLUS_3_MOSCOW:         return 3.0;
      case GMT_PLUS_3_NAIROBI:        return 3.0;
      case GMT_PLUS_3_30_TEHRAN:      return 3.5;
      case GMT_PLUS_4_ABU_DHABI:      return 4.0;
      case GMT_PLUS_4_BAKU:           return 4.0;
      case GMT_PLUS_4_30_KABUL:       return 4.5;
      case GMT_PLUS_5_EKATERINBURG:   return 5.0;
      case GMT_PLUS_5_KARACHI:        return 5.0;
      case GMT_PLUS_5_30_CHENNAI:     return 5.5;
      case GMT_PLUS_5_30_COLOMBO:     return 5.5;
      case GMT_PLUS_5_45_KATHMANDU:   return 5.75;
      case GMT_PLUS_6_DHAKA:          return 6.0;
      case GMT_PLUS_6_30_YANGON:      return 6.5;
      case GMT_PLUS_7_BANGKOK:        return 7.0;
      case GMT_PLUS_8_BEIJING:        return 8.0;
      case GMT_PLUS_8_MANILA:         return 8.0;
      case GMT_PLUS_8_SINGAPORE:      return 8.0;
      case GMT_PLUS_9_OSAKA:          return 9.0;
      case GMT_PLUS_9_SEOUL:          return 9.0;
      case GMT_PLUS_9_30_ADELAIDE:    return 9.5;
      case GMT_PLUS_10_BRISBANE:      return 10.0;
      case GMT_PLUS_10_CANBERRA:      return 10.0;
      case GMT_PLUS_10_VLADIVOSTOK:   return 10.0;
      case GMT_PLUS_11_SOLOMON:       return 11.0;
      case GMT_PLUS_12_AUCKLAND:      return 12.0;
      case GMT_PLUS_12_ENIWETOK:      return 12.0;
      default:                        return 0.0;
   }
}

//+------------------------------------------------------------------+
//| 🔹 FUNCIÓN CORREGIDA: Configurar sesión de mercado con DST      |
//+------------------------------------------------------------------+
void SetupMarketSession()
{
   // Detectar si estamos en horario de verano para la fecha actual
   bool isDST = IsDaylightSavingTime(TimeCurrent(), InpMarketSession);
   
   switch(InpMarketSession)
   {
      case SESSION_SYDNEY:
         currentSession.name = "Sydney";
         if(isDST) // AEDT (UTC+11)
         {
            currentSession.startTime = "23:00";  // 10:00 AEDT
            currentSession.endTime = "05:00";    // 16:00 AEDT
         }
         else // AEST (UTC+10)
         {
            currentSession.startTime = "00:00";  // 10:00 AEST
            currentSession.endTime = "06:00";    // 16:00 AEST
         }
         currentSession.timezoneOffset = GetTimezoneOffset();
         currentSession.isDST = isDST;
         break;
         
      case SESSION_TOKYO:
         currentSession.name = "Tokyo";
         currentSession.startTime = "00:00";  // 09:00 JST
         currentSession.endTime = "06:00";    // 15:00 JST (sin lunch break para ORB)
         currentSession.timezoneOffset = GetTimezoneOffset();
         currentSession.isDST = false; // Japón no usa DST
         break;
         
      case SESSION_LONDON:
         currentSession.name = "London";
         if(isDST) // BST (UTC+1)
         {
            currentSession.startTime = "07:00";  // 08:00 BST
            currentSession.endTime = "15:30";    // 16:30 BST
         }
         else // GMT (UTC+0)
         {
            currentSession.startTime = "08:00";  // 08:00 GMT
            currentSession.endTime = "16:30";    // 16:30 GMT
         }
         currentSession.timezoneOffset = GetTimezoneOffset();
         currentSession.isDST = isDST;
         break;
         
      case SESSION_NEWYORK:
         currentSession.name = "New York";
         if(isDST) // EDT (UTC-4)
         {
            currentSession.startTime = "13:30";  // 09:30 EDT
            currentSession.endTime = "20:00";    // 16:00 EDT
         }
         else // EST (UTC-5)
         {
            currentSession.startTime = "14:30";  // 09:30 EST
            currentSession.endTime = "21:00";    // 16:00 EST
         }
         currentSession.timezoneOffset = GetTimezoneOffset();
         currentSession.isDST = isDST;
         break;
         
      case SESSION_FRANKFURT:
         currentSession.name = "Frankfurt";
         if(isDST) // CEST (UTC+2)
         {
            currentSession.startTime = "07:00";  // 09:00 CEST
            currentSession.endTime = "15:30";    // 17:30 CEST
         }
         else // CET (UTC+1)
         {
            currentSession.startTime = "08:00";  // 09:00 CET
            currentSession.endTime = "16:30";    // 17:30 CET
         }
         currentSession.timezoneOffset = GetTimezoneOffset();
         currentSession.isDST = isDST;
         break;
         
      case SESSION_CUSTOM:
      default:
         currentSession.name = "Custom";
         currentSession.startTime = "";
         currentSession.endTime = "";
         currentSession.timezoneOffset = GetTimezoneOffset();
         currentSession.isDST = false;
         break;
   }
   
   DebugPrint(StringFormat("📍 Market Session: %s (%s - %s UTC%+.1f) %s", 
      currentSession.name, currentSession.startTime, currentSession.endTime, 
      currentSession.timezoneOffset, isDST ? "[DST]" : "[STD]"));
}

//+------------------------------------------------------------------+
//| Obtener timeframe del gráfico en minutos                         |
//+------------------------------------------------------------------+
int GetChartTimeframeMinutes()
{
   ENUM_TIMEFRAMES tf = (ENUM_TIMEFRAMES)Period();
   
   switch(tf)
   {
      case PERIOD_M1:  return 1;
      case PERIOD_M2:  return 2;
      case PERIOD_M3:  return 3;
      case PERIOD_M4:  return 4;
      case PERIOD_M5:  return 5;
      case PERIOD_M6:  return 6;
      case PERIOD_M10: return 10;
      case PERIOD_M12: return 12;
      case PERIOD_M15: return 15;
      case PERIOD_M20: return 20;
      case PERIOD_M30: return 30;
      case PERIOD_H1:  return 60;
      case PERIOD_H2:  return 120;
      case PERIOD_H3:  return 180;
      case PERIOD_H4:  return 240;
      case PERIOD_H6:  return 360;
      case PERIOD_H8:  return 480;
      case PERIOD_H12: return 720;
      case PERIOD_D1:  return 1440;
      case PERIOD_W1:  return 10080;
      case PERIOD_MN1: return 43200;
      default: return 15;
   }
}

//+------------------------------------------------------------------+
//| Determinar si debe usar modo de primera vela                     |
//+------------------------------------------------------------------+
bool ShouldUseFirstCandleMode()
{
   if(orbPeriodMinutes == 0) return false;
   bool useFirstCandle = (chartTimeframeMinutes == orbPeriodMinutes);
   
   DebugPrint(StringFormat("📊 Chart TF: %d min, ORB Period: %d min → Mode: %s",
      chartTimeframeMinutes, orbPeriodMinutes, 
      useFirstCandle ? "FIRST CANDLE" : "RANGE"));
   
   return useFirstCandle;
}

//+------------------------------------------------------------------+
//| Calcular SMA de volumen                                          |
//+------------------------------------------------------------------+
void CalculateVolumeSMA(const long &volume[], int rates_total)
{
   ArrayResize(volumeSMA, rates_total);
   
   for(int i = 0; i < rates_total; i++)
   {
      if(i < volumePeriod)
      {
         volumeSMA[i] = 0;
         continue;
      }
      
      double sum = 0;
      for(int j = 0; j < volumePeriod; j++)
      {
         sum += (double)volume[i - j];
      }
      volumeSMA[i] = sum / volumePeriod;
   }
}

//+------------------------------------------------------------------+
//| Detectar breakout avanzado con confirmación                      |
//+------------------------------------------------------------------+
BreakoutData DetectAdvancedBreakout(const datetime &time[], const double &high[], 
                                   const double &low[], const double &close[], 
                                   const long &volume[], int index, const ORBData &orb)
{
   BreakoutData breakout;
   ZeroMemory(breakout);
   
   if(index < 2) return breakout;
   
   // 🔹 LÓGICA DE BREAKOUT AVANZADA (como en Pine Script)
   // highCrossBO = (low[2] < orbHighPrice and close[2] > orbHighPrice and low[1] > orbHighPrice and close[1] > orbHighPrice and close > low[1] and low > orbHighPrice)
   breakout.highCrossBO = (low[index-2] < orb.high && close[index-2] > orb.high && 
                          low[index-1] > orb.high && close[index-1] > orb.high && 
                          close[index] > low[index-1] && low[index] > orb.high);
   
   // lowCrossBO = (high[2] > orbLowPrice and close[2] < orbLowPrice and high[1] < orbLowPrice and close[1] < orbLowPrice and close < high[1] and high < orbLowPrice)
   breakout.lowCrossBO = (high[index-2] > orb.low && close[index-2] < orb.low && 
                         high[index-1] < orb.low && close[index-1] < orb.low && 
                         close[index] < high[index-1] && high[index] < orb.low);
   
   // 🔹 CRUCES SIMPLES
   breakout.highCross = (close[index-1] <= orb.high && close[index] > orb.high);
   breakout.lowCross = (close[index-1] >= orb.low && close[index] < orb.low);
   
   // 🔹 DETECCIÓN DE RETESTS
   breakout.isRetestOrbHigh = (close[index-1] > orb.high && low[index] <= orb.high && close[index] >= orb.high);
   breakout.isRetestOrbLow = (close[index-1] < orb.low && high[index] >= orb.low && close[index] <= orb.low);
   
   // 🔹 CONFIRMACIÓN DE VOLUMEN (si está habilitada)
   if(InpUseVolumeConfirmation && index < ArraySize(volumeSMA))
   {
      breakout.volumeSpike = ((double)volume[index-2] > volumeSMA[index-2] || 
                             (double)volume[index-1] > volumeSMA[index-1] || 
                             (double)volume[index] > volumeSMA[index]);
   }
   else
   {
      breakout.volumeSpike = true; // Si no usamos volumen, siempre es true
   }
   
   return breakout;
}

//+------------------------------------------------------------------+
//| Inicialización del Indicador                                     |
//+------------------------------------------------------------------+
int OnInit()
{
   SetupMarketSession();
   chartTimeframeMinutes = GetChartTimeframeMinutes();
   volumePeriod = InpVolumePeriod;
   
   if(InpORBPeriod == ORB_CUSTOM)
   {
      orbPeriodMinutes = 0;
      DebugPrint("Using CUSTOM time period: " + InpCustomTime);
   }
   else
   {
      orbPeriodMinutes = (int)InpORBPeriod;
      DebugPrint("Using predefined period: " + IntegerToString(orbPeriodMinutes) + " minutes");
   }
   
   bool firstCandleMode = ShouldUseFirstCandleMode();
   
   string indicatorName = StringFormat("ORB%s_%s_%s%s%s%s", 
      (orbPeriodMinutes > 0) ? IntegerToString(orbPeriodMinutes) : "Custom",
      currentSession.name,
      firstCandleMode ? "1C" : "RANGE",
      currentSession.isDST ? "_DST" : "_STD",
      InpShowFibTargets ? "_FIB" : "",
      InpUseVolumeConfirmation ? "_VOL" : "");
   IndicatorSetString(INDICATOR_SHORTNAME, indicatorName);
   
   ArrayResize(orbDataArray, 0);
   
   Print("🚀 ORB Indicator initialized - Version 2.1 WITH DST SUPPORT");
   Print("📊 Chart Timeframe: ", chartTimeframeMinutes, " minutes");
   Print("📊 ORB Period: ", orbPeriodMinutes, " minutes");
   Print("📍 Market Session: ", currentSession.name);
   Print("🎯 Mode: ", firstCandleMode ? "FIRST CANDLE" : "FULL RANGE");
   Print("🌍 Timezone: ", EnumToString(InpTimeZone), " (UTC", currentSession.timezoneOffset, ")");
   Print("⏰ DST Status: ", currentSession.isDST ? "DAYLIGHT SAVING TIME" : "STANDARD TIME");
   Print("📦 Shaded Box: ", InpShowShadedBox ? "ENABLED" : "DISABLED");
   Print("📐 Fibonacci Targets: ", InpShowFibTargets ? "ENABLED" : "DISABLED");
   Print("📊 Volume Confirmation: ", InpUseVolumeConfirmation ? "ENABLED" : "DISABLED");
   
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Desinicialización del Indicador                                  |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   DeleteAllORBObjects();
   Print("👋 ORB Indicator deinitialized");
}

//+------------------------------------------------------------------+
//| Función principal de cálculo                                     |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   if(rates_total < 100) return(0);
   
   // 🔹 CALCULAR SMA DE VOLUMEN SI ESTÁ HABILITADO
   if(InpUseVolumeConfirmation)
   {
      CalculateVolumeSMA(volume, rates_total);
   }
   
   CalculateAllORBs(time, high, low, rates_total);
   DrawAllORBElements();
   
   // 🔹 DETECTAR BREAKOUTS EN TIEMPO REAL
   DetectRealtimeBreakouts(time, high, low, close, volume, rates_total);
   
   return(rates_total);
}

//+------------------------------------------------------------------+
//| Detectar breakouts en tiempo real                                |
//+------------------------------------------------------------------+
void DetectRealtimeBreakouts(const datetime &time[], const double &high[], 
                            const double &low[], const double &close[], 
                            const long &volume[], int rates_total)
{
   if(rates_total < 3) return;
   
   // Buscar ORB del día actual
   ORBData currentORB;
   bool foundCurrentORB = false;
   
   int arraySize = ArraySize(orbDataArray);
   for(int i = arraySize - 1; i >= 0; i--)
   {
      if(IsToday(orbDataArray[i].date) && orbDataArray[i].calculated)
      {
         currentORB = orbDataArray[i];
         foundCurrentORB = true;
         break;
      }
   }
   
   if(!foundCurrentORB) return;
   
   // Detectar breakouts en la vela actual
   int currentIndex = rates_total - 1;
   BreakoutData breakout = DetectAdvancedBreakout(time, high, low, close, volume, currentIndex, currentORB);
   
   // 🔹 PROCESAR ALERTAS
   ProcessBreakoutAlerts(breakout, currentORB, time[currentIndex]);
   
   // 🔹 ACTUALIZAR ESTADO DE BREAKOUT
   UpdateBreakoutState(breakout, currentORB);
}

//+------------------------------------------------------------------+
//| Procesar alertas de breakout                                     |
//+------------------------------------------------------------------+
void ProcessBreakoutAlerts(const BreakoutData &breakout, const ORBData &orb, datetime currentTime)
{
   // Evitar alertas duplicadas en la misma vela
   if(currentTime == lastAlertTime) return;
   
   string orbName = StringFormat("ORB%s_%s", 
      (orbPeriodMinutes > 0) ? IntegerToString(orbPeriodMinutes) : "Custom",
      currentSession.name);
   
   if(!InpAlertBreakoutsOnly)
   {
      // Alertas para cruces simples
      if(breakout.highCross)
      {
         string message = StringFormat("%s: Price crossing HIGH level %.5f", orbName, orb.high);
         SendORBAlert(message);
         lastAlertTime = currentTime;
      }
      
      if(breakout.lowCross)
      {
         string message = StringFormat("%s: Price crossing LOW level %.5f", orbName, orb.low);
         SendORBAlert(message);
         lastAlertTime = currentTime;
      }
   }
   else
   {
      // Alertas solo para breakouts confirmados
      if(breakout.highCrossBO && breakout.volumeSpike)
      {
         string message = StringFormat("%s: BREAKOUT above HIGH %.5f - Look for Retest", orbName, orb.high);
         SendORBAlert(message);
         lastAlertTime = currentTime;
      }
      
      if(breakout.lowCrossBO && breakout.volumeSpike)
      {
         string message = StringFormat("%s: BREAKOUT below LOW %.5f - Look for Retest", orbName, orb.low);
         SendORBAlert(message);
      }
   }
   
   // 🔹 ALERTAS DE RETEST
   if(breakout.isRetestOrbHigh)
   {
      string message = StringFormat("%s: RETEST of HIGH level %.5f", orbName, orb.high);
      SendORBAlert(message);
   }
   
   if(breakout.isRetestOrbLow)
   {
      string message = StringFormat("%s: RETEST of LOW level %.5f", orbName, orb.low);
      SendORBAlert(message);
   }
}

//+------------------------------------------------------------------+
//| Actualizar estado de breakout                                    |
//+------------------------------------------------------------------+
void UpdateBreakoutState(const BreakoutData &breakout, const ORBData &orb)
{
   // Lógica similar al Pine Script para tracking de breakouts
   if(breakout.highCrossBO || breakout.lowCrossBO)
   {
      currentInBreakout = true;
   }
   
   if(currentInBreakout && (breakout.isRetestOrbHigh || breakout.isRetestOrbLow || breakout.failedRetest))
   {
      currentInBreakout = false;
   }
}

//+------------------------------------------------------------------+
//| Calcular ORBs para todos los días                                |
//+------------------------------------------------------------------+
void CalculateAllORBs(const datetime &time[], const double &high[], const double &low[], int rates_total)
{
   ArrayResize(orbDataArray, 0);
   
   datetime firstVisibleTime = time[MathMax(0, rates_total - 1000)];
   datetime lastTime = time[rates_total - 1];
   
   MqlDateTime dtFirst, dtLast;
   TimeToStruct(firstVisibleTime, dtFirst);
   TimeToStruct(lastTime, dtLast);
   
   DebugPrint("Processing dates from " + TimeToString(firstVisibleTime) + " to " + TimeToString(lastTime));
   
   int daysProcessed = 0;
   for(datetime currentDate = StringToTime(StringFormat("%04d.%02d.%02d", dtFirst.year, dtFirst.mon, dtFirst.day));
       currentDate <= StringToTime(StringFormat("%04d.%02d.%02d", dtLast.year, dtLast.mon, dtLast.day));
       currentDate += 86400)
   {
      MqlDateTime dt;
      TimeToStruct(currentDate, dt);
      if(dt.day_of_week == 0 || dt.day_of_week == 6) continue;
      
      ORBData orb;
      if(CalculateORBForDate(currentDate, time, high, low, rates_total, orb))
      {
         int size = ArraySize(orbDataArray);
         ArrayResize(orbDataArray, size + 1);
         orbDataArray[size] = orb;
         daysProcessed++;
         
         DebugPrint(StringFormat("✅ ORB calculated for %s: H=%.5f, L=%.5f, Range=%.5f, Bars=%d, Mode=%s",
            TimeToString(currentDate, TIME_DATE), orb.high, orb.low, orb.range, orb.barsFound,
            orb.isFirstCandleMode ? "FirstCandle" : "Range"));
      }
   }
   
   Print("📈 Calculated ORBs for ", daysProcessed, " days");
}

//+------------------------------------------------------------------+
//| 🔹 FUNCIÓN MEJORADA: Calcular ORB para una fecha específica con DST |
//+------------------------------------------------------------------+
bool CalculateORBForDate(datetime date, const datetime &time[], const double &high[], 
                        const double &low[], int rates_total, ORBData &orb)
{
   datetime sessionStart, sessionEnd;
   GetORBSessionForDate(date, sessionStart, sessionEnd);
   
   orb.date = date;
   orb.startTime = sessionStart;
   orb.endTime = sessionEnd;
   orb.high = 0.0;
   orb.low = DBL_MAX;
   orb.calculated = false;
   orb.barsFound = 0;
   orb.candleTime = 0;
   orb.inBreakout = false;
   orb.breakoutDirection = 0;
   orb.breakoutTime = 0;
   orb.breakoutPrice = 0;
   
   bool useFirstCandle = ShouldUseFirstCandleMode();
   orb.isFirstCandleMode = useFirstCandle;
   
   if(useFirstCandle)
   {
      DebugPrint("🕯️ Using FIRST CANDLE mode for " + TimeToString(date, TIME_DATE));
      return FindFirstCandleORB(time, high, low, rates_total, sessionStart, orb);
   }
   else
   {
      DebugPrint("📊 Using RANGE mode for " + TimeToString(date, TIME_DATE));
      return FindRangeORB(time, high, low, rates_total, sessionStart, sessionEnd, orb);
   }
}

//+------------------------------------------------------------------+
//| Buscar ORB de la primera vela solamente                          |
//+------------------------------------------------------------------+
bool FindFirstCandleORB(const datetime &time[], const double &high[], const double &low[], 
                       int rates_total, datetime sessionStart, ORBData &orb)
{
   int bestIndex = -1;
   int minTimeDiff = INT_MAX;
   
   for(int i = 0; i < rates_total; i++)
   {
      int timeDiff = (int)MathAbs(time[i] - sessionStart);
      
      if(timeDiff < minTimeDiff)
      {
         minTimeDiff = timeDiff;
         bestIndex = i;
      }
      
      if(timeDiff == 0) break;
   }
   
   if(bestIndex >= 0 && minTimeDiff <= 300)
   {
      orb.high = high[bestIndex];
      orb.low = low[bestIndex];
      orb.range = orb.high - orb.low;
      orb.calculated = true;
      orb.barsFound = 1;
      orb.candleTime = time[bestIndex];
      
      DebugPrint(StringFormat("🎯 Found FIRST CANDLE at %s: H=%.5f, L=%.5f, TimeDiff=%d sec",
         TimeToString(time[bestIndex]), high[bestIndex], low[bestIndex], minTimeDiff));
      
      return true;
   }
   
   DebugPrint("❌ No suitable first candle found near " + TimeToString(sessionStart));
   return false;
}

//+------------------------------------------------------------------+
//| Buscar ORB en rango completo                                     |
//+------------------------------------------------------------------+
bool FindRangeORB(const datetime &time[], const double &high[], const double &low[], 
                 int rates_total, datetime sessionStart, datetime sessionEnd, ORBData &orb)
{
   bool foundData = false;
   
   DebugPrint(StringFormat("🔍 Searching RANGE from %s to %s", 
      TimeToString(sessionStart), TimeToString(sessionEnd)));
   
   for(int i = 0; i < rates_total; i++)
   {
      if(time[i] >= sessionStart && time[i] <= sessionEnd)
      {
         if(!foundData)
         {
            orb.high = high[i];
            orb.low = low[i];
            foundData = true;
            orb.candleTime = time[i];
            
            DebugPrint(StringFormat("📍 First bar in range at %s: H=%.5f, L=%.5f", 
               TimeToString(time[i]), high[i], low[i]));
         }
         else
         {
            if(high[i] > orb.high) 
            {
               orb.high = high[i];
               DebugPrint(StringFormat("⬆️ New HIGH: %.5f at %s", high[i], TimeToString(time[i])));
            }
            if(low[i] < orb.low) 
            {
               orb.low = low[i];
               DebugPrint(StringFormat("⬇️ New LOW: %.5f at %s", low[i], TimeToString(time[i])));
            }
         }
         orb.barsFound++;
      }
   }
   
   if(foundData && orb.barsFound > 0)
   {
      orb.range = orb.high - orb.low;
      orb.calculated = true;
      
      DebugPrint(StringFormat("✅ RANGE ORB complete: H=%.5f, L=%.5f, Range=%.5f, Bars=%d",
         orb.high, orb.low, orb.range, orb.barsFound));
      
      return true;
   }
   
   DebugPrint("❌ No data found in range");
   return false;
}

//+------------------------------------------------------------------+
//| 🔹 FUNCIÓN MEJORADA: Obtener horarios de sesión con DST         |
//+------------------------------------------------------------------+
void GetORBSessionForDate(datetime date, datetime &startTime, datetime &endTime)
{
   MqlDateTime dt;
   TimeToStruct(date, dt);
   
   string sessionStart, sessionEnd;
   double timezoneOffset = currentSession.timezoneOffset;
   
   // 🔹 DETECTAR DST PARA LA FECHA ESPECÍFICA
   bool isDST = IsDaylightSavingTime(date, InpMarketSession);
   
   if(InpMarketSession == SESSION_CUSTOM)
   {
      if(orbPeriodMinutes == 0)
      {
         string times[];
         if(StringSplit(InpCustomTime, '-', times) == 2)
         {
            sessionStart = times[0];
            sessionEnd = times[1];
         }
         else
         {
            sessionStart = "09:30";
            sessionEnd = "09:45";
         }
      }
      else
      {
         sessionStart = "09:30";
         switch(orbPeriodMinutes)
         {
            case 5:  sessionEnd = "09:35"; break;
            case 15: sessionEnd = "09:45"; break;
            case 30: sessionEnd = "10:00"; break;
            default: sessionEnd = "09:45"; break;
         }
      }
   }
   else
   {
      // 🔹 USAR HORARIOS AJUSTADOS POR DST
      switch(InpMarketSession)
      {
         case SESSION_SYDNEY:
            if(isDST) // AEDT
            {
               sessionStart = "23:00";  // 10:00 AEDT
               sessionEnd = "05:00";    // 16:00 AEDT
            }
            else // AEST
            {
               sessionStart = "00:00";  // 10:00 AEST
               sessionEnd = "06:00";    // 16:00 AEST
            }
            break;
            
         case SESSION_TOKYO:
            sessionStart = "00:00";  // 09:00 JST
            sessionEnd = "06:00";    // 15:00 JST
            break;
            
         case SESSION_LONDON:
            if(isDST) // BST
            {
               sessionStart = "07:00";  // 08:00 BST
               sessionEnd = "15:30";    // 16:30 BST
            }
            else // GMT
            {
               sessionStart = "08:00";  // 08:00 GMT
               sessionEnd = "16:30";    // 16:30 GMT
            }
            break;
            
         case SESSION_NEWYORK:
            if(isDST) // EDT
            {
               sessionStart = "13:30";  // 09:30 EDT
               sessionEnd = "20:00";    // 16:00 EDT
            }
            else // EST
            {
               sessionStart = "14:30";  // 09:30 EST
               sessionEnd = "21:00";    // 16:00 EST
            }
            break;
            
         case SESSION_FRANKFURT:
            if(isDST) // CEST
            {
               sessionStart = "07:00";  // 09:00 CEST
               sessionEnd = "15:30";    // 17:30 CEST
            }
            else // CET
            {
               sessionStart = "08:00";  // 09:00 CET
               sessionEnd = "16:30";    // 17:30 CET
            }
            break;
      }
      
      // 🔹 AJUSTAR SEGÚN PERÍODO ORB
      if(orbPeriodMinutes > 0)
      {
         string startParts[];
         StringSplit(sessionStart, ':', startParts);
         int startHour = (int)StringToInteger(startParts[0]);
         int startMinute = (int)StringToInteger(startParts[1]);
         int totalStartMinutes = startHour * 60 + startMinute;
         
         int totalEndMinutes = totalStartMinutes + orbPeriodMinutes;
         
         int endHour = totalEndMinutes / 60;
         int endMinute = totalEndMinutes % 60;
         
         if(endHour >= 24)
         {
            endHour -= 24;
         }
         
         sessionEnd = StringFormat("%02d:%02d", endHour, endMinute);
      }
   }
   
   string dateStr = StringFormat("%04d.%02d.%02d", dt.year, dt.mon, dt.day);
   startTime = StringToTime(dateStr + " " + sessionStart) + (int)(timezoneOffset * 3600);
   
   // 🔹 MANEJAR CRUCE DE MEDIANOCHE PARA SYDNEY
   if(InpMarketSession == SESSION_SYDNEY && isDST && StringCompare(sessionEnd, "05:00") == 0)
   {
      datetime nextDay = date + 86400;
      MqlDateTime dtNext;
      TimeToStruct(nextDay, dtNext);
      string nextDayStr = StringFormat("%04d.%02d.%02d", dtNext.year, dtNext.mon, dtNext.day);
      endTime = StringToTime(nextDayStr + " " + sessionEnd) + (int)(timezoneOffset * 3600);
   }
   else
   {
      endTime = StringToTime(dateStr + " " + sessionEnd) + (int)(timezoneOffset * 3600);
   }
   
   DebugPrint(StringFormat("📅 Session for %s (%s): %s to %s (UTC%+.1f) %s", 
      dateStr, currentSession.name, TimeToString(startTime), TimeToString(endTime), 
      timezoneOffset, isDST ? "[DST]" : "[STD]"));
}

//+------------------------------------------------------------------+
//| Dibujar todos los elementos ORB                                  |
//+------------------------------------------------------------------+
void DrawAllORBElements()
{
   DeleteAllORBObjects();
   
   int arraySize = ArraySize(orbDataArray);
   if(arraySize == 0) 
   {
      DebugPrint("⚠️ No ORB data to draw");
      return;
   }
   
   for(int i = 0; i < arraySize; i++)
   {
      if(!orbDataArray[i].calculated) continue;
      
      bool isToday = IsToday(orbDataArray[i].date);
      if(!InpShowPreviousDays && !isToday) continue;
      
      DrawORBForDay(orbDataArray[i], i);
   }
}

//+------------------------------------------------------------------+
//| Dibujar ORB para un día específico                               |
//+------------------------------------------------------------------+
void DrawORBForDay(const ORBData &orb, int dayIndex)
{
   string suffix = "_" + IntegerToString(dayIndex);
   datetime lineEndTime = orb.endTime + 86400;
   
   datetime boxStartTime = orb.isFirstCandleMode ? orb.candleTime : orb.startTime;
   
   // 🔹 CAJA SOMBREADA
   if(InpShowShadedBox)
   {
      string boxName = orbPrefix + "Box" + suffix;
      ObjectDelete(0, boxName);
      
      if(ObjectCreate(0, boxName, OBJ_RECTANGLE, 0, boxStartTime, orb.high, lineEndTime, orb.low))
      {
         ObjectSetInteger(0, boxName, OBJPROP_COLOR, InpShadeColor);
         ObjectSetInteger(0, boxName, OBJPROP_STYLE, STYLE_SOLID);
         ObjectSetInteger(0, boxName, OBJPROP_WIDTH, InpBoxBorderSize);
         ObjectSetInteger(0, boxName, OBJPROP_FILL, true);
         ObjectSetInteger(0, boxName, OBJPROP_BACK, true);
         ObjectSetInteger(0, boxName, OBJPROP_SELECTED, false);
         ObjectSetInteger(0, boxName, OBJPROP_SELECTABLE, false);
      }
   }
   
   // 🔹 LÍNEAS ORB
   DrawORBLine("High" + suffix, orb.endTime, lineEndTime, orb.high, InpORBHighColor);
   DrawORBLine("Low" + suffix, orb.endTime, lineEndTime, orb.low, InpORBLowColor);
   
   // 🔹 OBJETIVOS DE PRECIO
   if(InpShowPriceTargets)
      DrawPriceTargetsForDay(orb, suffix, lineEndTime);
   
   // 🔹 OBJETIVOS FIBONACCI
   if(InpShowFibTargets)
      DrawFibonacciTargetsForDay(orb, suffix, lineEndTime);
   
   // 🔹 PUNTO MEDIO
   if(InpShowMidPoint)
      DrawMidPointForDay(orb, suffix, lineEndTime);
   
   // 🔹 ETIQUETAS
   if(InpShowLabels && IsToday(orb.date))
      DrawLabelsForDay(orb, suffix);
}

//+------------------------------------------------------------------+
//| Dibujar línea ORB                                                |
//+------------------------------------------------------------------+
void DrawORBLine(string name, datetime startTime, datetime endTime, double price, color lineColor)
{
   string objName = orbPrefix + name;
   if(ObjectCreate(0, objName, OBJ_TREND, 0, startTime, price, endTime, price))
   {
      ObjectSetInteger(0, objName, OBJPROP_COLOR, lineColor);
      ObjectSetInteger(0, objName, OBJPROP_STYLE, InpLineStyle);
      ObjectSetInteger(0, objName, OBJPROP_WIDTH, InpLineWidth);
      ObjectSetInteger(0, objName, OBJPROP_RAY_RIGHT, false);
      ObjectSetInteger(0, objName, OBJPROP_SELECTED, false);
      ObjectSetInteger(0, objName, OBJPROP_SELECTABLE, false);
   }
}

//+------------------------------------------------------------------+
//| Dibujar objetivos de precio                                      |
//+------------------------------------------------------------------+
void DrawPriceTargetsForDay(const ORBData &orb, string suffix, datetime endTime)
{
   DrawTargetLineForDay("Target_High_50" + suffix, orb.high + (orb.range * 0.5), InpTarget50Color, endTime);
   DrawTargetLineForDay("Target_High_100" + suffix, orb.high + (orb.range * 1.0), InpTarget100Color, endTime);
   DrawTargetLineForDay("Target_Low_50" + suffix, orb.low - (orb.range * 0.5), InpTarget50Color, endTime);
   DrawTargetLineForDay("Target_Low_100" + suffix, orb.low - (orb.range * 1.0), InpTarget100Color, endTime);
   
   if(InpShowExtendedTargets)
   {
      double multipliers[] = {1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0};
      for(int i = 0; i < ArraySize(multipliers); i++)
      {
         DrawTargetLineForDay("Target_High_" + DoubleToString(multipliers[i], 1) + suffix, 
                             orb.high + (orb.range * multipliers[i]), InpTargetOtherColor, endTime);
         DrawTargetLineForDay("Target_Low_" + DoubleToString(multipliers[i], 1) + suffix, 
                             orb.low - (orb.range * multipliers[i]), InpTargetOtherColor, endTime);
      }
   }
}

//+------------------------------------------------------------------+
//| Dibujar objetivos Fibonacci                                      |
//+------------------------------------------------------------------+
void DrawFibonacciTargetsForDay(const ORBData &orb, string suffix, datetime endTime)
{
   // 🔹 NIVELES FIBONACCI: 27.2% y 61.8%
   DrawTargetLineForDay("Fib_High_272" + suffix, orb.high + (orb.range * 0.272), InpFibColor, endTime);
   DrawTargetLineForDay("Fib_High_618" + suffix, orb.high + (orb.range * 0.618), InpFibColor, endTime);
   DrawTargetLineForDay("Fib_Low_272" + suffix, orb.low - (orb.range * 0.272), InpFibColor, endTime);
   DrawTargetLineForDay("Fib_Low_618" + suffix, orb.low - (orb.range * 0.618), InpFibColor, endTime);
   
   // 🔹 ETIQUETAS FIBONACCI (solo para el día actual)
   if(IsToday(orb.date))
   {
      DrawPriceTargetLabel(orb.high, 0.272, "FIB 27.2%", InpFibColor, suffix);
      DrawPriceTargetLabel(orb.high, 0.618, "FIB 61.8%", InpFibColor, suffix);
      DrawPriceTargetLabel(orb.low, -0.272, "FIB 27.2%", InpFibColor, suffix);
      DrawPriceTargetLabel(orb.low, -0.618, "FIB 61.8%", InpFibColor, suffix);
   }
}

//+------------------------------------------------------------------+
//| Dibujar línea de objetivo                                        |
//+------------------------------------------------------------------+
void DrawTargetLineForDay(string name, double price, color lineColor, datetime endTime)
{
   string objName = orbPrefix + name;
   datetime startTime = endTime - 86400;
   
   if(ObjectCreate(0, objName, OBJ_TREND, 0, startTime, price, endTime, price))
   {
      ObjectSetInteger(0, objName, OBJPROP_COLOR, lineColor);
      ObjectSetInteger(0, objName, OBJPROP_STYLE, STYLE_DOT);
      ObjectSetInteger(0, objName, OBJPROP_WIDTH, 1);
      ObjectSetInteger(0, objName, OBJPROP_RAY_RIGHT, false);
      ObjectSetInteger(0, objName, OBJPROP_SELECTED, false);
      ObjectSetInteger(0, objName, OBJPROP_SELECTABLE, false);
   }
}

//+------------------------------------------------------------------+
//| Dibujar punto medio                                              |
//+------------------------------------------------------------------+
void DrawMidPointForDay(const ORBData &orb, string suffix, datetime endTime)
{
   double midPrice = orb.low + (orb.range * 0.5);
   DrawTargetLineForDay("MidPoint" + suffix, midPrice, InpMidPointColor, endTime);
}

//+------------------------------------------------------------------+
//| Dibujar etiqueta de objetivo de precio                           |
//+------------------------------------------------------------------+
void DrawPriceTargetLabel(double fromPrice, double level, string name, color labelColor, string suffix)
{
   double targetPrice = fromPrice + (level * (ArraySize(orbDataArray) > 0 ? orbDataArray[ArraySize(orbDataArray)-1].range : 10.0));
   
   string labelName = orbPrefix + "Label_" + name + suffix;
   datetime labelTime = TimeCurrent() + 3600; // 1 hora en el futuro
   
   if(ObjectCreate(0, labelName, OBJ_TEXT, 0, labelTime, targetPrice))
   {
      string orbName = StringFormat("ORB%s_%s", 
         (orbPeriodMinutes > 0) ? IntegerToString(orbPeriodMinutes) : "Custom",
         currentSession.name);
      
      ObjectSetString(0, labelName, OBJPROP_TEXT, orbName + " " + name);
      ObjectSetInteger(0, labelName, OBJPROP_COLOR, labelColor);
      ObjectSetInteger(0, labelName, OBJPROP_FONTSIZE, 8);
      ObjectSetString(0, labelName, OBJPROP_FONT, "Arial Bold");
      ObjectSetInteger(0, labelName, OBJPROP_SELECTED, false);
      ObjectSetInteger(0, labelName, OBJPROP_SELECTABLE, false);
   }
}

//+------------------------------------------------------------------+
//| Dibujar etiquetas                                                |
//+------------------------------------------------------------------+
void DrawLabelsForDay(const ORBData &orb, string suffix)
{
   string orbName = StringFormat("ORB%s_%s%s", 
      (orbPeriodMinutes > 0) ? IntegerToString(orbPeriodMinutes) : "Custom",
      currentSession.name,
      orb.isFirstCandleMode ? "_1C" : "");
   
   string labelHighName = orbPrefix + "Label_High" + suffix;
   if(ObjectCreate(0, labelHighName, OBJ_TEXT, 0, orb.endTime + 600, orb.high))
   {
      ObjectSetString(0, labelHighName, OBJPROP_TEXT, orbName + " HIGH");
      ObjectSetInteger(0, labelHighName, OBJPROP_COLOR, InpORBHighColor);
      ObjectSetInteger(0, labelHighName, OBJPROP_FONTSIZE, 9);
      ObjectSetString(0, labelHighName, OBJPROP_FONT, "Arial Bold");
      ObjectSetInteger(0, labelHighName, OBJPROP_SELECTED, false);
      ObjectSetInteger(0, labelHighName, OBJPROP_SELECTABLE, false);
   }
   
   string labelLowName = orbPrefix + "Label_Low" + suffix;
   if(ObjectCreate(0, labelLowName, OBJ_TEXT, 0, orb.endTime + 600, orb.low))
   {
      ObjectSetString(0, labelLowName, OBJPROP_TEXT, orbName + " LOW");
      ObjectSetInteger(0, labelLowName, OBJPROP_COLOR, InpORBLowColor);
      ObjectSetInteger(0, labelLowName, OBJPROP_FONTSIZE, 9);
      ObjectSetString(0, labelLowName, OBJPROP_FONT, "Arial Bold");
      ObjectSetInteger(0, labelLowName, OBJPROP_SELECTED, false);
      ObjectSetInteger(0, labelLowName, OBJPROP_SELECTABLE, false);
   }
   
   // 🔹 ETIQUETAS DE OBJETIVOS BÁSICOS
   if(InpShowPriceTargets)
   {
      DrawPriceTargetLabel(orb.high, 0.5, "PT 50%", InpTarget50Color, suffix);
      DrawPriceTargetLabel(orb.high, 1.0, "PT 100%", InpTarget100Color, suffix);
      DrawPriceTargetLabel(orb.low, -0.5, "PT 50%", InpTarget50Color, suffix);
      DrawPriceTargetLabel(orb.low, -1.0, "PT 100%", InpTarget100Color, suffix);
      
      if(InpShowExtendedTargets)
      {
         double multipliers[] = {1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0};
         for(int i = 0; i < ArraySize(multipliers); i++)
         {
            string ptName = StringFormat("PT %.0f%%", multipliers[i] * 100);
            DrawPriceTargetLabel(orb.high, multipliers[i], ptName, InpTargetOtherColor, suffix);
            DrawPriceTargetLabel(orb.low, -multipliers[i], ptName, InpTargetOtherColor, suffix);
         }
      }
   }
   
   // 🔹 PUNTO MEDIO
   if(InpShowMidPoint)
   {
      DrawPriceTargetLabel(orb.low, 0.5, "MIDPOINT", InpMidPointColor, suffix);
   }
}

//+------------------------------------------------------------------+
//| Verificar si es hoy                                              |
//+------------------------------------------------------------------+
bool IsToday(datetime date)
{
   datetime today = StringToTime(TimeToString(TimeCurrent(), TIME_DATE));
   datetime checkDate = StringToTime(TimeToString(date, TIME_DATE));
   return today == checkDate;
}

//+------------------------------------------------------------------+
//| Eliminar todos los objetos ORB                                   |
//+------------------------------------------------------------------+
void DeleteAllORBObjects()
{
   for(int i = ObjectsTotal(0) - 1; i >= 0; i--)
   {
      string objName = ObjectName(0, i);
      if(StringFind(objName, orbPrefix) == 0)
         ObjectDelete(0, objName);
   }
}

//+------------------------------------------------------------------+
//| Enviar alerta ORB                                                |
//+------------------------------------------------------------------+
void SendORBAlert(string message)
{
   Alert("🔔 ORB Alert: " + message);
   Print("🔔 ORB Alert: " + message);
   
   // 🔹 OPCIONAL: Enviar notificación push si está habilitado
   if(TerminalInfoInteger(TERMINAL_NOTIFICATIONS_ENABLED))
   {
      SendNotification("ORB: " + message);
   }
}

//+------------------------------------------------------------------+
//| Timer                                                            |
//+------------------------------------------------------------------+
void OnTimer() 
{
   // Implementar lógica de timer si es necesario
}

//+------------------------------------------------------------------+
//| Eventos del gráfico                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
   if(id == CHARTEVENT_OBJECT_CLICK)
   {
      DebugPrint("Objeto clickeado: " + sparam);
   }
}