//@version=6
indicator("Key Opens + AMD", shorttitle="Opens/AMD", overlay=true,
     max_boxes_count=500, max_lines_count=500, max_labels_count=500)

// ═══════════════════════════════════════════════════════════════════════════
// The key opens, and the AMD phases that hang off them.
//
// ── WHAT AN AMD ACTUALLY IS ON HIS GRID ────────────────────────────────────
// On the reference chart A runs 10:00-10:30, M 10:30-11:00, D 11:00-11:30.
// Those are exactly the three 30M cycles that make up AM3 (10:00-11:29) in his
// own ladder. So an AMD is not a new idea: it is a 90M cycle read as its three
// 30M children, and the same construction works off any anchor.
//
// Which is why the phase length is one setting and not three. Change it to 10
// and you get the 30M cycle read as its three 10M children — the ladder is
// self-similar and so is this.
//
// ── WHY THE OPENS NEED THEIR OWN ANCHORS ───────────────────────────────────
// His 90M grid is anchored on 02:30, so 07:00 and 10:00 fall on it but 03:00,
// 09:30, 12:00 and 14:00 do not. Those get their own AMD, anchored on the open
// itself rather than on the grid. Both kinds are listed below; nothing is
// derived from the other.
//
// ── THE BOX IS THE PHASE'S RANGE, NOT A BACKGROUND ─────────────────────────
// On the reference chart each block is drawn to the high and low of its own
// phase, which is what makes the accumulation visibly narrow and the
// manipulation visibly tall. A full-height background would lose exactly that.
// The cost: a box can only be as tall as the bars it has seen, so it grows
// while its phase runs and is finished when the phase ends. The vertical
// dividers DO project forward, because their times are known in advance.
//
// NOT A SIGNAL. This labels the clock, nothing else.
// ═══════════════════════════════════════════════════════════════════════════

NY = "America/New_York"

// ───────────────────────── the opens ─────────────────────────
// Six slots, pre-filled with his: 03:00, 07:00, 09:30, 10:00, 12:00, 14:00.
// Each can draw a divider, the open price, and an AMD.
gK = "Key opens (New York)"
o1On = input.bool(true,  "", inline="k1", group=gK)
o1Tm = input.string("03:00", "", inline="k1", group=gK)
o1Am = input.bool(false, "AMD", inline="k1", group=gK)
o2On = input.bool(true,  "", inline="k2", group=gK)
o2Tm = input.string("07:00", "", inline="k2", group=gK)
o2Am = input.bool(false, "AMD", inline="k2", group=gK)
o3On = input.bool(true,  "", inline="k3", group=gK)
o3Tm = input.string("09:30", "", inline="k3", group=gK)
o3Am = input.bool(false, "AMD", inline="k3", group=gK)
o4On = input.bool(true,  "", inline="k4", group=gK)
o4Tm = input.string("10:00", "", inline="k4", group=gK)
o4Am = input.bool(true,  "AMD", inline="k4", group=gK)
o5On = input.bool(true,  "", inline="k5", group=gK)
o5Tm = input.string("12:00", "", inline="k5", group=gK)
o5Am = input.bool(false, "AMD", inline="k5", group=gK)
o6On = input.bool(true,  "", inline="k6", group=gK)
o6Tm = input.string("14:00", "", inline="k6", group=gK)
o6Am = input.bool(false, "AMD", inline="k6", group=gK)

phaseMin = input.int(30, "AMD phase length (minutes)", minval=1, maxval=240, group=gK,
     tooltip="Three phases of this length. 30 gives the 90-minute AMD on the reference chart. 10 gives the 30M cycle read as its three 10M children — the same shape one rung down the ladder.")

// AMD only where you ask for it, because two AMD's that overlap are unreadable:
// 09:30 and 10:00 are half an hour apart and a 30-minute phase makes each of
// them ninety minutes long. Default is 10:00 only, as on the reference chart.

// ───────────────────────── what to draw ─────────────────────────
gD = "Draw"
showDiv  = input.bool(true, "Vertical divider at each open", group=gD)
showOpen = input.bool(true, "Horizontal line at the open price", group=gD,
     tooltip="Appears when that open happens — a price cannot be drawn before it exists. The dividers do run ahead, because their times are known.")
showPD   = input.bool(true, "Previous day high and low", group=gD,
     tooltip="The reference chart calls the previous day low its draw on liquidity. Shown as two lines with labels.")
extendBars = input.int(40, "Extend lines right (bars)", minval=0, maxval=500, group=gD)
daysAhead = input.int(1, "Days drawn", minval=1, maxval=3, group=gD)

