// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © STEEL-CITY-CREATORS

//@version=5
indicator("Elliott Wave (rules-based, compile-safe)", overlay=true, max_lines_count=500, max_labels_count=500)

// ── Inputs ────────────────────────────────────────────────────────────────────
left     = input.int(5,   "Pivot Left",  minval=1)
right    = input.int(5,   "Pivot Right", minval=1)
useATR   = input.bool(true, "Use ATR filter for swing threshold?")
atrLen   = input.int(14, "ATR Length", minval=1)
atrMult  = input.float(1.0, "ATR Multiplier", step=0.1)
minPct   = input.float(0.5, "Min % swing (if ATR off)", step=0.1)
maxBack  = input.int(2000, "Max bars back for drawing", minval=300)
showABC  = input.bool(true, "Attempt A–B–C after 5 waves?")
showZig  = input.bool(true, "Show ZigZag Lines?")
colorUp  = color.new(color.lime, 0)
colorDn  = color.new(color.red,  0)

// ── Globals (declare BEFORE any function uses them) ───────────────────────────
var pivotBars  = array.new_int()
var pivotPrice = array.new_float()
var pivotType  = array.new_int()    // +1 = high, -1 = low

var lineArr    = array.new_line()
var labelArr   = array.new_label()

var int  lastImpulseBar = na
var int  lastABCBar     = na
var bool impulseFound   = false
var bool impulseUp      = false

// ── Helpers ───────────────────────────────────────────────────────────────────
atr = ta.atr(atrLen)

toPctMove(a, b) =>
    math.abs(b - a) / a * 100.0

isSwingBigEnough(prev, curr) =>
    useATR ? math.abs(curr - prev) >= atrMult * atr : toPctMove(prev, curr) >= minPct

// Pivots (confirmed by right bars)
ph = ta.pivothigh(high, left, right)
pl = ta.pivotlow(low,  left, right)

// Add pivot if large enough
addPivot(b, p, t) =>
    bool pushed = false
    if array.size(pivotPrice) == 0
        array.push(pivotBars,  b)
        array.push(pivotPrice, p)
        array.push(pivotType,  t)
        pushed := true
    else
        last = array.get(pivotPrice, array.size(pivotPrice) - 1)
        if isSwingBigEnough(last, p)
            array.push(pivotBars,  b)
            array.push(pivotPrice, p)
            array.push(pivotType,  t)
            pushed := true
    pushed

drawZigZag() =>
    if showZig
        sz = array.size(pivotBars)
        if sz >= 2
            b1 = array.get(pivotBars,  sz - 2)
            p1 = array.get(pivotPrice, sz - 2)
            b2 = array.get(pivotBars,  sz - 1)
            p2 = array.get(pivotPrice, sz - 1)
            ln = line.new(b1, p1, b2, p2, extend=extend.none, width=2, color = p2 > p1 ? colorUp : colorDn)
            array.push(lineArr, ln)

makeLabel(txt, b, p, col) =>
    lb = label.new(b, p, txt, textcolor=color.white, color=col, style=label.style_label_center, size=size.tiny)
    array.push(labelArr, lb)
    lb

// Basic impulse validation using six prices (not arrays)
isUpImpulse(p0, p1, p2, p3, p4, p5) =>
    // L0, H1, HL2, HH3, HL4, HH5
    (p0 < p2 and p2 < p4) and (p1 < p3 and p3 < p5) and (p1 > p0 and p3 > p2 and p5 > p4)

isDnImpulse(p0, p1, p2, p3, p4, p5) =>
    // H0, L1, LH2, LL3, LH4, LL5
    (p0 > p2 and p2 > p4) and (p1 > p3 and p3 > p5) and (p1 < p0 and p3 < p2 and p5 < p4)

// A–B–C check given three prices (A,B,C) and whether prior impulse was up
isABC(pa, pb, pc, uptrend) =>
    uptrend ? (pa > pb and pc < pa and pc < pb) : (pa < pb and pc > pa and pc > pb)

// ── Collect pivots on confirmation ────────────────────────────────────────────
newHigh = not na(ph)
newLow  = not na(pl)

if newHigh
    addPivot(bar_index - right, ph, +1)
    drawZigZag()

if newLow
    addPivot(bar_index - right, pl, -1)
    drawZigZag()

