//@version=6
indicator("Swing Levels — Breakout Map", shorttitle="Swing Levels", overlay=true,
     max_lines_count=500, max_labels_count=500)

// ═══════════════════════════════════════════════════════════════════════════
// Raw swing highs and lows from up to three higher timeframes, read as a
// BREAKOUT map rather than a rejection map.
//
// Rebuilt from Zeiierman's "Buyers & Sellers Profile + Dynamic S/R" after
// measuring that indicator on fifteen years of NQ one-minute bars with real
// volume. Three findings came out of it, and all three are built in here:
//
//  1. DO NOT MOVE THE LEVEL. The original pulls the pivot toward a nearby
//     high-volume node. Across 288 parameter combinations that made the level
//     WORSE: 81 cells fell outside the 95% band and every one of the 81 was
//     negative. A pivot is a price where the market actually turned; shifting
//     it half an ATR onto a volume node moves it off the price that mattered.
//     So there is no profile and no pull here. The level is the wick.
//
//  2. THE VOLUME LAYER ADDS NOTHING, so it is gone. The evidence filter came
//     out at 0 of 288 cells outside the band. The buyers/sellers estimate
//     cannot work by construction: it is (close-low)/(high-low) averaged over
//     hundreds of bars, and its spread collapses from 0.098 to 0.051 as the
//     lookback grows — 69% of readings end up between 0.45 and 0.55. A real
//     signal sharpens with more data; that one flattens.
//
//  3. THE SIGN IS BACKWARDS. Price broke these levels far more often than it
//     held them: 43% held against 49% broken, where a random walk gives 57.5%
//     held. So levels are marked as places where continuation is the better
//     bet, not places to fade.
//
// WHAT IT IS WORTH, measured, so nothing here is oversold: a real swing level
// beats a randomly placed horizontal line by about 0.7 to 1.1 POINTS per
// trade, and it costs about 1 point to trade. That is the whole edge. This is
// a context tool, not a system, and the corner table says so on every chart.
//
// ARMING is the one piece of logic worth more than the lines themselves. A
// level only becomes a setup once price has been armATR away from it. Without
// that rule the original measurement was worthless: levels born next to the
// current price counted as "retests" and inflated the result by seventeen
// percentage points. It is why a level here goes from pale to solid rather
// than being live from birth.
// ═══════════════════════════════════════════════════════════════════════════

// ───────────────────────────── timeframes ─────────────────────────────
gT = "Timeframes"
use1 = input.bool(true,  "", inline="t1", group=gT)
tf1  = input.timeframe("15", "", inline="t1", group=gT)
use2 = input.bool(true,  "", inline="t2", group=gT)
tf2  = input.timeframe("30", "", inline="t2", group=gT)
use3 = input.bool(true,  "", inline="t3", group=gT)
tf3  = input.timeframe("60", "", inline="t3", group=gT)

// Swing length. Tested at 5, 10 and 20 and the result was flat across all
// three, so this is not a knob with an edge hidden in it — pick whatever
// matches the structure you actually read on the chart.
swingLen = input.int(10, "Swing length (bars each side)", minval=1, maxval=50, group=gT,
     tooltip="Bars required left and right of the pivot. A pivot is only drawn once the right-hand side is complete, so nothing here uses information from the future.")

// ───────────────────────────── level handling ─────────────────────────────
gL = "Levels"
armATR   = input.float(1.0, "Arm the level once price is this far away (ATR)", minval=0.0, step=0.25, group=gL,
     tooltip="A level is context until price leaves it and comes back. Measured: dropping this rule inflated rejection rates by 17 percentage points, because levels born next to the current price counted as retests.")
mergeATR = input.float(0.25, "Merge levels closer than (ATR)", minval=0.0, step=0.05, group=gL,
     tooltip="Two pivots a few ticks apart are one level. Merging is across timeframes too, so a 15m and a 30m high at the same price are drawn once and labelled with whichever arrived first.")
breakATR = input.float(0.1, "Mark broken after a close beyond by (ATR)", minval=0.0, step=0.05, group=gL,
     tooltip="A wick through is not a break. A wick through is the wick that makes the next level.")