// ───────────────────────── look ─────────────────────────
gS = "Look"
colA = input.color(color.new(color.green, 88), "A — accumulation", group=gS)
colM = input.color(color.new(color.red,   88), "M — manipulation", group=gS)
colD = input.color(color.new(color.blue,  88), "D — distribution", group=gS)
colDiv  = input.color(color.new(color.gray, 55), "Divider", group=gS)
colOpen = input.color(color.new(color.red, 30),  "Open price", group=gS)
colPD   = input.color(color.new(color.black, 10), "PDH / PDL", group=gS)
showLet = input.bool(true, "A / M / D letters", group=gS)
letSzIn = input.string("large", "  └ size", options=["small","normal","large","huge"], group=gS)
letSz = letSzIn == "small" ? size.small : letSzIn == "normal" ? size.normal :
     letSzIn == "large" ? size.large : size.huge

// ═══════════════════════ helpers ═══════════════════════
// "09:30" -> 570. Written out rather than parsed loosely, because a silent
// failure here would put every block an hour off and still look plausible.
f_min(string s) =>
    int colon = str.pos(s, ":")
    int h = na(colon) ? 0 : math.round(str.tonumber(str.substring(s, 0, colon)))
    int m = na(colon) ? 0 : math.round(str.tonumber(str.substring(s, colon + 1)))
    h * 60 + m

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

barMs = timeframe.in_seconds() * 1000
int l_min = hour(time, NY) * 60 + minute(time, NY)

// ═══════════════════════ the open prices ═══════════════════════
// One slot per open. Reset at the start of each trading day so yesterday's
// open never leaks into today's line.
var array<float> opPrice = array.new_float(6, na)
var array<int>   opTime  = array.new_int(6, na)
var array<line>  opLine  = array.new_line(6, na)
var array<label> opLbl   = array.new_label(6, na)

var int lastDay = na
bool newDay = na(lastDay) or dayofmonth(time, NY) != lastDay
if newDay
    for i = 0 to 5
        array.set(opPrice, i, na)
        array.set(opTime, i, na)
lastDay := dayofmonth(time, NY)

f_on(int i)   => i == 0 ? o1On : i == 1 ? o2On : i == 2 ? o3On : i == 3 ? o4On : i == 4 ? o5On : o6On
f_tm(int i)   => i == 0 ? o1Tm : i == 1 ? o2Tm : i == 2 ? o3Tm : i == 3 ? o4Tm : i == 4 ? o5Tm : o6Tm
f_amd(int i)  => i == 0 ? o1Am : i == 1 ? o2Am : i == 2 ? o3Am : i == 3 ? o4Am : i == 4 ? o5Am : o6Am

// The open price is the OPEN of the first bar at or after that minute. Using
// the close would be a different number and the label would still say "open".
for i = 0 to 5
    if f_on(i) and na(array.get(opPrice, i))
        int km = f_min(f_tm(i))
        if l_min >= km and l_min < km + 5
            array.set(opPrice, i, open)
            array.set(opTime, i, time)

// ═══════════════════════ the AMD phases ═══════════════════════
// Eighteen slots: six opens x three phases. Each keeps its own high and low,
// so a box is always exactly as tall as the bars inside its phase.
var array<float> phHi  = array.new_float(18, na)
var array<float> phLo  = array.new_float(18, na)
var array<int>   phT0  = array.new_int(18, na)
var array<int>   phT1  = array.new_int(18, na)
var array<box>   phBox = array.new_box(18, na)
var array<label> phLbl = array.new_label(18, na)

if newDay
    for i = 0 to 17
        array.set(phHi, i, na)
        array.set(phLo, i, na)
        array.set(phT0, i, na)
        array.set(phT1, i, na)

for i = 0 to 5
    if f_on(i) and f_amd(i)
        int km = f_min(f_tm(i))
        for p = 0 to 2
            int a0 = km + p * phaseMin
            int a1 = a0 + phaseMin
            if l_min >= a0 and l_min < a1
                int k = i * 3 + p
                array.set(phHi, k, na(array.get(phHi, k)) ? high : math.max(array.get(phHi, k), high))
                array.set(phLo, k, na(array.get(phLo, k)) ? low  : math.min(array.get(phLo, k), low))
                if na(array.get(phT0, k))
                    array.set(phT0, k, time)
                array.set(phT1, k, time)

// ═══════════════════════ drawing ═══════════════════════
// Redrawn whole on the last bar. In bar replay "the last bar" moves backwards,
// and a list that is patched rather than rebuilt would hold on to drawings
// from a step that has not happened yet.
var array<line>  divLn = array.new_line()
var array<label> divLb = array.new_label()
var line pdhLn = na
var line pdlLn = na
var label pdhLb = na
var label pdlLb = na

f_clearDiv() =>
    if array.size(divLn) > 0
        for i = 0 to array.size(divLn) - 1
            line.delete(array.get(divLn, i))
    if array.size(divLb) > 0
        for i = 0 to array.size(divLb) - 1
            label.delete(array.get(divLb, i))
    array.clear(divLn)
    array.clear(divLb)

