//@version=6
indicator("Cycle Raster", shorttitle="Raster", overlay=true, max_boxes_count=500,
     max_lines_count=500, max_labels_count=500)

// ═══════════════════════════════════════════════════════════════════════════
// The cycle grid as a background, drawn for the WHOLE day — including the
// cycles that have not happened yet.
//
// WHY IT HAS TO BE BOXES. bgcolor() can only paint a bar that exists, which is
// why a shaded grid appears to grow bar by bar and never shows what is coming.
// Boxes anchored on xloc.bar_time take a timestamp rather than a bar, and Pine
// will happily draw one past the last bar. That is the whole trick, and it is
// the only way to see the next cycle arrive before price does.
//
// For bar replay this matters more than it does live: you can see where the
// boundary falls while you are stepping through, instead of discovering it one
// bar late.
//
// ── THE GRID ───────────────────────────────────────────────────────────────
// Identical to CyclePOC and to his own SMT file, verified minute by minute
// over a full day (1,440 minutes x 4 grids, 0 differences). New York time,
// DST automatic. Anchor 02:30, end 15:59.
//
//    10M     10 min      81/day
//    30M     30 min      27/day
//    90M     90 min       9/day   LO1 02:30-03:59  LO2 04:00-05:29  LO3 05:30-06:59
//                                 AM1 07:00-08:29  AM2 08:30-09:59  AM3 10:00-11:29
//                                 PM1 11:30-12:59  PM2 13:00-14:29  PM3 14:30-15:59
//    Asia 18:00-02:29 . London 02:30-06:59 . NY AM 07:00-11:29 . NY PM 11:30-15:59
//    16:00-17:59 has no session and no cycle, by design — it is left unshaded.
//
// Everything is redrawn on the last bar rather than accumulated, so the grid
// is always right and never has to be repaired. That also makes it correct in
// replay, where "the last bar" moves backwards.
// ═══════════════════════════════════════════════════════════════════════════

gC = "Grid"
mode = input.string("90M", "Cycle", options=["Sessions", "90M", "30M", "10M"], group=gC)
daysAhead = input.int(1, "Days drawn", minval=1, maxval=3, group=gC,
     tooltip="1 = today only, which already includes every cycle still to come. 2 or 3 also draws the days after it — useful when you are stepping through a replay and want the next session already on screen. More days means more boxes; the 10M grid uses 81 of the 500 available per day.")
showPast = input.bool(true, "Shade cycles that have already happened", group=gC,
     tooltip="Off leaves the past clean and shades only what is still to come, which is the whole point of the thing.")

gS = "Look"
shadeA  = input.color(color.new(color.gray, 93), "Shading", inline="s", group=gS)
shadeB  = input.color(color.new(color.gray, 97), "alternating", inline="s", group=gS)
futureA = input.color(color.new(color.blue, 93), "Future", inline="f", group=gS)
futureB = input.color(color.new(color.blue, 97), "alternating", inline="f", group=gS)
showEdge = input.bool(true, "Boundary lines", group=gS)
edgeCol  = input.color(color.new(color.gray, 55), "  └ colour", group=gS)
showName = input.bool(true, "Cycle names", group=gS)
nameCol  = input.color(color.new(color.gray, 35), "  └ colour", group=gS)
nameSzIn = input.string("tiny", "  └ size", options=["tiny","small","normal"], group=gS)
nameSz = nameSzIn == "tiny" ? size.tiny : nameSzIn == "small" ? size.small : size.normal

NY = "America/New_York"

// A background box needs a top and a bottom, and there is no "full height" in
// Pine. Half again above and below the current price is far outside any
// sensible view on an index future, so the box reads as a background.
f_top() => close * 1.5
f_bot() => close * 0.5

var array<box>   bx = array.new_box()
var array<line>  ln = array.new_line()
var array<label> lb = array.new_label()

f_clear() =>
    if array.size(bx) > 0
        for i = 0 to array.size(bx) - 1
            box.delete(array.get(bx, i))
    if array.size(ln) > 0
        for i = 0 to array.size(ln) - 1
            line.delete(array.get(ln, i))
    if array.size(lb) > 0
        for i = 0 to array.size(lb) - 1
            label.delete(array.get(lb, i))
    array.clear(bx)
    array.clear(ln)
    array.clear(lb)

