//+------------------------------------------------------------------+
//| DinexSpace | Session Boxes                                        |
//| Draws the Asia (Tokyo), Europe (London) and US (New York)        |
//| sessions as boxes spanning each session's high and low.          |
//| Session hours are entered in each market's local time; London    |
//| and New York daylight saving is applied automatically.           |
//+------------------------------------------------------------------+
#property copyright   "(c) 2026 DinexSpace"
#property version     "1.00"
#property description "Asia, Europe and US trading sessions as boxes with their high-low range."
#property description "Hours are in each market's local time; daylight saving is handled automatically."
#property strict
#property indicator_chart_window
#property indicator_buffers 0
#property indicator_plots   0

//--- server time handling
enum ENUM_SERVER_TZ
  {
   SERVER_AUTO_US_DST = 0, // Auto, broker shifts with US DST (most brokers)
   SERVER_AUTO_FIXED  = 1, // Auto, fixed offset all year
   SERVER_MANUAL      = 2  // Manual offset (below)
  };

enum ENUM_RANGE_UNIT
  {
   UNIT_PRICE  = 0, // Price
   UNIT_POINTS = 1, // Points
   UNIT_PIPS   = 2  // Pips (forex)
  };

input group "Sessions (hours in each market's local time)"
input bool   InpShowAsia   = true;           // Show Asia (Tokyo, UTC+9)
input int    InpAsiaStart  = 900;            // Asia start (HHMM)
input int    InpAsiaEnd    = 1800;           // Asia end (HHMM)
input color  InpAsiaColor  = C'60,50,120';   // Asia colour
input bool   InpShowLondon = true;           // Show Europe (London, UK daylight saving)
input int    InpLonStart   = 800;            // Europe start (HHMM)
input int    InpLonEnd     = 1700;           // Europe end (HHMM)
input color  InpLonColor   = C'110,80,0';    // Europe colour
input bool   InpShowNY     = true;           // Show US (New York, US daylight saving)
input int    InpNYStart    = 800;            // US start (HHMM)
input int    InpNYEnd      = 1700;           // US end (HHMM)
input color  InpNYColor    = C'110,40,70';   // US colour

input group "Server time"
input ENUM_SERVER_TZ InpServerTz     = SERVER_AUTO_US_DST; // Server time zone
input double         InpServerOffset = 2.0;                // Manual server offset from UTC (hours)

input group "Display"
input bool            InpFill     = true;         // Fill boxes (drawn behind candles)
input bool            InpLabels   = true;         // Label with name and range
input ENUM_RANGE_UNIT InpUnit     = UNIT_PRICE;   // Range unit
input bool            InpMidLine  = false;        // Mid-line (50% of range)
input int             InpKeep     = 20;           // Sessions to keep on chart (each)
input int             InpMaxBars  = 5000;         // Bars to scan
input bool            InpPanel    = true;         // Status panel
input ENUM_BASE_CORNER InpCorner  = CORNER_RIGHT_UPPER; // Panel corner

#define NS 3
const string PFX = "DNXSB_";

string   g_name[NS]  = {"Asia", "London", "New York"};
bool     g_show[NS];
int      g_start[NS], g_end[NS];          // minutes of day, local
color    g_col[NS];
datetime g_key[NS];                       // start time (UTC) of the session being tracked
datetime g_t0[NS];                        // server time of first bar of that session
double   g_hi[NS], g_lo[NS];
bool     g_open[NS];                      // session contains the latest bar
struct SHist { datetime k[]; };           // keys of drawn sessions (oldest first)
SHist    g_hist[NS];

//+------------------------------------------------------------------+
//| Calendar helpers                                                 |
//+------------------------------------------------------------------+
datetime MakeDate(int y, int m, int d)
  {
   MqlDateTime s;
   ZeroMemory(s);
   s.year = y; s.mon = m; s.day = d;
   return StructToTime(s);
  }

// Day of month of the n-th Sunday (n >= 1) or the last Sunday (n = 0) of a month.
int SundayOf(int y, int m, int n)
  {
   if(n > 0)
     {
      MqlDateTime s;
      TimeToStruct(MakeDate(y, m, 1), s);
      int first = 1 + (7 - s.day_of_week) % 7;
      return first + 7 * (n - 1);
     }
   int nm = (m == 12) ? 1 : m + 1, ny = (m == 12) ? y + 1 : y;
   MqlDateTime e;
   TimeToStruct(MakeDate(ny, nm, 1) - 86400, e);
   return e.day - e.day_of_week;
  }