maxSide  = input.int(4, "Keep this many levels per side", minval=1, maxval=20, group=gL,
     tooltip="Counted separately for highs and lows, so a one-sided market cannot push all the levels off one side of the chart.")
atrLen   = input.int(14, "ATR length (chart timeframe)", minval=2, group=gL)
keepBroken = input.bool(false, "Keep broken levels on the chart", group=gL,
     tooltip="Off = a broken level is removed. On = it stays dotted and grey, which is useful for reading how price treated the map.")

// ───────────────────────────── style ─────────────────────────────
gS = "Style"
colHigh   = input.color(color.rgb(200, 60, 60),   "Swing high", inline="c1", group=gS)
colLow    = input.color(color.rgb(0, 150, 90),    "Swing low",  inline="c1", group=gS)
colArmed  = input.color(color.rgb(230, 170, 40),  "Armed",      inline="c2", group=gS,
     tooltip="Price has been far enough away. A return to this level is now a genuine retest.")
colBroken = input.color(color.rgb(120, 120, 120), "Broken",     inline="c2", group=gS)
wIdle       = input.int(1, "Width before arming", minval=1, maxval=5, group=gS)
wArmed      = input.int(2, "Width once armed", minval=1, maxval=5, group=gS)
extendRight = input.int(30, "Extend right (bars)", minval=0, maxval=300, group=gS)
showLabels  = input.bool(true, "Labels", group=gS)
labelSizeIn = input.string("small", "  └ size", options=["tiny", "small", "normal"], group=gS)
showTable   = input.bool(true, "Show what this is worth (corner table)", group=gS,
     tooltip="The measured edge, on the chart. An indicator that cannot state its own size invites you to trust it more than it earned.")

labelSize = labelSizeIn == "tiny" ? size.tiny : labelSizeIn == "small" ? size.small : size.normal

// ───────────────────────────── alerts ─────────────────────────────
gA = "Alerts"
alertArm   = input.bool(true, "Alert when a level arms", group=gA)
alertTouch = input.bool(true, "Alert when price returns to an armed level", group=gA)
alertBreak = input.bool(true, "Alert when a level breaks", group=gA)

atr = ta.atr(atrLen)
// Bar duration in milliseconds, for drawing to the right of the live candle.
// Taken from the timeframe rather than from time - time[1], which is na on the
// first bar and wrong across a session gap.
barMs = timeframe.in_seconds() * 1000

// ═══════════════════════════ higher-timeframe pivots ═══════════════════════
// request.security sits at global scope and is never wrapped in an `if`.
// Inside a conditional it returns unreliable values — that cost six debug
// rounds on an earlier indicator, and the fix is to always call it and ignore
// the result when the timeframe is switched off.
//
// lookahead stays off (the default), so a pivot only appears on the chart bar
// where its higher-timeframe bar has actually closed.
f_piv(int k) =>
    ph = ta.pivothigh(high, k, k)
    pl = ta.pivotlow(low, k, k)
    // time[k] is the timestamp of the pivot bar itself, not of the bar that
    // confirmed it. Anchoring on the confirming bar shifts a 15m level by a
    // quarter of an hour — wrong by exactly one candle, every time.
    [ph, pl, time[k]]

[ph1, pl1, pt1] = request.security(syminfo.tickerid, tf1, f_piv(swingLen))
[ph2, pl2, pt2] = request.security(syminfo.tickerid, tf2, f_piv(swingLen))
[ph3, pl3, pt3] = request.security(syminfo.tickerid, tf3, f_piv(swingLen))

// ═══════════════════════════ level store ═══════════════════════════
// Parallel arrays rather than a user type, so the whole state is visible in
// one place and a level is never half-updated.
var array<float>  lvlPrice  = array.new_float()
var array<bool>   lvlIsHigh = array.new_bool()
var array<int>    lvlBorn   = array.new_int()
var array<bool>   lvlArmed  = array.new_bool()
var array<bool>   lvlBroken = array.new_bool()
var array<string> lvlTf     = array.new_string()
var array<line>   lvlLine   = array.new_line()
var array<label>  lvlLabel  = array.new_label()