// One cycle, from startMin to endMin (inclusive) on the day offset by dayOff.
f_draw(int dayOff, int startMin, int endMin, string nm, int idx) =>
    int y = year(time, NY)
    int m = month(time, NY)
    int d = dayofmonth(time, NY) + dayOff
    int t0 = timestamp(NY, y, m, d, startMin / 60, startMin % 60)
    // endMin is the last minute IN the cycle and the box closes ON it. Running
    // to endMin + 1 looked tidier but handed the next cycle's opening candle to
    // this one: the 14:30 bar belongs to the cycle that starts at 14:30 and to
    // nothing else. The one-bar gap that leaves is the correct boundary, not a
    // defect to be closed.
    int t1 = timestamp(NY, y, m, d, endMin / 60, endMin % 60)
    bool toekomst = t0 > time
    if toekomst or showPast
        color fill = toekomst ? (idx % 2 == 0 ? futureA : futureB)
             : (idx % 2 == 0 ? shadeA : shadeB)
        array.push(bx, box.new(t0, f_top(), t1, f_bot(), xloc=xloc.bar_time,
             bgcolor=fill, border_color=color.new(color.white, 100)))
        if showEdge
            array.push(ln, line.new(t0, f_bot(), t0, f_top(), xloc=xloc.bar_time,
                 color=edgeCol, width=1, style=line.style_dotted))
        if showName
            array.push(lb, label.new(t0, f_top(), nm, xloc=xloc.bar_time,
                 style=label.style_label_down, color=color.new(color.white, 100),
                 textcolor=nameCol, size=nameSz))

f_hhmm(int m) =>
    int h = m / 60
    int mm = m % 60
    (h < 10 ? "0" : "") + str.tostring(h) + ":" + (mm < 10 ? "0" : "") + str.tostring(mm)

// Redrawn whole on the last bar. Cheaper to reason about than patching, and it
// is what makes replay correct: there "the last bar" is wherever you have
// stepped to.
if barstate.islast
    f_clear()
    for dayOff = 0 to daysAhead - 1
        if mode == "Sessions"
            // Asia runs 18:00 to 02:29 the next day, so it is drawn as one box
            // whose end timestamp simply falls on the following date.
            int y = year(time, NY)
            int mo = month(time, NY)
            int dd = dayofmonth(time, NY) + dayOff
            int a0 = timestamp(NY, y, mo, dd, 18, 0)
            int a1 = timestamp(NY, y, mo, dd + 1, 2, 29)
            bool fut = a0 > time
            if fut or showPast
                array.push(bx, box.new(a0, f_top(), a1, f_bot(), xloc=xloc.bar_time,
                     bgcolor=fut ? futureA : shadeA, border_color=color.new(color.white, 100)))
                if showEdge
                    array.push(ln, line.new(a0, f_bot(), a0, f_top(), xloc=xloc.bar_time,
                         color=edgeCol, width=1, style=line.style_dotted))
                if showName
                    array.push(lb, label.new(a0, f_top(), "Asia", xloc=xloc.bar_time,
                         style=label.style_label_down, color=color.new(color.white, 100),
                         textcolor=nameCol, size=nameSz))
            f_draw(dayOff, 150, 419, "London", 1)
            f_draw(dayOff, 420, 689, "NY AM", 0)
            f_draw(dayOff, 690, 959, "NY PM", 1)
        else if mode == "90M"
            // Written out, not divided — his own file's choice, and it keeps
            // the nine names attached to the nine windows.
            f_draw(dayOff, 150, 239, "LO1", 0)
            f_draw(dayOff, 240, 329, "LO2", 1)
            f_draw(dayOff, 330, 419, "LO3", 0)
            f_draw(dayOff, 420, 509, "AM1", 1)
            f_draw(dayOff, 510, 599, "AM2", 0)
            f_draw(dayOff, 600, 689, "AM3", 1)
            f_draw(dayOff, 690, 779, "PM1", 0)
            f_draw(dayOff, 780, 869, "PM2", 1)
            f_draw(dayOff, 870, 959, "PM3", 0)
        else
            int len = mode == "30M" ? 30 : 10
            for k = 0 to (960 - 150) / len - 1
                int s0 = 150 + k * len
                f_draw(dayOff, s0, s0 + len - 1, (len == 30 ? "" : "") + f_hhmm(s0), k)

// Nothing is plotted; the grid is the output.