// ── Wave detection & labeling ─────────────────────────────────────────────────
tryLabelImpulse() =>
    // Returns (found, uptrend)
    bool found = false, bool up = false
    sz = array.size(pivotBars)
    if sz >= 6
        // Gather last 6 pivots
        b0 = array.get(pivotBars,  sz - 6)
        b1 = array.get(pivotBars,  sz - 5)
        b2 = array.get(pivotBars,  sz - 4)
        b3 = array.get(pivotBars,  sz - 3)
        b4 = array.get(pivotBars,  sz - 2)
        b5 = array.get(pivotBars,  sz - 1)

        p0 = array.get(pivotPrice, sz - 6)
        p1 = array.get(pivotPrice, sz - 5)
        p2 = array.get(pivotPrice, sz - 4)
        p3 = array.get(pivotPrice, sz - 3)
        p4 = array.get(pivotPrice, sz - 2)
        p5 = array.get(pivotPrice, sz - 1)

        t0 = array.get(pivotType,  sz - 6)
        t1 = array.get(pivotType,  sz - 5)
        t2 = array.get(pivotType,  sz - 4)
        t3 = array.get(pivotType,  sz - 3)
        t4 = array.get(pivotType,  sz - 2)
        t5 = array.get(pivotType,  sz - 1)

        // Alternation (+1/-1) and pattern checks
        altUp   = (t0 == -1 and t1 == +1 and t2 == -1 and t3 == +1 and t4 == -1 and t5 == +1)
        altDown = (t0 == +1 and t1 == -1 and t2 == +1 and t3 == -1 and t4 == +1 and t5 == -1)

        upOk = altUp   and isUpImpulse(p0, p1, p2, p3, p4, p5)
        dnOk = altDown and isDnImpulse(p0, p1, p2, p3, p4, p5)

        if (upOk or dnOk)
            col = upOk ? color.new(color.teal, 0) : color.new(color.orange, 0)
            // Label 1..5 at pivots 1..5
            makeLabel("1", b1, p1, col)
            makeLabel("2", b2, p2, col)
            makeLabel("3", b3, p3, col)
            makeLabel("4", b4, p4, col)
            makeLabel("5", b5, p5, col)
            found := true
            up := upOk
    [found, up]

// On any new pivot, try to detect impulse (tuple destructuring!)
if (newHigh or newLow)
    [found, up] = tryLabelImpulse()
    if found and (na(lastImpulseBar) or bar_index > lastImpulseBar)
        impulseFound   := true
        impulseUp      := up
        lastImpulseBar := bar_index
        alert("Elliott impulse (1–5) completed: " + (impulseUp ? "UP" : "DOWN"), alert.freq_once_per_bar_close)

// ── Try A–B–C after impulse ───────────────────────────────────────────────────
if showABC and impulseFound and (newHigh or newLow)
    sz = array.size(pivotBars)
    if sz >= 9
        pa = array.get(pivotPrice, sz - 3)
        pb = array.get(pivotPrice, sz - 2)
        pc = array.get(pivotPrice, sz - 1)
        ba = array.get(pivotBars,  sz - 3)
        bb = array.get(pivotBars,  sz - 2)
        bc = array.get(pivotBars,  sz - 1)

        if isABC(pa, pb, pc, impulseUp)
            ccol = color.new(color.fuchsia, 0)
            makeLabel("A", ba, pa, ccol)
            makeLabel("B", bb, pb, ccol)
            makeLabel("C", bc, pc, ccol)
            if na(lastABCBar) or bar_index > lastABCBar
                lastABCBar := bar_index
                alert("Elliott correction (A–B–C) detected", alert.freq_once_per_bar_close)

// ── Housekeeping ──────────────────────────────────────────────────────────────
trimOldDrawings() =>
    for i = array.size(lineArr) - 1 to 0
        ln = array.get(lineArr, i)
        x1 = line.get_x1(ln)
        if bar_index - x1 > maxBack
            line.delete(ln)
            array.remove(lineArr, i)
    for i = array.size(labelArr) - 1 to 0
        lb = array.get(labelArr, i)
        xb = label.get_x(lb)
        if bar_index - xb > maxBack
            label.delete(lb)
            array.remove(labelArr, i)

if barstate.islast
    trimOldDrawings()

// ── Visual hints ──────────────────────────────────────────────────────────────
plotshape(newHigh, title="New Pivot High",  style=shape.triangledown, color=colorDn, location=location.abovebar, size=size.tiny, text="PH")
plotshape(newLow,  title="New Pivot Low",   style=shape.triangleup,   color=colorUp, location=location.belowbar, size=size.tiny, text="PL")