// US daylight saving: second Sunday of March 07:00 UTC to first Sunday of November 06:00 UTC.
bool IsUsDst(datetime utc)
  {
   MqlDateTime s;
   TimeToStruct(utc, s);
   datetime a = MakeDate(s.year, 3, SundayOf(s.year, 3, 2)) + 7 * 3600;
   datetime b = MakeDate(s.year, 11, SundayOf(s.year, 11, 1)) + 6 * 3600;
   return utc >= a && utc < b;
  }

// EU daylight saving: last Sunday of March 01:00 UTC to last Sunday of October 01:00 UTC.
bool IsEuDst(datetime utc)
  {
   MqlDateTime s;
   TimeToStruct(utc, s);
   datetime a = MakeDate(s.year, 3, SundayOf(s.year, 3, 0)) + 3600;
   datetime b = MakeDate(s.year, 10, SundayOf(s.year, 10, 0)) + 3600;
   return utc >= a && utc < b;
  }

//+------------------------------------------------------------------+
//| Time zones                                                       |
//+------------------------------------------------------------------+
int g_baseOffset = 0;   // server offset from UTC in seconds (standard time for SERVER_AUTO_US_DST)

void DetectServerOffset()
  {
   if(InpServerTz == SERVER_MANUAL)
     {
      g_baseOffset = (int)MathRound(InpServerOffset * 3600.0);
      return;
     }
   datetime srv = TimeTradeServer(), gmt = TimeGMT();
   int off = (int)MathRound((double)(srv - gmt) / 1800.0) * 1800;
   if(InpServerTz == SERVER_AUTO_US_DST && IsUsDst(gmt))
      off -= 3600;
   g_baseOffset = off;
  }

datetime ServerToUtc(datetime t)
  {
   datetime u = t - g_baseOffset;
   if(InpServerTz == SERVER_AUTO_US_DST && IsUsDst(u))
      u -= 3600;
   return u;
  }

// Offset of session market s from UTC at time utc, in seconds.
int MarketOffset(int s, datetime utc)
  {
   if(s == 0)
      return 9 * 3600;                                  // Tokyo, no daylight saving
   if(s == 1)
      return IsEuDst(utc) ? 3600 : 0;                   // London
   return IsUsDst(utc) ? -4 * 3600 : -5 * 3600;         // New York
  }

int HhmmToMin(int v) { return (v / 100) * 60 + v % 100; }

// If the bar at UTC time `utc` is inside session s, returns true and the session's start time (UTC).
bool InSession(int s, datetime utc, datetime &key)
  {
   int off = MarketOffset(s, utc);
   datetime loc = utc + off;
   MqlDateTime d;
   TimeToStruct(loc, d);
   int mins = d.hour * 60 + d.min;
   int st = g_start[s], en = g_end[s];
   datetime dayStart = loc - (d.hour * 3600 + d.min * 60 + d.sec);
   bool inS;
   datetime startLoc;
   if(st < en)
     {
      inS = mins >= st && mins < en;
      startLoc = dayStart + st * 60;
     }
   else
     {
      inS = mins >= st || mins < en;
      startLoc = (mins >= st) ? dayStart + st * 60 : dayStart - 86400 + st * 60;
     }
   if(!inS)
      return false;
   MqlDateTime sd;
   TimeToStruct(startLoc, sd);
   if(sd.day_of_week == 0 || sd.day_of_week == 6)
      return false;                                      // no sessions starting on weekends
   key = startLoc - off;
   return true;
  }

//+------------------------------------------------------------------+
//| Drawing                                                          |
//+------------------------------------------------------------------+
string FmtRange(double r)
  {
   if(InpUnit == UNIT_POINTS)
      return IntegerToString((long)MathRound(r / _Point)) + " pts";
   if(InpUnit == UNIT_PIPS)
     {
      double pip = (_Digits == 3 || _Digits == 5) ? _Point * 10 : _Point;
      return DoubleToString(r / pip, 1) + " pips";
     }
   return DoubleToString(r, _Digits);
  }