// The last pivot timestamp per timeframe and side. Comparing the TIMESTAMP
// rather than the price is what makes "is this a new pivot?" correct when two
// consecutive pivots happen to share a price.
var int seenH1 = 0
var int seenL1 = 0
var int seenH2 = 0
var int seenL2 = 0
var int seenH3 = 0
var int seenL3 = 0

f_tooClose(float px) =>
    bool hit = false
    if mergeATR > 0 and atr > 0 and array.size(lvlPrice) > 0
        for i = 0 to array.size(lvlPrice) - 1
            if not array.get(lvlBroken, i)
                if math.abs(array.get(lvlPrice, i) - px) < mergeATR * atr
                    hit := true
    hit

f_drop(int i) =>
    line.delete(array.get(lvlLine, i))
    label.delete(array.get(lvlLabel, i))
    array.remove(lvlPrice, i)
    array.remove(lvlIsHigh, i)
    array.remove(lvlBorn, i)
    array.remove(lvlArmed, i)
    array.remove(lvlBroken, i)
    array.remove(lvlTf, i)
    array.remove(lvlLine, i)
    array.remove(lvlLabel, i)

f_add(float px, bool isHigh, int born, string tfName) =>
    if not na(px) and not na(atr) and not f_tooClose(px)
        array.push(lvlPrice, px)
        array.push(lvlIsHigh, isHigh)
        array.push(lvlBorn, born)
        // Armed at birth only if price is already far enough away. Usually it
        // is not — the pivot is right where price just was, which is exactly
        // the case the arming rule exists to exclude.
        array.push(lvlArmed, math.abs(close - px) >= armATR * atr)
        array.push(lvlBroken, false)
        array.push(lvlTf, tfName)
        array.push(lvlLine, line.new(born, px, born, px, xloc=xloc.bar_time,
             color=isHigh ? colHigh : colLow, width=wIdle))
        array.push(lvlLabel, label.new(born, px, "", xloc=xloc.bar_time,
             style=label.style_label_left, color=color.new(color.white, 100),
             textcolor=isHigh ? colHigh : colLow, size=labelSize))

if use1
    if not na(ph1) and pt1 != seenH1
        seenH1 := pt1
        f_add(ph1, true, pt1, tf1)
    if not na(pl1) and pt1 != seenL1
        seenL1 := pt1
        f_add(pl1, false, pt1, tf1)
if use2
    if not na(ph2) and pt2 != seenH2
        seenH2 := pt2
        f_add(ph2, true, pt2, tf2)
    if not na(pl2) and pt2 != seenL2
        seenL2 := pt2
        f_add(pl2, false, pt2, tf2)
if use3
    if not na(ph3) and pt3 != seenH3
        seenH3 := pt3
        f_add(ph3, true, pt3, tf3)
    if not na(pl3) and pt3 != seenL3
        seenL3 := pt3
        f_add(pl3, false, pt3, tf3)

// ═══════════════════════════ state machine ═══════════════════════════
// Every level walks the same three steps: context, armed, broken. The arming
// step is the one the measurement insisted on; without it a level is live from
// birth and the word "retest" stops meaning anything.
bool firedArm = false
bool firedTouch = false
bool firedBreak = false

// Descending, because a level can be removed inside the loop and indices
// below the current one must stay valid.
if array.size(lvlPrice) > 0
    for i = array.size(lvlPrice) - 1 to 0
        float px = array.get(lvlPrice, i)
        bool isHigh = array.get(lvlIsHigh, i)
        bool broken = array.get(lvlBroken, i)
        bool armed = array.get(lvlArmed, i)

        if not broken
            // Arm: price has travelled away on the side it will come back
            // from. For a swing high that means trading below it.
            if not armed
                float away = isHigh ? (px - high) : (low - px)
                if away >= armATR * atr
                    array.set(lvlArmed, i, true)
                    armed := true
                    firedArm := true

            // Break on a CLOSE beyond the level plus a buffer.
            bool brokeNow = isHigh ? (close > px + breakATR * atr) : (close < px - breakATR * atr)
            if brokeNow
                array.set(lvlBroken, i, true)
                broken := true
                firedBreak := true
            else if armed and low <= px and high >= px
                firedTouch := true

        if broken and not keepBroken
            f_drop(i)
        else
            line ln = array.get(lvlLine, i)
            label lb = array.get(lvlLabel, i)
            color col = broken ? colBroken : armed ? colArmed : (isHigh ? colHigh : colLow)
            int right = time + extendRight * barMs
            line.set_xy1(ln, array.get(lvlBorn, i), px)
            line.set_xy2(ln, right, px)
            line.set_color(ln, col)
            line.set_width(ln, broken ? 1 : armed ? wArmed : wIdle)
            line.set_style(ln, broken ? line.style_dotted : line.style_solid)
            label.set_xy(lb, right, px)
            label.set_textcolor(lb, col)
            label.set_size(lb, labelSize)
            if showLabels
                // Scope and unit on every reading: which timeframe, which
                // side, which state. Nothing left to be guessed at.
                string state = broken ? "broken" : armed ? "ARMED" : "context"
                label.set_text(lb, array.get(lvlTf, i) + " " + (isHigh ? "high" : "low") + "  " + state)
            else
                label.set_text(lb, "")

