//@version=6
indicator("Cycle Ribbon — AMD", shorttitle="Ribbon", overlay=true,
     max_boxes_count=500, max_labels_count=500)

// ═══════════════════════════════════════════════════════════════════════════
// Every cycle on his grid, coloured A / M / D, as a ribbon of stacked rows.
//
// ── WHY THERE IS NO AMD SETTING ────────────────────────────────────────────
// A cycle does not need splitting into an AMD. It IS one. 30M cycle number two
// is the M of its 90M; 90M number two is the M of its session. The ladder is
// self-similar, so the colour falls out of the position in the parent and
// there is nothing to configure:
//
//      Sessions   4/day    each is the A, M or D of the trading day
//      90M        9/day    each is the A, M or D of its session
//      30M       27/day    each is the A, M or D of its 90M
//      10M       81/day    each is the A, M or D of its 30M
//
// ── WHY A RIBBON AND NOT FOUR BACKGROUNDS ──────────────────────────────────
// Four transparent layers over the candles is mud, and two of them already
// fight. As stacked rows beside the price each group stays readable and you
// can watch each row subdivide the one below it — which is the whole point of
// a ladder that goes up in threes.
//
// ── THE GAP BETWEEN CYCLES IS DELIBERATE ───────────────────────────────────
// A cell ends on the LAST bar inside its cycle, so the 14:30 candle belongs to
// the cycle starting at 14:30 and to nothing else. An earlier version ran each
// cell to the first bar of the next cycle: tidier to look at, and wrong about
// which bar belongs where.
//
// All New York time, DST automatic. Grid anchored 02:30, ending 15:59, taken
// from his own SMT file and checked minute by minute against it. Asia runs
// 18:00 to 02:29 the next day and sits outside the grid; 16:00-17:59 is empty
// by design.
// ═══════════════════════════════════════════════════════════════════════════

NY = "America/New_York"

// ───────────────────────── which rows ─────────────────────────
gR = "Rows"
useSes = input.bool(true,  "Sessions   ·  4 per day", group=gR)
use90  = input.bool(true,  "90M        ·  9 per day", group=gR)
use30  = input.bool(true,  "30M        · 27 per day", group=gR)
use10  = input.bool(false, "10M        · 81 per day", group=gR,
     tooltip="Off by default. 81 cells a day is a lot of ink for a row you can also read off the 30M above it, and it is the row that eats the drawing budget.")
daysAhead = input.int(1, "Days drawn", minval=1, maxval=2, group=gR,
     tooltip="Includes every cycle still to come today, because the times are known in advance. Two days with every row on is about 242 boxes of the 500 available.")

// ───────────────────────── where the ribbon sits ─────────────────────────
gP = "Placement"
side   = input.string("Below price", "Ribbon sits", options=["Below price", "Above price"], group=gP)
gapATR = input.float(1.0, "Clear of the price by (x ATR)", minval=0, step=0.25, group=gP)
rowATR = input.float(0.6, "Row height (x ATR)", minval=0.1, step=0.1, group=gP)
rowGap = input.float(0.15, "Space between rows (x ATR)", minval=0, step=0.05, group=gP)
atrLen = input.int(120, "ATR length", minval=5, group=gP)

// ───────────────────────── look ─────────────────────────
gS = "Look"
colA    = input.color(color.new(color.green, 55), "A — accumulation", group=gS)
colM    = input.color(color.new(color.red,   55), "M — manipulation", group=gS)
colD    = input.color(color.new(color.blue,  55), "D — distribution", group=gS)
colAsia = input.color(color.new(color.gray,  65), "Asia (outside the grid)", group=gS)
colBord = input.color(color.new(color.white, 100), "Cell border", group=gS)
showLbl = input.bool(true, "Names on the Sessions and 90M rows", group=gS,
     tooltip="Not on 30M or 10M: 27 or 81 labels is unreadable, and those are the rows you read by colour anyway.")
lblSzIn = input.string("tiny", "  └ size", options=["tiny","small","normal"], group=gS)
lblSz = lblSzIn == "tiny" ? size.tiny : lblSzIn == "small" ? size.small : size.normal

atr = ta.atr(atrLen)