string ObjName(int s, datetime key, string part)
  {
   return PFX + IntegerToString(s) + "_" + IntegerToString((long)key) + "_" + part;
  }

void DeleteSession(int s, datetime key)
  {
   ObjectDelete(0, ObjName(s, key, "box"));
   ObjectDelete(0, ObjName(s, key, "lbl"));
   ObjectDelete(0, ObjName(s, key, "mid"));
  }

void DrawSession(int s, datetime key, datetime t0, datetime t1, double hi, double lo)
  {
   string bx = ObjName(s, key, "box");
   if(ObjectFind(0, bx) < 0)
     {
      ObjectCreate(0, bx, OBJ_RECTANGLE, 0, t0, hi, t1, lo);
      ObjectSetInteger(0, bx, OBJPROP_COLOR, g_col[s]);
      ObjectSetInteger(0, bx, OBJPROP_FILL, InpFill);
      ObjectSetInteger(0, bx, OBJPROP_BACK, true);
      ObjectSetInteger(0, bx, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, bx, OBJPROP_HIDDEN, true);
     }
   ObjectMove(0, bx, 0, t0, hi);
   ObjectMove(0, bx, 1, t1, lo);
   if(InpLabels)
     {
      string lb = ObjName(s, key, "lbl");
      if(ObjectFind(0, lb) < 0)
        {
         ObjectCreate(0, lb, OBJ_TEXT, 0, t0, hi);
         ObjectSetInteger(0, lb, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);
         ObjectSetInteger(0, lb, OBJPROP_FONTSIZE, 8);
         ObjectSetInteger(0, lb, OBJPROP_COLOR, clrSilver);
         ObjectSetInteger(0, lb, OBJPROP_SELECTABLE, false);
         ObjectSetInteger(0, lb, OBJPROP_HIDDEN, true);
        }
      ObjectMove(0, lb, 0, t0, hi);
      ObjectSetString(0, lb, OBJPROP_TEXT, g_name[s] + "  " + FmtRange(hi - lo));
     }
   if(InpMidLine)
     {
      string md = ObjName(s, key, "mid");
      double mid = (hi + lo) / 2.0;
      if(ObjectFind(0, md) < 0)
        {
         ObjectCreate(0, md, OBJ_TREND, 0, t0, mid, t1, mid);
         ObjectSetInteger(0, md, OBJPROP_COLOR, g_col[s]);
         ObjectSetInteger(0, md, OBJPROP_STYLE, STYLE_DOT);
         ObjectSetInteger(0, md, OBJPROP_RAY_RIGHT, false);
         ObjectSetInteger(0, md, OBJPROP_SELECTABLE, false);
         ObjectSetInteger(0, md, OBJPROP_HIDDEN, true);
        }
      ObjectMove(0, md, 0, t0, mid);
      ObjectMove(0, md, 1, t1, mid);
     }
  }

void PanelLine(int row, string text, color col)
  {
   string nm = PFX + "panel_" + IntegerToString(row);
   if(ObjectFind(0, nm) < 0)
     {
      ObjectCreate(0, nm, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(0, nm, OBJPROP_CORNER, InpCorner);
      bool right = (InpCorner == CORNER_RIGHT_UPPER || InpCorner == CORNER_RIGHT_LOWER);
      bool lower = (InpCorner == CORNER_LEFT_LOWER || InpCorner == CORNER_RIGHT_LOWER);
      ObjectSetInteger(0, nm, OBJPROP_ANCHOR, right ? (lower ? ANCHOR_RIGHT_LOWER : ANCHOR_RIGHT_UPPER)
                                                    : (lower ? ANCHOR_LEFT_LOWER : ANCHOR_LEFT_UPPER));
      ObjectSetInteger(0, nm, OBJPROP_XDISTANCE, 10);
      ObjectSetInteger(0, nm, OBJPROP_YDISTANCE, 20 + (lower ? 4 - row : row) * 16);
      ObjectSetInteger(0, nm, OBJPROP_FONTSIZE, 9);
      ObjectSetString(0, nm, OBJPROP_FONT, "Consolas");
      ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, nm, OBJPROP_HIDDEN, true);
     }
   ObjectSetString(0, nm, OBJPROP_TEXT, text);
   ObjectSetInteger(0, nm, OBJPROP_COLOR, col);
  }