// Trim the map, counted PER SIDE so a one-sided market cannot push every
// level off one edge of the chart. Furthest from price goes first: the near
// ones are the only ones you can act on, and a chart with forty lines is a
// chart you stop reading.
f_trimSide(bool wantHigh) =>
    bool again = true
    while again
        again := false
        int count = 0
        int worst = -1
        float worstDist = -1.0
        if array.size(lvlPrice) > 0
            for i = 0 to array.size(lvlPrice) - 1
                if array.get(lvlIsHigh, i) == wantHigh and not array.get(lvlBroken, i)
                    count += 1
                    float dist = math.abs(array.get(lvlPrice, i) - close)
                    if dist > worstDist
                        worstDist := dist
                        worst := i
        if count > maxSide and worst >= 0
            f_drop(worst)
            again := true

f_trimSide(true)
f_trimSide(false)

// ═══════════════════════════ what it is worth ═══════════════════════════
// On the chart, not buried in a description. Every figure carries its scope
// and its unit, because a number without those gets read as whatever the
// reader was hoping for.
var table t = table.new(position.bottom_right, 2, 6,
     bgcolor=color.new(color.black, 20), border_color=color.new(color.gray, 60), border_width=1)

if showTable and barstate.islast
    table.cell(t, 0, 0, "Measured: NQ 15m, 2020-2026", text_color=color.white,
         text_size=size.small, text_halign=text.align_left)
    table.cell(t, 1, 0, "n = 7,423", text_color=color.gray, text_size=size.tiny)
    table.cell(t, 0, 1, "Level beats a random line by", text_color=color.gray,
         text_size=size.tiny, text_halign=text.align_left)
    table.cell(t, 1, 1, "0.7 - 1.1 pt per trade", text_color=color.white, text_size=size.tiny)
    table.cell(t, 0, 2, "Round-trip cost on NQ", text_color=color.gray,
         text_size=size.tiny, text_halign=text.align_left)
    table.cell(t, 1, 2, "about 1.0 pt", text_color=color.white, text_size=size.tiny)
    table.cell(t, 0, 3, "Retest holds the level", text_color=color.gray,
         text_size=size.tiny, text_halign=text.align_left)
    table.cell(t, 1, 3, "42.9% of retests", text_color=color.white, text_size=size.tiny)
    table.cell(t, 0, 4, "Retest goes through it", text_color=color.gray,
         text_size=size.tiny, text_halign=text.align_left)
    table.cell(t, 1, 4, "48.9% of retests", text_color=color.white, text_size=size.tiny)
    table.cell(t, 0, 5, "So: context, not a system", text_color=color.rgb(230, 170, 40),
         text_size=size.tiny, text_halign=text.align_left)
    table.cell(t, 1, 5, "8.2% unresolved", text_color=color.gray, text_size=size.tiny)

alertcondition(alertArm and firedArm, "Level armed",
     "A swing level has armed: price has moved away, so a return is now a retest.")
alertcondition(alertTouch and firedTouch, "Price back at an armed level",
     "Price has returned to an armed swing level.")
alertcondition(alertBreak and firedBreak, "Level broken",
     "A swing level has been closed through.")