// ═══════════════════════ helpers, all at global scope ═══════════════════════
// Pine will not take a function declared inside an if-block, so everything the
// drawing needs is defined out here and handed its values.
f_90name(int i) =>
    i == 0 ? "LO1" : i == 1 ? "LO2" : i == 2 ? "LO3" :
     i == 3 ? "AM1" : i == 4 ? "AM2" : i == 5 ? "AM3" :
     i == 6 ? "PM1" : i == 7 ? "PM2" : "PM3"

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

f_role(int idx) => idx % 3 == 0 ? colA : idx % 3 == 1 ? colM : colD

var array<box>   cells = array.new_box()
var array<label> names = array.new_label()

f_clear() =>
    if array.size(cells) > 0
        for i = 0 to array.size(cells) - 1
            box.delete(array.get(cells, i))
    if array.size(names) > 0
        for i = 0 to array.size(names) - 1
            label.delete(array.get(names, i))
    array.clear(cells)
    array.clear(names)

// One cell. startMin and endMin are both INSIDE the cycle, and the box closes
// on endMin — not endMin + 1. That is what leaves the one-bar gap, and what
// stops a cell from owning the next cycle's first candle.
//
// endMin may run past 1440: Asia ends at 02:29 the NEXT day, which is minute
// 1589. Without the day rollover that lands at 00:29 on the same date and the
// box is drawn backwards across eighteen hours.
f_cell(int dayOff, int startMin, int endMin, float top, float bot, color col,
       string nm, bool label_it) =>
    int y  = year(time, NY)
    int mo = month(time, NY)
    int d  = dayofmonth(time, NY) + dayOff
    int t0 = timestamp(NY, y, mo, d + startMin / 1440,
         (startMin % 1440) / 60, (startMin % 1440) % 60)
    int t1 = timestamp(NY, y, mo, d + endMin / 1440,
         (endMin % 1440) / 60, (endMin % 1440) % 60)
    array.push(cells, box.new(t0, top, t1, bot, xloc=xloc.bar_time,
         bgcolor=col, border_color=colBord, border_width=1))
    if label_it and showLbl
        array.push(names, label.new(t0 + (t1 - t0) / 2, (top + bot) / 2, nm,
             xloc=xloc.bar_time, style=label.style_none,
             textcolor=color.new(color.gray, 10), size=lblSz))

// Top of row r, counted outward from the price.
f_top(int r, float anchor, float a) =>
    float step = r * (rowATR + rowGap) * a
    side == "Below price" ? anchor - step : anchor + step + rowATR * a

// ═══════════════════════ drawing ═══════════════════════
// Redrawn whole on the last bar. In bar replay "the last bar" moves backwards,
// and a patched list would hold drawings from a step that has not happened.
if barstate.islast and not na(atr)
    f_clear()
    float anchor = side == "Below price" ? low - gapATR * atr : high + gapATR * atr

    for dOff = 0 to daysAhead - 1
        int row = 0

        // ── Sessions. London, NY AM and NY PM are the A, M and D of the
        //    trading day. Asia sits outside the 02:30-15:59 grid and gets its
        //    own colour rather than a role it does not have.
        if useSes
            float tp = f_top(row, anchor, atr)
            float bt = tp - rowATR * atr
            f_cell(dOff, 1080, 1589, tp, bt, colAsia, "Asia", true)
            f_cell(dOff,  150,  419, tp, bt, colA, "London", true)
            f_cell(dOff,  420,  689, tp, bt, colM, "NY AM", true)
            f_cell(dOff,  690,  959, tp, bt, colD, "NY PM", true)
            row += 1

        // ── 90M. Nine windows, each the A, M or D of its session.
        if use90
            float tp = f_top(row, anchor, atr)
            float bt = tp - rowATR * atr
            for i = 0 to 8
                int s0 = 150 + i * 90
                f_cell(dOff, s0, s0 + 89, tp, bt, f_role(i), f_90name(i), true)
            row += 1

        // ── 30M. Each the A, M or D of its 90M.
        if use30
            float tp = f_top(row, anchor, atr)
            float bt = tp - rowATR * atr
            for i = 0 to 26
                int s0 = 150 + i * 30
                f_cell(dOff, s0, s0 + 29, tp, bt, f_role(i), f_hhmm(s0), false)
            row += 1

        // ── 10M. Each the A, M or D of its 30M.
        if use10
            float tp = f_top(row, anchor, atr)
            float bt = tp - rowATR * atr
            for i = 0 to 80
                int s0 = 150 + i * 10
                f_cell(dOff, s0, s0 + 9, tp, bt, f_role(i), f_hhmm(s0), false)
            row += 1