void UpdatePanel()
  {
   if(!InpPanel)
      return;
   if(PeriodSeconds(_Period) >= 86400)
     {
      PanelLine(0, "Sessions need an intraday chart", clrOrange);
      PanelLine(4, "DinexSpace", clrSpringGreen);
      return;
     }
   PanelLine(0, "Session      Status   Range", clrGray);
   for(int s = 0; s < NS; s++)
     {
      string rng = (g_key[s] > 0) ? FmtRange(g_hi[s] - g_lo[s]) : "-";
      string st = !g_show[s] ? "off" : (g_open[s] ? "open" : "closed");
      PanelLine(1 + s, StringFormat("%-12s %-8s %s", g_name[s], st, rng), g_open[s] ? clrSpringGreen : clrSilver);
     }
   PanelLine(4, "DinexSpace", clrSpringGreen);
  }

//+------------------------------------------------------------------+
//| Indicator events                                                 |
//+------------------------------------------------------------------+
void ResetState()
  {
   for(int s = 0; s < NS; s++)
     {
      g_key[s] = 0; g_t0[s] = 0; g_hi[s] = 0; g_lo[s] = 0; g_open[s] = false;
      ArrayResize(g_hist[s].k, 0);
     }
  }

int OnInit()
  {
   g_show[0] = InpShowAsia;   g_start[0] = HhmmToMin(InpAsiaStart); g_end[0] = HhmmToMin(InpAsiaEnd); g_col[0] = InpAsiaColor;
   g_show[1] = InpShowLondon; g_start[1] = HhmmToMin(InpLonStart);  g_end[1] = HhmmToMin(InpLonEnd);  g_col[1] = InpLonColor;
   g_show[2] = InpShowNY;     g_start[2] = HhmmToMin(InpNYStart);   g_end[2] = HhmmToMin(InpNYEnd);   g_col[2] = InpNYColor;
   for(int s = 0; s < NS; s++)
      if(g_start[s] < 0 || g_start[s] >= 1440 || g_end[s] < 0 || g_end[s] >= 1440 || g_start[s] == g_end[s])
        {
         Print("DinexSpace Session Boxes: invalid hours for ", g_name[s], " (use HHMM, start different from end)");
         return INIT_PARAMETERS_INCORRECT;
        }
   if(InpKeep < 1 || InpMaxBars < 10)
      return INIT_PARAMETERS_INCORRECT;
   DetectServerOffset();
   ResetState();
   return INIT_SUCCEEDED;
  }

void OnDeinit(const int reason)
  {
   ObjectsDeleteAll(0, PFX);
  }

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 < 2)
      return 0;
   ArraySetAsSeries(time, false);
   ArraySetAsSeries(high, false);
   ArraySetAsSeries(low, false);
   if(PeriodSeconds(_Period) >= 86400)
     {
      UpdatePanel();
      return rates_total;
     }
   int from;
   if(prev_calculated == 0)
     {
      ObjectsDeleteAll(0, PFX);
      DetectServerOffset();
      ResetState();
      from = MathMax(0, rates_total - InpMaxBars);
     }
   else
      from = prev_calculated - 1;

   for(int i = from; i < rates_total; i++)
     {
      datetime utc = ServerToUtc(time[i]);
      for(int s = 0; s < NS; s++)
        {
         if(!g_show[s])
            continue;
         datetime key;
         bool inS = InSession(s, utc, key);
         if(i == rates_total - 1)
            g_open[s] = inS;
         if(!inS)
            continue;
         if(key != g_key[s])
           {
            // a new session starts on this bar
            g_key[s] = key; g_t0[s] = time[i]; g_hi[s] = high[i]; g_lo[s] = low[i];
            int n = ArraySize(g_hist[s].k);
            ArrayResize(g_hist[s].k, n + 1);
            g_hist[s].k[n] = key;
            if(n + 1 > InpKeep)
              {
               DeleteSession(s, g_hist[s].k[0]);
               ArrayRemove(g_hist[s].k, 0, 1);
              }
           }
         else
           {
            g_hi[s] = MathMax(g_hi[s], high[i]);
            g_lo[s] = MathMin(g_lo[s], low[i]);
           }
         DrawSession(s, g_key[s], g_t0[s], time[i], g_hi[s], g_lo[s]);
        }
     }
   UpdatePanel();
   return rates_total;
  }
//+------------------------------------------------------------------+