// Previous day's high and low, held from the daily series.
pdh = request.security(syminfo.tickerid, "D", high[1], lookahead=barmerge.lookahead_on)
pdl = request.security(syminfo.tickerid, "D", low[1],  lookahead=barmerge.lookahead_on)
// lookahead_on is safe here and only here: high[1] and low[1] are YESTERDAY's,
// settled before this session opened. Asking for [0] with lookahead would be
// reading the future; asking for [1] is reading a closed day.

if barstate.islast
    f_clearDiv()
    int rEnd = time + extendBars * barMs

    // ── the opens ──
    for i = 0 to 5
        if f_on(i)
            int km = f_min(f_tm(i))
            for dOff = 0 to daysAhead - 1
                int ts = timestamp(NY, year(time, NY), month(time, NY),
                     dayofmonth(time, NY) + dOff, km / 60, km % 60)
                if showDiv
                    array.push(divLn, line.new(ts, low, ts, high, xloc=xloc.bar_time,
                         extend=extend.both, color=colDiv, width=1, style=line.style_dotted))
                    array.push(divLb, label.new(ts, high, f_hhmm(km), xloc=xloc.bar_time,
                         style=label.style_label_down, color=color.new(color.white, 100),
                         textcolor=colDiv, size=size.tiny))

            // The horizontal open line only exists once the open has happened.
            float px = array.get(opPrice, i)
            if showOpen and not na(px)
                line ln = array.get(opLine, i)
                label lb = array.get(opLbl, i)
                if na(ln)
                    ln := line.new(array.get(opTime, i), px, rEnd, px, xloc=xloc.bar_time,
                         color=colOpen, width=1, style=line.style_dashed)
                    lb := label.new(rEnd, px, "", xloc=xloc.bar_time,
                         style=label.style_label_left, color=color.new(color.white, 100),
                         textcolor=colOpen, size=size.small)
                    array.set(opLine, i, ln)
                    array.set(opLbl, i, lb)
                line.set_xy1(ln, array.get(opTime, i), px)
                line.set_xy2(ln, rEnd, px)
                label.set_xy(lb, rEnd, px)
                label.set_text(lb, f_hhmm(km) + " Open")

    // ── the AMD blocks ──
    for i = 0 to 5
        for p = 0 to 2
            int k = i * 3 + p
            box bx = array.get(phBox, k)
            label lb = array.get(phLbl, k)
            bool draw = f_on(i) and f_amd(i) and not na(array.get(phHi, k))
            if not draw
                box.delete(bx)
                label.delete(lb)
                array.set(phBox, k, na)
                array.set(phLbl, k, na)
            else
                color col = p == 0 ? colA : p == 1 ? colM : colD
                string letter = p == 0 ? "A" : p == 1 ? "M" : "D"
                float hi = array.get(phHi, k)
                float lo = array.get(phLo, k)
                int t0 = array.get(phT0, k)
                int t1 = array.get(phT1, k)
                if na(bx)
                    bx := box.new(t0, hi, t1, lo, xloc=xloc.bar_time, bgcolor=col,
                         border_color=color.new(color.gray, 70), border_width=1)
                    lb := label.new(t0, hi, "", xloc=xloc.bar_time,
                         style=label.style_label_down, color=color.new(color.white, 100),
                         textcolor=color.new(color.gray, 20), size=letSz)
                    array.set(phBox, k, bx)
                    array.set(phLbl, k, lb)
                box.set_lefttop(bx, t0, hi)
                box.set_rightbottom(bx, t1, lo)
                box.set_bgcolor(bx, col)
                // Letter in the middle of the phase, above the box.
                label.set_xy(lb, t0 + (t1 - t0) / 2, hi)
                label.set_text(lb, showLet ? letter : "")
                label.set_size(lb, letSz)

    // ── previous day high and low ──
    if showPD and not na(pdh) and not na(pdl)
        if na(pdhLn)
            pdhLn := line.new(time, pdh, rEnd, pdh, xloc=xloc.bar_time, color=colPD, width=1)
            pdlLn := line.new(time, pdl, rEnd, pdl, xloc=xloc.bar_time, color=colPD, width=1)
            pdhLb := label.new(rEnd, pdh, "", xloc=xloc.bar_time, style=label.style_label_left,
                 color=color.new(color.white, 100), textcolor=colPD, size=size.small)
            pdlLb := label.new(rEnd, pdl, "", xloc=xloc.bar_time, style=label.style_label_left,
                 color=color.new(color.white, 100), textcolor=colPD, size=size.small)
        line.set_xy1(pdhLn, time - 500 * barMs, pdh)
        line.set_xy2(pdhLn, rEnd, pdh)
        line.set_xy1(pdlLn, time - 500 * barMs, pdl)
        line.set_xy2(pdlLn, rEnd, pdl)
        label.set_xy(pdhLb, rEnd, pdh)
        label.set_xy(pdlLb, rEnd, pdl)
        label.set_text(pdhLb, "PDH")
        label.set_text(pdlLb, "PDL")