//@version=6
// =====================================================================================
//  FUSED — SwingTargets (v1_8) + MTF Manipulation Candle & Zone Detector (v24.1)
//  v2 CHANGES vs v1 (settings/panel only — no detection, drawing, or break logic touched):
//    - SwingTargets' colour-legend table removed entirely (inputs showLegend/legendPos
//      and the table.new() block) — one less thing drawing on the chart, and one less
//      settings group.
//    - Per-TF settings from BOTH engines are now unified: one "TF — 1m" / "TF — 5m" /
//      etc. group holds SwingTargets' rows AND the MC/Zone Detector's row for that same
//      timeframe, placed together at the very top of Settings. Previously they sat in
//      two separate blocks ("SwingTargets — 1m" then, much further down, "MC Zones —
//      1m"), so finding everything for one TF meant scrolling and cross-referencing.
//    - Within each unified group, the per-TF "Enable" checkboxes are now labelled
//      "Enable (Swings)" and "Enable (Zones)" so the two engines' toggles aren't
//      visually identical once they sit side by side.
//  Phase 1 (this build's foundation) is still: both engines byte-for-byte identical in
//  LOGIC to their original scripts — nothing added, removed, or changed in what either
//  engine detects, draws, or breaks on. The v2 edits above are purely settings-panel
//  organisation and one cosmetic feature removal (the legend), both done at your request.
//  Mechanical renames carried over from v1, to let both engines share one script without
//  name clashes: every identifier that existed in BOTH originals (inputs, functions, draw
//  arrays) was prefixed — st_ for SwingTargets, mz_ for the MC/Zone Detector — e.g.
//  boxOpacity -> st_boxOpacity / mz_boxOpacity, proc() -> st_proc()/mz_proc(). chartMin
//  and the invisible "scale_anchor" price-lock plot (identical in both originals) are
//  each declared ONCE and shared. calc_bars_count=0 is inherited from the MC/Zone
//  Detector (it needs max loaded history to anchor higher-TF zones) — this also extends
//  how much history SwingTargets sees, strictly more data, nothing removed.
//  NOT included in this build: zone-overlap/confluence marking, swing sweep-vs-break
//  marking, or the AMC label — all deferred, on purpose, to a later version.
// =====================================================================================
indicator("SwingTargets + MC Zones — Fused v2", overlay=true, max_lines_count=500, max_boxes_count=500, max_labels_count=500, calc_bars_count=0)

// invisible plot: locks the indicator to the chart's price scale (shared by both engines;
// was identical and duplicated in both originals, kept once here).
plot(close, "scale_anchor", color=color.new(color.gray, 100))

// =====================================================================================
//  TIMEFRAME SETTINGS — everything for a given TF (both engines) lives in one place here.
//  "Enable (Swings)" + the rows under it = SwingTargets on that TF.
//  "Enable (Zones)" + "Zones" = the MC/Zone Detector on that TF.
// =====================================================================================
st_en0=input.bool(true,"Enable (Swings)",group="TF — 1m",inline="a"), sw0=input.bool(true,"Show swings",group="TF — 1m",inline="a"), bx0=input.bool(true,"Show boxes",group="TF — 1m",inline="a")
ea0=input.int(2,"Ext above",minval=0,group="TF — 1m",inline="b"), eb0=input.int(2,"Ext below",minval=0,group="TF — 1m",inline="b")
ia0=input.int(2,"Int above",minval=0,group="TF — 1m",inline="c"), ib0=input.int(2,"Int below",minval=0,group="TF — 1m",inline="c")
ec0=input.color(color.gray,"Ext colour",group="TF — 1m",inline="d"), ic0=input.color(color.silver,"Int colour",group="TF — 1m",inline="d")
fe0=input.bool(true,"Show FVGs",group="TF — 1m",inline="e"), fc0=input.color(color.gray,"FVG colour",group="TF — 1m",inline="e")
fa0=input.int(1,"FVG above",minval=0,group="TF — 1m",inline="f"), fb0=input.int(1,"FVG below",minval=0,group="TF — 1m",inline="f")
mz_en0=input.bool(true,"Enable (Zones)",group="TF — 1m",inline="g"), z0=input.bool(false,"Zones",group="TF — 1m",inline="g")

st_en1=input.bool(true,"Enable (Swings)",group="TF — 5m",inline="a"), sw1=input.bool(true,"Show swings",group="TF — 5m",inline="a"), bx1=input.bool(true,"Show boxes",group="TF — 5m",inline="a")
ea1=input.int(2,"Ext above",minval=0,group="TF — 5m",inline="b"), eb1=input.int(2,"Ext below",minval=0,group="TF — 5m",inline="b")
ia1=input.int(2,"Int above",minval=0,group="TF — 5m",inline="c"), ib1=input.int(2,"Int below",minval=0,group="TF — 5m",inline="c")
ec1=input.color(color.blue,"Ext colour",group="TF — 5m",inline="d"), ic1=input.color(color.aqua,"Int colour",group="TF — 5m",inline="d")
fe1=input.bool(true,"Show FVGs",group="TF — 5m",inline="e"), fc1=input.color(color.blue,"FVG colour",group="TF — 5m",inline="e")
fa1=input.int(1,"FVG above",minval=0,group="TF — 5m",inline="f"), fb1=input.int(1,"FVG below",minval=0,group="TF — 5m",inline="f")
mz_en1=input.bool(true,"Enable (Zones)",group="TF — 5m",inline="g"), z1=input.bool(true,"Zones",group="TF — 5m",inline="g")

st_en2=input.bool(true,"Enable (Swings)",group="TF — 15m",inline="a"), sw2=input.bool(true,"Show swings",group="TF — 15m",inline="a"), bx2=input.bool(true,"Show boxes",group="TF — 15m",inline="a")
ea2=input.int(2,"Ext above",minval=0,group="TF — 15m",inline="b"), eb2=input.int(2,"Ext below",minval=0,group="TF — 15m",inline="b")
ia2=input.int(2,"Int above",minval=0,group="TF — 15m",inline="c"), ib2=input.int(2,"Int below",minval=0,group="TF — 15m",inline="c")
ec2=input.color(color.teal,"Ext colour",group="TF — 15m",inline="d"), ic2=input.color(color.green,"Int colour",group="TF — 15m",inline="d")
fe2=input.bool(true,"Show FVGs",group="TF — 15m",inline="e"), fc2=input.color(color.teal,"FVG colour",group="TF — 15m",inline="e")
fa2=input.int(1,"FVG above",minval=0,group="TF — 15m",inline="f"), fb2=input.int(1,"FVG below",minval=0,group="TF — 15m",inline="f")
mz_en2=input.bool(true,"Enable (Zones)",group="TF — 15m",inline="g"), z2=input.bool(false,"Zones",group="TF — 15m",inline="g")

mz_en3=input.bool(true,"Enable (Zones)",group="TF — 30m",inline="g"), z3=input.bool(false,"Zones",group="TF — 30m",inline="g")

st_en3=input.bool(true,"Enable (Swings)",group="TF — 1h",inline="a"), sw3=input.bool(true,"Show swings",group="TF — 1h",inline="a"), bx3=input.bool(true,"Show boxes",group="TF — 1h",inline="a")
ea3=input.int(2,"Ext above",minval=0,group="TF — 1h",inline="b"), eb3=input.int(2,"Ext below",minval=0,group="TF — 1h",inline="b")
ia3=input.int(2,"Int above",minval=0,group="TF — 1h",inline="c"), ib3=input.int(2,"Int below",minval=0,group="TF — 1h",inline="c")
ec3=input.color(color.orange,"Ext colour",group="TF — 1h",inline="d"), ic3=input.color(color.yellow,"Int colour",group="TF — 1h",inline="d")
fe3=input.bool(true,"Show FVGs",group="TF — 1h",inline="e"), fc3=input.color(color.orange,"FVG colour",group="TF — 1h",inline="e")
fa3=input.int(1,"FVG above",minval=0,group="TF — 1h",inline="f"), fb3=input.int(1,"FVG below",minval=0,group="TF — 1h",inline="f")
mz_en4=input.bool(true,"Enable (Zones)",group="TF — 1h",inline="g"), z4=input.bool(true,"Zones",group="TF — 1h",inline="g")

st_en4=input.bool(true,"Enable (Swings)",group="TF — 4h",inline="a"), sw4=input.bool(true,"Show swings",group="TF — 4h",inline="a"), bx4=input.bool(true,"Show boxes",group="TF — 4h",inline="a")
ea4=input.int(2,"Ext above",minval=0,group="TF — 4h",inline="b"), eb4=input.int(2,"Ext below",minval=0,group="TF — 4h",inline="b")
ia4=input.int(2,"Int above",minval=0,group="TF — 4h",inline="c"), ib4=input.int(2,"Int below",minval=0,group="TF — 4h",inline="c")
ec4=input.color(#ff6600,"Ext colour",group="TF — 4h",inline="d"), ic4=input.color(#ffaa66,"Int colour",group="TF — 4h",inline="d")
fe4=input.bool(true,"Show FVGs",group="TF — 4h",inline="e"), fc4=input.color(#ff6600,"FVG colour",group="TF — 4h",inline="e")
fa4=input.int(1,"FVG above",minval=0,group="TF — 4h",inline="f"), fb4=input.int(1,"FVG below",minval=0,group="TF — 4h",inline="f")
mz_en5=input.bool(true,"Enable (Zones)",group="TF — 4h",inline="g"), z5=input.bool(true,"Zones",group="TF — 4h",inline="g")

st_en5=input.bool(true,"Enable (Swings)",group="TF — Daily",inline="a"), sw5=input.bool(true,"Show swings",group="TF — Daily",inline="a"), bx5=input.bool(true,"Show boxes",group="TF — Daily",inline="a")
ea5=input.int(2,"Ext above",minval=0,group="TF — Daily",inline="b"), eb5=input.int(2,"Ext below",minval=0,group="TF — Daily",inline="b")
ia5=input.int(2,"Int above",minval=0,group="TF — Daily",inline="c"), ib5=input.int(2,"Int below",minval=0,group="TF — Daily",inline="c")
ec5=input.color(color.red,"Ext colour",group="TF — Daily",inline="d"), ic5=input.color(#ff9999,"Int colour",group="TF — Daily",inline="d")
fe5=input.bool(true,"Show FVGs",group="TF — Daily",inline="e"), fc5=input.color(color.red,"FVG colour",group="TF — Daily",inline="e")
fa5=input.int(1,"FVG above",minval=0,group="TF — Daily",inline="f"), fb5=input.int(1,"FVG below",minval=0,group="TF — Daily",inline="f")
mz_en6=input.bool(true,"Enable (Zones)",group="TF — Daily",inline="g"), z6=input.bool(true,"Zones",group="TF — Daily",inline="g")

// =====================================================================================
//  ENGINE 1 — SWINGTARGETS  (st_ prefix on every identifier that used to collide)
// =====================================================================================
// =====================================================================================
//  SwingTargets  -  Pine v1_8   (TradingView port of NinjaScript v10's feature set)
//  NEW vs v1_6: per-TF "Show swings" toggle (swOf) — swings and FVGs are now independent
//               siblings under the master per-TF "Enable". Lets you run FVG-only on any
//               timeframe (e.g. 15m FVGs on a 5m chart with no 15m swings).
//  NEW vs v1_7: FVG mitigation is now a 3-way choice (First touch / Full fill / Body
//               close) defaulting to Full fill. The old "Wick touch" default broke every
//               FVG on the first touch of its NEAR edge, so FVGs were detected and then
//               instantly marked broken -> nothing ever drew. Also: FVGs default ON,
//               "showBroken" is finally wired up (diagnostic), and the self-break
//               immunity guard now spans the whole 3-candle pattern.
//
//  PORTS: per-TF swings (internal/external), lines + wick boxes, break vs sweep
//         (selectable), nearest-N per side per TF, min-1, per-TF FVGs, labels,
//         colour-legend table, per-TF colours & counts, current TF and above.
//  NOT PORTED: deep history (Pine = loaded chart bars only), bias engine.
// =====================================================================================

// invisible plot: locks this indicator to the chart's PRICE scale so all lines/boxes
// track the candles when you pan/scroll (fixes "frozen drawings on a separate scale").
// Transparent colour = invisible, but it still anchors the scale (do NOT use display.none).

// ---------------- global inputs ----------------
extLen   = input.int(5, "External strength", minval=1, group="Detection")
intLen   = input.int(2, "Internal strength", minval=1, group="Detection")
swBreakWick  = input.string("Full body close", "Swing break", options=["Full body close","Wick touch"], group="Detection") == "Wick touch"
// FVG mitigation: "First touch" = dies when price touches the NEAR edge (old v1_7
// behaviour, extremely trigger-happy). "Full fill" = dies only once the gap is fully
// closed. "Body close" = dies when a body closes clean through it.
fvgMode = input.string("Full fill", "FVG mitigation", options=["First touch","Full fill","Body close"], group="Detection")

showLines     = input.bool(true,  "Show lines",  group="Display")
showBroken    = input.bool(false, "Show broken zones", group="Display")
distinguish   = input.bool(true,  "Distinguish internal/external", group="Display")
guaranteeMin  = input.bool(true,  "Guarantee min 1 per side", group="Display")
showLabels    = input.bool(true,  "Show labels", group="Display")
labelPlusType = input.string("TF + type","Label style", options=["TF + type","TF only"], group="Display") == "TF + type"
st_labelStackT   = input.int(10, "Label stack tolerance (ticks)", minval=1, group="Display")
st_labelStep     = input.int(4,  "Label horizontal step (bars)", minval=1, group="Display")
lineW         = input.int(2,  "Line width", minval=1, maxval=4, group="Display")
st_boxOpacity    = input.int(18, "Box opacity (0-100)", minval=0, maxval=100, group="Display")

// ---------------- per-TF inputs (inlined; Pine requires const args) ----------------
// "Enable"      = master switch for this TF (nothing at all if off)
// "Show swings" = swing lines/boxes/labels for this TF
// "Show FVGs"   = FVG boxes/labels for this TF   <- independent of "Show swings"
// ---------------- ladder accessors ----------------
st_tfMin(i)  => i==0?1   : i==1?5   : i==2?15  : i==3?60  : i==4?240 : 1440
st_tfName(i) => i==0?"1m": i==1?"5m": i==2?"15m": i==3?"1h": i==4?"4h":"D"
st_enOf(i)   => i==0?st_en0:i==1?st_en1:i==2?st_en2:i==3?st_en3:i==4?st_en4:st_en5
swOf(i)   => i==0?sw0:i==1?sw1:i==2?sw2:i==3?sw3:i==4?sw4:sw5
bxOf(i)   => i==0?bx0:i==1?bx1:i==2?bx2:i==3?bx3:i==4?bx4:bx5
eaOf(i)   => i==0?ea0:i==1?ea1:i==2?ea2:i==3?ea3:i==4?ea4:ea5
ebOf(i)   => i==0?eb0:i==1?eb1:i==2?eb2:i==3?eb3:i==4?eb4:eb5
iaOf(i)   => i==0?ia0:i==1?ia1:i==2?ia2:i==3?ia3:i==4?ia4:ia5
ibOf(i)   => i==0?ib0:i==1?ib1:i==2?ib2:i==3?ib3:i==4?ib4:ib5
ecOf(i)   => i==0?ec0:i==1?ec1:i==2?ec2:i==3?ec3:i==4?ec4:ec5
icOf(i)   => i==0?ic0:i==1?ic1:i==2?ic2:i==3?ic3:i==4?ic4:ic5
feOf(i)   => i==0?fe0:i==1?fe1:i==2?fe2:i==3?fe3:i==4?fe4:fe5
faOf(i)   => i==0?fa0:i==1?fa1:i==2?fa2:i==3?fa3:i==4?fa4:fa5
fbOf(i)   => i==0?fb0:i==1?fb1:i==2?fb2:i==3?fb3:i==4?fb4:fb5
fcOf(i)   => i==0?fc0:i==1?fc1:i==2?fc2:i==3?fc3:i==4?fc4:fc5

chartMin = timeframe.in_seconds(timeframe.period) / 60
st_activeTF(i) => st_tfMin(i) >= chartMin and st_enOf(i)

// ---------------- types ----------------
type Swing
    int   tf
    float extreme
    float bodyEdge
    int   t
    bool  isHigh
    bool  isExt
    bool  broken
    int   breakT
type Fvg
    int   tf
    float lo
    float hi
    int   t
    bool  isBull
    bool  broken
    int   breakT

var array<Swing> swings = array.new<Swing>()
var array<Fvg>   fvgs   = array.new<Fvg>()

// ---------------- per-TF data via one security call each (confirmed) ----------------
st_f_tf() =>
    phi = ta.pivothigh(intLen, intLen)
    pli = ta.pivotlow(intLen, intLen)
    phe = ta.pivothigh(extLen, extLen)
    ple = ta.pivotlow(extLen, extLen)
    beHiI = math.max(open[intLen], close[intLen])
    beLoI = math.min(open[intLen], close[intLen])
    tiI   = time[intLen]
    beHiE = math.max(open[extLen], close[extLen])
    beLoE = math.min(open[extLen], close[extLen])
    tiE   = time[extLen]
    cC = close[1]
    cH = high[1]
    cL = low[1]
    bull = high[3] < low[1]
    bear = low[3]  > high[1]
    fLo = bull ? high[3] : bear ? high[1] : na
    fHi = bull ? low[1]  : bear ? low[3]  : na
    fT  = time[2]
    [phi, pli, phe, ple, beHiI, beLoI, tiI, beHiE, beLoE, tiE, cC, cH, cL, bull, bear, fLo, fHi, fT]

[a0_phi,a0_pli,a0_phe,a0_ple,a0_beHiI,a0_beLoI,a0_tiI,a0_beHiE,a0_beLoE,a0_tiE,a0_cC,a0_cH,a0_cL,a0_bull,a0_bear,a0_fLo,a0_fHi,a0_fT] = request.security(syminfo.tickerid, "1",   st_f_tf(), lookahead=barmerge.lookahead_off)
[a1_phi,a1_pli,a1_phe,a1_ple,a1_beHiI,a1_beLoI,a1_tiI,a1_beHiE,a1_beLoE,a1_tiE,a1_cC,a1_cH,a1_cL,a1_bull,a1_bear,a1_fLo,a1_fHi,a1_fT] = request.security(syminfo.tickerid, "5",   st_f_tf(), lookahead=barmerge.lookahead_off)
[a2_phi,a2_pli,a2_phe,a2_ple,a2_beHiI,a2_beLoI,a2_tiI,a2_beHiE,a2_beLoE,a2_tiE,a2_cC,a2_cH,a2_cL,a2_bull,a2_bear,a2_fLo,a2_fHi,a2_fT] = request.security(syminfo.tickerid, "15",  st_f_tf(), lookahead=barmerge.lookahead_off)
[a3_phi,a3_pli,a3_phe,a3_ple,a3_beHiI,a3_beLoI,a3_tiI,a3_beHiE,a3_beLoE,a3_tiE,a3_cC,a3_cH,a3_cL,a3_bull,a3_bear,a3_fLo,a3_fHi,a3_fT] = request.security(syminfo.tickerid, "60",  st_f_tf(), lookahead=barmerge.lookahead_off)
[a4_phi,a4_pli,a4_phe,a4_ple,a4_beHiI,a4_beLoI,a4_tiI,a4_beHiE,a4_beLoE,a4_tiE,a4_cC,a4_cH,a4_cL,a4_bull,a4_bear,a4_fLo,a4_fHi,a4_fT] = request.security(syminfo.tickerid, "240", st_f_tf(), lookahead=barmerge.lookahead_off)
[a5_phi,a5_pli,a5_phe,a5_ple,a5_beHiI,a5_beLoI,a5_tiI,a5_beHiE,a5_beLoE,a5_tiE,a5_cC,a5_cH,a5_cL,a5_bull,a5_bear,a5_fLo,a5_fHi,a5_fT] = request.security(syminfo.tickerid, "D",   st_f_tf(), lookahead=barmerge.lookahead_off)

// process each TF only when ITS htf bar changes (handle each htf bar once, not on every
// chart bar) -> prevents higher-TF zones from re-checking stale data and self-breaking
st_new0 = ta.change(time("1"))   != 0
st_new1 = ta.change(time("5"))   != 0
st_new2 = ta.change(time("15"))  != 0
st_new3 = ta.change(time("60"))  != 0
st_new4 = ta.change(time("240")) != 0
st_new5 = ta.change(time("D"))   != 0

// ---------------- add / break helpers ----------------
addSwing(tf, extreme, bodyEdge, t, isHigh, isExt) =>
    handled = false
    if array.size(swings) > 0
        for i = 0 to array.size(swings)-1
            s = array.get(swings, i)
            if s.tf==tf and s.t==t and s.isHigh==isHigh
                if isExt and not s.isExt
                    s.isExt := true
                handled := true
                break
    if not handled and not na(extreme)
        array.push(swings, Swing.new(tf, extreme, bodyEdge, t, isHigh, isExt, false, na))

addFvg(tf, lo, hi, t, isBull) =>
    handled = false
    if array.size(fvgs) > 0
        for i = 0 to array.size(fvgs)-1
            f = array.get(fvgs, i)
            if f.tf==tf and f.t==t
                handled := true
                break
    if not handled and not na(lo) and not na(hi)
        array.push(fvgs, Fvg.new(tf, lo, hi, t, isBull, false, na))

swingBroke(isHigh, extreme, hi, lo, cl) =>
    swBreakWick ? (isHigh ? hi >= extreme : lo <= extreme) : (isHigh ? cl > extreme : cl < extreme)

fvgBroke(isBull, lo, hi, h, l, c) =>
    r = false
    if fvgMode == "First touch"
        r := isBull ? l <= hi : h >= lo      // near edge
    else if fvgMode == "Full fill"
        r := isBull ? l <= lo : h >= hi      // far edge - gap fully closed
    else
        r := isBull ? c < lo : c > hi        // body through it
    r

st_proc(tf, isNew, phi,pli,phe,ple, beHiI,beLoI,tiI, beHiE,beLoE,tiE, cC,cH,cL, bull,bear,fLo,fHi,fT) =>
    if st_activeTF(tf) and isNew
        // ADD newly formed zones once per htf bar (using htf data). Break-checking is NOT
        // done here anymore — it happens every CHART bar against chart price (see below),
        // so a higher-TF zone dies when the candle in front of you breaks it, not only on
        // a close of its own timeframe. (cC/cH/cL kept in the signature but unused now.)
        // swOf(tf) / feOf(tf) gate ingestion: a TF with swings off never grows the swing
        // array, so FVG-only mode costs nothing in break-check work.
        if swOf(tf) and not na(phi)
            addSwing(tf, phi, beHiI, tiI, true,  false)
        if swOf(tf) and not na(pli)
            addSwing(tf, pli, beLoI, tiI, false, false)
        if swOf(tf) and not na(phe)
            addSwing(tf, phe, beHiE, tiE, true,  true)
        if swOf(tf) and not na(ple)
            addSwing(tf, ple, beLoE, tiE, false, true)
        if feOf(tf) and bull
            addFvg(tf, fLo, fHi, fT, true)
        if feOf(tf) and bear
            addFvg(tf, fLo, fHi, fT, false)

st_proc(0, st_new0, a0_phi,a0_pli,a0_phe,a0_ple, a0_beHiI,a0_beLoI,a0_tiI, a0_beHiE,a0_beLoE,a0_tiE, a0_cC,a0_cH,a0_cL, a0_bull,a0_bear,a0_fLo,a0_fHi,a0_fT)
st_proc(1, st_new1, a1_phi,a1_pli,a1_phe,a1_ple, a1_beHiI,a1_beLoI,a1_tiI, a1_beHiE,a1_beLoE,a1_tiE, a1_cC,a1_cH,a1_cL, a1_bull,a1_bear,a1_fLo,a1_fHi,a1_fT)
st_proc(2, st_new2, a2_phi,a2_pli,a2_phe,a2_ple, a2_beHiI,a2_beLoI,a2_tiI, a2_beHiE,a2_beLoE,a2_tiE, a2_cC,a2_cH,a2_cL, a2_bull,a2_bear,a2_fLo,a2_fHi,a2_fT)
st_proc(3, st_new3, a3_phi,a3_pli,a3_phe,a3_ple, a3_beHiI,a3_beLoI,a3_tiI, a3_beHiE,a3_beLoE,a3_tiE, a3_cC,a3_cH,a3_cL, a3_bull,a3_bear,a3_fLo,a3_fHi,a3_fT)
st_proc(4, st_new4, a4_phi,a4_pli,a4_phe,a4_ple, a4_beHiI,a4_beLoI,a4_tiI, a4_beHiE,a4_beLoE,a4_tiE, a4_cC,a4_cH,a4_cL, a4_bull,a4_bear,a4_fLo,a4_fHi,a4_fT)
st_proc(5, st_new5, a5_phi,a5_pli,a5_phe,a5_ple, a5_beHiI,a5_beLoI,a5_tiI, a5_beHiE,a5_beLoE,a5_tiE, a5_cC,a5_cH,a5_cL, a5_bull,a5_bear,a5_fLo,a5_fHi,a5_fT)

// ---- break-check EVERY zone against the CHART's own price, every chart bar ----
// This is the fix: a 4h zone breaks when the 1h candle in front of you breaks it (wick
// or body per mode), instead of waiting for a 4h close. Per-zone guard `time >= t + one
// htf bar` skips the zone's own formation bar so it can't instant-break itself.
// >>> To make higher-TF body-close breaks wait for a true higher-TF close instead of a
//     chart close, this is the line to change. As-is: chart price counts (reactive).
if array.size(swings) > 0
    for i = 0 to array.size(swings)-1
        s = array.get(swings, i)
        if not s.broken and time >= s.t + st_tfMin(s.tf)*60000 and swingBroke(s.isHigh, s.extreme, high, low, close)
            s.broken := true
            s.breakT := time
if array.size(fvgs) > 0
    for i = 0 to array.size(fvgs)-1
        f = array.get(fvgs, i)
        if not f.broken and time > f.t + 2*st_tfMin(f.tf)*60000 and fvgBroke(f.isBull, f.lo, f.hi, high, low, close)
            f.broken := true
            f.breakT := time

// ---------------- draw ----------------
var array<line>  st_dLines  = array.new<line>()
var array<box>   st_dBoxes  = array.new<box>()
var array<label> st_dLabels = array.new<label>()
var array<float> lblPrice = array.new<float>()
var array<string> lblText = array.new<string>()
var array<color>  lblCol  = array.new<color>()

st_clearDrawn() =>
    if array.size(st_dLines) > 0
        for i = 0 to array.size(st_dLines)-1
            line.delete(array.get(st_dLines, i))
    if array.size(st_dBoxes) > 0
        for i = 0 to array.size(st_dBoxes)-1
            box.delete(array.get(st_dBoxes, i))
    if array.size(st_dLabels) > 0
        for i = 0 to array.size(st_dLabels)-1
            label.delete(array.get(st_dLabels, i))
    array.clear(st_dLines)
    array.clear(st_dBoxes)
    array.clear(st_dLabels)

labelTxt(tf, isExt, isFvg) =>
    base = st_tfName(tf)
    labelPlusType ? (isFvg ? base + " FVG" : base + (isExt ? " Ext" : " Int")) : base

drawSwing(s, col) =>
    rightT = s.broken ? s.breakT : time
    if showLines
        ln = line.new(s.t, s.extreme, rightT, s.extreme, xloc=xloc.bar_time, color=col, width=lineW, force_overlay=true)
        array.push(st_dLines, ln)
    if bxOf(s.tf)
        bx = box.new(s.t, math.max(s.extreme, s.bodyEdge), rightT, math.min(s.extreme, s.bodyEdge), xloc=xloc.bar_time, border_color=col, bgcolor=color.new(col, 100-st_boxOpacity), force_overlay=true)
        array.push(st_dBoxes, bx)

drawFvg(f, col) =>
    rightT = f.broken ? f.breakT : time
    bx = box.new(f.t, f.hi, rightT, f.lo, xloc=xloc.bar_time, border_color=col, bgcolor=color.new(col, 100-st_boxOpacity), force_overlay=true)
    array.push(st_dBoxes, bx)

// nearest-N selection of swings for (tf,isHigh,isExt)
selectSwings(tf, isHigh, isExt, n, price) =>
    res = array.new<Swing>()
    if n > 0 and array.size(swings) > 0
        tmp = array.new<Swing>()
        for i = 0 to array.size(swings)-1
            s = array.get(swings, i)
            if s.tf==tf and (showBroken or not s.broken) and s.isHigh==isHigh and s.isExt==isExt
                array.push(tmp, s)
        cnt = math.min(n, array.size(tmp))
        if cnt > 0
            for k = 0 to cnt-1
                bestIdx = -1
                bestD = 1.7976931348623157e308
                for j = 0 to array.size(tmp)-1
                    s = array.get(tmp, j)
                    d = math.abs(s.extreme - price)
                    if d < bestD
                        bestD := d
                        bestIdx := j
                if bestIdx >= 0
                    array.push(res, array.get(tmp, bestIdx))
                    array.remove(tmp, bestIdx)
    res

// nearest-N selection of FVGs for tf, side (above=bearish, below=bullish)
selectFvgs(tf, wantBull, n, price) =>
    res = array.new<Fvg>()
    if n > 0 and array.size(fvgs) > 0
        tmp = array.new<Fvg>()
        for i = 0 to array.size(fvgs)-1
            f = array.get(fvgs, i)
            if f.tf==tf and (showBroken or not f.broken) and f.isBull==wantBull
                array.push(tmp, f)
        cnt = math.min(n, array.size(tmp))
        if cnt > 0
            for k = 0 to cnt-1
                bestIdx = -1
                bestD = 1.7976931348623157e308
                for j = 0 to array.size(tmp)-1
                    f = array.get(tmp, j)
                    refp = f.isBull ? f.hi : f.lo
                    d = math.abs(refp - price)
                    if d < bestD
                        bestD := d
                        bestIdx := j
                if bestIdx >= 0
                    array.push(res, array.get(tmp, bestIdx))
                    array.remove(tmp, bestIdx)
    res

pushLabel(p, t, c) =>
    array.push(lblPrice, p)
    array.push(lblText, t)
    array.push(lblCol, c)

placeLabels() =>
    n = array.size(lblPrice)
    if showLabels and n > 0
        order = array.new<int>()
        for i = 0 to n-1
            array.push(order, i)
        if n > 1
            for i = 0 to n-2
                for j = 0 to n-2-i
                    a = array.get(order, j)
                    b = array.get(order, j+1)
                    if array.get(lblPrice, a) > array.get(lblPrice, b)
                        array.set(order, j, b)
                        array.set(order, j+1, a)
        tol = syminfo.mintick * st_labelStackT
        i = 0
        while i < n
            j = i
            while j+1 < n and math.abs(array.get(lblPrice, array.get(order, j+1)) - array.get(lblPrice, array.get(order, i))) <= tol
                j := j + 1
            for k = i to j
                idx = array.get(order, k)
                slot = k - i
                lb = label.new(bar_index + (slot+1)*st_labelStep, array.get(lblPrice, idx), array.get(lblText, idx), xloc=xloc.bar_index, style=label.style_label_left, color=color.new(color.black,100), textcolor=array.get(lblCol, idx), size=size.small, force_overlay=true)
                array.push(st_dLabels, lb)
            i := j + 1

if barstate.islast
    st_clearDrawn()
    array.clear(lblPrice)
    array.clear(lblText)
    array.clear(lblCol)
    price = close

    for tf = 0 to 5
        if st_activeTF(tf)
            colExt = ecOf(tf)
            colInt = distinguish ? icOf(tf) : ecOf(tf)

            // ---- swings (independent of FVGs) ----
            if swOf(tf)
                selHE = selectSwings(tf, true,  true,  eaOf(tf), price)
                selHI = selectSwings(tf, true,  false, iaOf(tf), price)
                selLE = selectSwings(tf, false, true,  ebOf(tf), price)
                selLI = selectSwings(tf, false, false, ibOf(tf), price)

                if array.size(selHE) > 0
                    for i = 0 to array.size(selHE)-1
                        s = array.get(selHE, i)
                        drawSwing(s, colExt)
                        pushLabel(s.extreme, labelTxt(tf, true, false), colExt)
                if array.size(selHI) > 0
                    for i = 0 to array.size(selHI)-1
                        s = array.get(selHI, i)
                        drawSwing(s, colInt)
                        pushLabel(s.extreme, labelTxt(tf, false, false), colInt)
                if array.size(selLE) > 0
                    for i = 0 to array.size(selLE)-1
                        s = array.get(selLE, i)
                        drawSwing(s, colExt)
                        pushLabel(s.extreme, labelTxt(tf, true, false), colExt)
                if array.size(selLI) > 0
                    for i = 0 to array.size(selLI)-1
                        s = array.get(selLI, i)
                        drawSwing(s, colInt)
                        pushLabel(s.extreme, labelTxt(tf, false, false), colInt)

            // ---- FVGs (independent of swings) ----
            if feOf(tf)
                selFA = selectFvgs(tf, false, faOf(tf), price)  // bearish = above
                selFB = selectFvgs(tf, true,  fbOf(tf), price)  // bullish = below
                if array.size(selFA) > 0
                    for i = 0 to array.size(selFA)-1
                        f = array.get(selFA, i)
                        drawFvg(f, fcOf(tf))
                        pushLabel(f.lo, labelTxt(tf, false, true), fcOf(tf))
                if array.size(selFB) > 0
                    for i = 0 to array.size(selFB)-1
                        f = array.get(selFB, i)
                        drawFvg(f, fcOf(tf))
                        pushLabel(f.hi, labelTxt(tf, false, true), fcOf(tf))

    placeLabels()

// =====================================================================================
//  ENGINE 2 — MC / ZONE DETECTOR  (mz_ prefix on every identifier that used to collide)
// =====================================================================================
// ============================================================================
// MTF Manipulation Candle & Zone Detector — build v24.1 (2 compile fixes: undeclared biw, z0 shadowing)
// Full feature set on the working per-TF zone engine, verified end-to-end:
//   - Zones on all timeframes, current-TF-and-above only
//   - Full settings layout matched to the original screenshots
//   - Clean right-edge zone labels — no candle-bubble clutter, nothing below chart TF
//   - Consolidated labels — zones at the same price merge into one "A | B" label
//   - Candle highlighting (MC and AMC bar colours)
//   - Min Rating gate, Max Touches filter, 50% Midline, Zone Extension Offset
//   - BOS confirmation actually computed (native per-TF swing + confirm window)
//   - Flip zones with lookback expiry
//   - Unconfirmed MC Action (None / Fade / Remove Zones) wired
//   - Rating [n], BIW +, touch ×N — all on the labels
//   - No per-TF caps: every unmitigated zone draws (per your "I need all the
//     zones at all times" — an artificial cap was hiding real zones)
//
// TWO FIXES for "not all 1H/4H/Daily zones show on 5m (they do on 15m+)" and
// "the zone disappears when price is inside it":
//   Fix 1 - Mitigation now checks each zone ONLY against its own native timeframes
//      confirmed close — never chart price on every chart bar. A stray 5m close
//      past a 1H zones edge used to break it even though the real 1H candle
//      never closed there.
//   Fix 2 - calc_bars_count=0 loads maximum chart history, and box left edges clamp
//      to the oldest loaded bar (first_bar_time) instead of failing to render
//      when a zones source candle predates the loaded window — the direct
//      cause of fewer HTF zones surviving on a low chart TF, which covers less
//      calendar time per bar than a higher one.
// ============================================================================
// calc_bars_count=0: load the MAXIMUM history TradingView will provide. Without
// this, a low chart TF (5m) covers far less calendar time than a higher one
// (15m+) for the same bar count — so fewer 1H/4H/Daily candles exist within the
// loaded window, and their zones can't be detected or anchored. This is why
// zones showed on 15m+ but not all of them on 5m.

// invisible plot: lock to price scale (same trick the reference uses)

// ============================================================================
// INPUTS — full layout, grouped to match the original settings screenshots.
// The per-TF ladder (mz_en0..mz_en6 / z0..z6) that the working engine depends on is
// preserved exactly; extra groups are added around it. No caps anywhere — every
// detected zone is created and drawn; only real mitigation or flip-expiry ever
// removes one.
// ============================================================================

// --- Multi-Timeframe (MTF) Settings ---
enable_mtf = input.bool(true, "Enable MTF Functionality", group="MULTI-TIMEFRAME (MTF) SETTINGS")

// --- Current Timeframe (CTF) Settings ---
show_ctf_mc         = input.bool(true,  "Show CTF Manipulation Candles", group="CURRENT TIMEFRAME (CTF) SETTINGS")
show_ctf_zones      = input.bool(false, "Show CTF Manipulation Zones",   group="CURRENT TIMEFRAME (CTF) SETTINGS")
ctf_mc_display_mode = input.string("Highlight", "CTF MC Display Mode", options=["Highlight","Label","Both","None"], group="CURRENT TIMEFRAME (CTF) SETTINGS")
bullish_mc_highlight_color = input.color(#00e000, "Bullish MC Highlight", group="CURRENT TIMEFRAME (CTF) SETTINGS")
bearish_mc_highlight_color = input.color(#c2185b, "Bearish MC Highlight", group="CURRENT TIMEFRAME (CTF) SETTINGS")

// --- AMC Detection ---
enable_amc_detection = input.bool(true,  "Enable AMC Detection", group="ATTEMPTED MANIPULATION CANDLE (AMC) DETECTION")
highlight_ctf_amcs   = input.bool(true,  "Highlight CTF AMCs",   group="ATTEMPTED MANIPULATION CANDLE (AMC) DETECTION")
bullish_amc_color    = input.color(#2196f3, "Bullish AMC Color",  group="ATTEMPTED MANIPULATION CANDLE (AMC) DETECTION")
bearish_amc_color    = input.color(#f06292, "Bearish AMC Color",  group="ATTEMPTED MANIPULATION CANDLE (AMC) DETECTION")
show_htf_amc_labels  = input.bool(true,  "Show HTF AMC Labels",  group="ATTEMPTED MANIPULATION CANDLE (AMC) DETECTION")

// --- MC Strength Settings ---
enable_strength_rating = input.bool(true, "Enable Strength Rating", group="MANIPULATION CANDLE (MC) STRENGTH SETTINGS")
vol_lookback  = input.int(10, "Volume Lookback Period", minval=1, group="MANIPULATION CANDLE (MC) STRENGTH SETTINGS")
min_vol_ratio = input.float(1.0, "Min Volume Ratio (Rating 1)",  group="MANIPULATION CANDLE (MC) STRENGTH SETTINGS")
max_vol_ratio = input.float(1.5, "Max Volume Ratio (Rating 10)", group="MANIPULATION CANDLE (MC) STRENGTH SETTINGS")
show_rating_mc   = input.bool(true, "Show Rating on MC Labels",   group="MANIPULATION CANDLE (MC) STRENGTH SETTINGS")
show_rating_zone = input.bool(true, "Show Rating on Zone Labels", group="MANIPULATION CANDLE (MC) STRENGTH SETTINGS")
min_rating = input.int(0, "Min Rating", minval=0, maxval=10, group="MANIPULATION CANDLE (MC) STRENGTH SETTINGS")
below_min_rating_action = input.string("Hide Everything", "Below Min Rating", options=["Show All (Hide Rating Only)","Hide Labels & Highlighting","Hide Zones","Hide Everything"], group="MANIPULATION CANDLE (MC) STRENGTH SETTINGS")

// --- BIW Detection ---
enable_biw_detection = input.bool(true, "Enable BIW Detection", group="BODY INSIDE WICK (BIW) DETECTION")
show_biw_mc   = input.bool(true, "Show BIW '+' on MC Labels",   group="BODY INSIDE WICK (BIW) DETECTION")
show_biw_zone = input.bool(true, "Show BIW '+' on Zone Labels", group="BODY INSIDE WICK (BIW) DETECTION")

// --- BOS Tracking ---
enable_bos_tracking = input.bool(true, "Enable BOS Tracking", group="BREAK OF STRUCTURE (BOS) TRACKING SETTINGS")
swing_lb    = input.int(3,  "Swing Lookback",          minval=1, group="BREAK OF STRUCTURE (BOS) TRACKING SETTINGS")
bos_window  = input.int(10, "BOS Confirmation Window",  minval=1, group="BREAK OF STRUCTURE (BOS) TRACKING SETTINGS")
unconfirmed_mc_action = input.string("None", "Unconfirmed MC Action", options=["None","Fade","Remove Zones"], group="BREAK OF STRUCTURE (BOS) TRACKING SETTINGS")
show_bos_checkmark = input.bool(true, "Show BOS '✓' on Zone Labels", group="BREAK OF STRUCTURE (BOS) TRACKING SETTINGS")
fade_transparency  = input.int(90, "Fade Transparency", minval=0, maxval=100, group="BREAK OF STRUCTURE (BOS) TRACKING SETTINGS")

// --- MC Label Appearance ---
show_mtf_mc_labels   = input.bool(true, "Show MTF MC Labels", group="MANIPULATION CANDLE (MC) LABEL APPEARANCE")
bullish_mc_label_col = input.color(#4caf50, "Bullish MC Label Background", group="MANIPULATION CANDLE (MC) LABEL APPEARANCE")
bullish_mc_text_col  = input.color(#ffffff, "Bullish MC Text",            group="MANIPULATION CANDLE (MC) LABEL APPEARANCE")
bearish_mc_label_col = input.color(#f44336, "Bearish MC Label Background", group="MANIPULATION CANDLE (MC) LABEL APPEARANCE")
bearish_mc_text_col  = input.color(#ffffff, "Bearish MC Text",            group="MANIPULATION CANDLE (MC) LABEL APPEARANCE")
mc_label_size_str    = input.string("tiny", "Label Size", options=["tiny","small","normal","large"], group="MANIPULATION CANDLE (MC) LABEL APPEARANCE")

// --- Manipulation Zone Settings ---
show_zones  = input.bool(true, "Show Manipulation Zones", group="MANIPULATION ZONE SETTINGS")
zone_method = input.string("Source Body", "Zone Detection Method", options=["Source Candle","Source Body","MC Wick"], group="MANIPULATION ZONE SETTINGS")
show_touch_count    = input.bool(true, "Show Touch Count on Labels", group="MANIPULATION ZONE SETTINGS")
max_touches_to_show = input.string("Show All", "Max Touches to Show", options=["Show All","1","2","3","4","5"], group="MANIPULATION ZONE SETTINGS")
zone_extension_offset = input.int(1, "Zone Extension Offset (bars)", minval=0, group="MANIPULATION ZONE SETTINGS")
show_50_midline     = input.bool(false, "Show 50% Midline", group="MANIPULATION ZONE SETTINGS")
midline_style_input = input.string("Dotted", "Midline Style", options=["Solid","Dotted","Dashed"], group="MANIPULATION ZONE SETTINGS")
midline_width = input.int(1, "Midline Width", minval=1, group="MANIPULATION ZONE SETTINGS")
midline_color = input.color(#808080, "Midline Color", group="MANIPULATION ZONE SETTINGS")

// --- Zone Colours & Labels ---
bull_zone_col = input.color(#008080, "Bullish Zone", group="MANIPULATION ZONE COLOURS")
bear_zone_col = input.color(#800000, "Bearish Zone", group="MANIPULATION ZONE COLOURS")
mz_boxOpacity    = input.int(85, "Box transparency (0-100)", minval=0, maxval=100, group="MANIPULATION ZONE COLOURS")
show_labels   = input.bool(true, "Show Labels", group="MANIPULATION ZONE LABEL SETTINGS")
consolidate_overlapping = input.bool(true, "Consolidate Overlapping Labels", group="MANIPULATION ZONE LABEL SETTINGS")
mz_labelStackT   = input.int(200, "Consolidation Distance (Ticks)", minval=1, group="MANIPULATION ZONE LABEL SETTINGS")
mz_labelStep     = input.int(4,  "Label horizontal step (bars)", minval=1, group="MANIPULATION ZONE LABEL SETTINGS")

// --- Flip Zones ---
show_flip = input.bool(true, "Show Flip Zones", group="FLIP ZONE SETTINGS")
flip_lookback_bars = input.int(5000, "Flip Zone Lookback (bars)", minval=1, group="FLIP ZONE SETTINGS")
bull_flip_col = input.color(#008080, "Bullish Flip Zone (support ↑)",    group="FLIP ZONE SETTINGS")
bear_flip_col = input.color(#800080, "Bearish Flip Zone (resistance ↓)", group="FLIP ZONE SETTINGS")

// ---------------- ladder accessors (reference pattern) ----------------
tfCode(i) => i==0?"1" : i==1?"5" : i==2?"15" : i==3?"30" : i==4?"60" : i==5?"240" : "D"
mz_tfMin(i)  => i==0?1   : i==1?5   : i==2?15   : i==3?30   : i==4?60   : i==5?240   : 1440
mz_tfName(i) => i==0?"1m": i==1?"5m": i==2?"15m": i==3?"30m": i==4?"1H" : i==5?"4H"  : "D"
mz_enOf(i)   => i==0?mz_en0:i==1?mz_en1:i==2?mz_en2:i==3?mz_en3:i==4?mz_en4:i==5?mz_en5:mz_en6
zOf(i)    => i==0?z0 :i==1?z1 :i==2?z2 :i==3?z3 :i==4?z4 :i==5?z5 :z6

// SAME rule as the reference: current TF and ABOVE only.
mz_activeTF(i) => mz_tfMin(i) >= chartMin and mz_enOf(i) and zOf(i)

// ---------------- types ----------------
type Zone
    int   tf
    int   dir          // 1 bull/demand, -1 bear/supply
    float top
    float bottom
    int   t            // source (swept) candle time = left anchor
    int   rating
    bool  biw
    bool  confirmed
    bool  broken
    int   breakT
    bool  isFlip
    int   flipBar
    int   touches
    bool  armed

var array<Zone> zones = array.new<Zone>()

// Oldest loaded bar's time. A zone's source candle can be older than this on a
// low chart TF; box.new can't anchor a left edge before the earliest loaded
// bar, so drawTFdir clamps to this instead of silently failing to render.
var int first_bar_time = 0
if barstate.isfirst
    first_bar_time := time

// ---------------- per-TF MC detection via one security call each ----------------
// Returns the just-closed bar's MC info. Same "confirmed via [1]" idea the
// reference uses for its pivots (time[intLen] etc are shifted-back confirmed).
mz_f_tf() =>
    bull = low[1] < low[2] and close[1] > open[2] and close[1] > high[2]
    bear = high[1] > high[2] and close[1] < open[2] and close[1] < low[2]
    // source (swept) candle = the one before the MC = [2]
    sHi = high[2]
    sLo = low[2]
    sOp = open[2]
    sCl = close[2]
    mHi = high[1]
    mLo = low[1]
    sT  = time[2]
    // strength
    vsma = ta.sma(volume, vol_lookback)
    vr = vsma[2] > 0 ? volume[1] / vsma[2] : 0.0
    rat = math.round(math.max(0, math.min(10, (vr - min_vol_ratio) / (max_vol_ratio - min_vol_ratio) * 9 + 1)))
    // BIW: prior body inside MC wick
    biwB = math.max(sOp,sCl) <= open[1] and math.min(sOp,sCl) >= low[1]
    biwS = math.min(sOp,sCl) >= open[1] and math.max(sOp,sCl) <= high[1]
    biw = bull ? biwB : bear ? biwS : false
    // BOS: track the most recent confirmed native swing high/low (pivot with
    // swing_lb bars each side, shifted via [1] so it's confirmed/non-repainting).
    // After an MC forms, watch for a later native close beyond that swing within
    // bos_window NATIVE bars of that timeframe.
    ph = ta.pivothigh(swing_lb, swing_lb)
    pl = ta.pivotlow(swing_lb, swing_lb)
    var float lastSH = na
    var float lastSL = na
    lastSH := na(ph) ? lastSH : ph
    lastSL := na(pl) ? lastSL : pl
    var float aSH = na
    var int bBars = 9999
    var bool bConf = false
    if bull
        aSH := lastSH
        bBars := 0
        bConf := false
    else
        bBars += 1
    if not bConf and bBars <= bos_window and close > aSH
        bConf := true
    var float aSL = na
    var int rBars = 9999
    var bool rConf = false
    if bear
        aSL := lastSL
        rBars := 0
        rConf := false
    else
        rBars += 1
    if not rConf and rBars <= bos_window and close < aSL
        rConf := true
    [bull, bear, sHi, sLo, sOp, sCl, mHi, mLo, sT, rat, biw, bConf, rConf]

// Second lightweight fetch: the native confirmed bar's own close/high/low, used
// ONLY for break-check and touch counting — so a zone is only ever tested
// against ITS OWN timeframe's confirmed data, never the chart's price. (Testing
// against chart price every chart bar was the earlier bug: on a 5m chart, any
// stray 5m close past a 1H/4H/Daily zone's far edge broke it instantly, even
// though the real 1H candle never closed there — worse on lower chart TFs, and
// able to fire while price was still inside the zone.)
f_conf() => [close[1], high[1], low[1]]

[a0b,a0s,a0sh,a0sl,a0so,a0sc,a0mh,a0ml,a0t,a0r,a0w,a0bc,a0rc] = request.security(syminfo.tickerid, "1",   mz_f_tf(), lookahead=barmerge.lookahead_off)
[a1b,a1s,a1sh,a1sl,a1so,a1sc,a1mh,a1ml,a1t,a1r,a1w,a1bc,a1rc] = request.security(syminfo.tickerid, "5",   mz_f_tf(), lookahead=barmerge.lookahead_off)
[a2b,a2s,a2sh,a2sl,a2so,a2sc,a2mh,a2ml,a2t,a2r,a2w,a2bc,a2rc] = request.security(syminfo.tickerid, "15",  mz_f_tf(), lookahead=barmerge.lookahead_off)
[a3b,a3s,a3sh,a3sl,a3so,a3sc,a3mh,a3ml,a3t,a3r,a3w,a3bc,a3rc] = request.security(syminfo.tickerid, "30",  mz_f_tf(), lookahead=barmerge.lookahead_off)
[a4b,a4s,a4sh,a4sl,a4so,a4sc,a4mh,a4ml,a4t,a4r,a4w,a4bc,a4rc] = request.security(syminfo.tickerid, "60",  mz_f_tf(), lookahead=barmerge.lookahead_off)
[a5b,a5s,a5sh,a5sl,a5so,a5sc,a5mh,a5ml,a5t,a5r,a5w,a5bc,a5rc] = request.security(syminfo.tickerid, "240", mz_f_tf(), lookahead=barmerge.lookahead_off)
[a6b,a6s,a6sh,a6sl,a6so,a6sc,a6mh,a6ml,a6t,a6r,a6w,a6bc,a6rc] = request.security(syminfo.tickerid, "D",   mz_f_tf(), lookahead=barmerge.lookahead_off)

[c0c,c0h,c0l] = request.security(syminfo.tickerid, "1",   f_conf(), lookahead=barmerge.lookahead_off)
[c1c,c1h,c1l] = request.security(syminfo.tickerid, "5",   f_conf(), lookahead=barmerge.lookahead_off)
[c2c,c2h,c2l] = request.security(syminfo.tickerid, "15",  f_conf(), lookahead=barmerge.lookahead_off)
[c3c,c3h,c3l] = request.security(syminfo.tickerid, "30",  f_conf(), lookahead=barmerge.lookahead_off)
[c4c,c4h,c4l] = request.security(syminfo.tickerid, "60",  f_conf(), lookahead=barmerge.lookahead_off)
[c5c,c5h,c5l] = request.security(syminfo.tickerid, "240", f_conf(), lookahead=barmerge.lookahead_off)
[c6c,c6h,c6l] = request.security(syminfo.tickerid, "D",   f_conf(), lookahead=barmerge.lookahead_off)

tfClose(i) => i==0?c0c:i==1?c1c:i==2?c2c:i==3?c3c:i==4?c4c:i==5?c5c:c6c
tfHigh(i)  => i==0?c0h:i==1?c1h:i==2?c2h:i==3?c3h:i==4?c4h:i==5?c5h:c6h
tfLow(i)   => i==0?c0l:i==1?c1l:i==2?c2l:i==3?c3l:i==4?c4l:i==5?c5l:c6l

// process each TF only when ITS bar changes (reference pattern exactly)
mz_new0 = ta.change(time("1"))   != 0
mz_new1 = ta.change(time("5"))   != 0
mz_new2 = ta.change(time("15"))  != 0
mz_new3 = ta.change(time("30"))  != 0
mz_new4 = ta.change(time("60"))  != 0
mz_new5 = ta.change(time("240")) != 0
mz_new6 = ta.change(time("D"))   != 0
tfIsNew(i) => i==0?mz_new0:i==1?mz_new1:i==2?mz_new2:i==3?mz_new3:i==4?mz_new4:i==5?mz_new5:mz_new6

// ---------------- add helper (reference's addSwing/addFvg pattern) ----------------
zoneTop(dir, sh, sl, so, sc, mh, ml) =>
    zone_method == "Source Candle" ? sh : zone_method == "Source Body" ? math.max(so,sc) : (dir==1 ? sl : mh)
zoneBot(dir, sh, sl, so, sc, mh, ml) =>
    zone_method == "Source Candle" ? sl : zone_method == "Source Body" ? math.min(so,sc) : (dir==1 ? ml : sh)

addZone(tf, dir, sh, sl, so, sc, mh, ml, t, rating, biw) =>
    handled = false
    if array.size(zones) > 0
        for i = 0 to array.size(zones)-1
            z = array.get(zones, i)
            if z.tf==tf and z.t==t and z.dir==dir
                handled := true
                break
    if not handled and not na(sh)
        top = zoneTop(dir, sh, sl, so, sc, mh, ml)
        bot = zoneBot(dir, sh, sl, so, sc, mh, ml)
        // confirmed starts false; updateConfirm() below sets it true once BOS
        // actually happens (it can't be known at the moment the MC forms).
        array.push(zones, Zone.new(tf, dir, top, bot, t, rating, biw, false, false, na, false, na, 0, true))

// Once a direction's BOS confirms (bConf/rConf from mz_f_tf), mark the MOST
// RECENT unconfirmed zone for that (tf,dir) as confirmed. bConf/rConf stay
// true for as long as that MC remains the active one being tracked, so this
// is safe to call every bar — it only flips confirmed from false to true.
updateConfirm(tf, dir, conf) =>
    if conf and array.size(zones) > 0
        for i = array.size(zones)-1 to 0
            z = array.get(zones, i)
            if z.tf==tf and z.dir==dir
                if not z.confirmed
                    z.confirmed := true
                break

mz_proc(tf, isNew, bull, bear, sh, sl, so, sc, mh, ml, t, rating, biw, bconf, rconf) =>
    // Min Rating gate: below-min signals dropped unless the action keeps them.
    bool rating_ok = rating >= min_rating or below_min_rating_action == "Show All (Hide Rating Only)" or below_min_rating_action == "Hide Labels & Highlighting"
    if mz_activeTF(tf) and isNew and enable_mtf and show_zones and rating_ok
        if bull
            addZone(tf, 1, sh, sl, so, sc, mh, ml, t, rating, biw)
        if bear
            addZone(tf, -1, sh, sl, so, sc, mh, ml, t, rating, biw)
    if mz_activeTF(tf) and enable_bos_tracking
        updateConfirm(tf, 1, bconf)
        updateConfirm(tf, -1, rconf)

mz_proc(0, mz_new0, a0b,a0s,a0sh,a0sl,a0so,a0sc,a0mh,a0ml,a0t,a0r,a0w,a0bc,a0rc)
mz_proc(1, mz_new1, a1b,a1s,a1sh,a1sl,a1so,a1sc,a1mh,a1ml,a1t,a1r,a1w,a1bc,a1rc)
mz_proc(2, mz_new2, a2b,a2s,a2sh,a2sl,a2so,a2sc,a2mh,a2ml,a2t,a2r,a2w,a2bc,a2rc)
mz_proc(3, mz_new3, a3b,a3s,a3sh,a3sl,a3so,a3sc,a3mh,a3ml,a3t,a3r,a3w,a3bc,a3rc)
mz_proc(4, mz_new4, a4b,a4s,a4sh,a4sl,a4so,a4sc,a4mh,a4ml,a4t,a4r,a4w,a4bc,a4rc)
mz_proc(5, mz_new5, a5b,a5s,a5sh,a5sl,a5so,a5sc,a5mh,a5ml,a5t,a5r,a5w,a5bc,a5rc)
mz_proc(6, mz_new6, a6b,a6s,a6sh,a6sl,a6so,a6sc,a6mh,a6ml,a6t,a6r,a6w,a6bc,a6rc)



// ---- zone lifecycle: touches, break/flip, expiry — ALL evaluated on each
// zone's OWN native timeframe, on ITS OWN new-bar close, never the chart's ----
// This is the fix for zones breaking/vanishing spuriously (worse on low chart
// TFs, able to fire while price sat inside the zone): a stray CHART candle
// closing past a zone's far edge used to break it even though the zone's own
// timeframe never actually closed there. Now only that timeframe's own
// confirmed close/high/low can touch or break its zones, checked only when
// that timeframe's own bar has just closed.
if array.size(zones) > 0
    idx = array.size(zones) - 1
    while idx >= 0
        z = array.get(zones, idx)
        bool past_formation = time > z.t + mz_tfMin(z.tf)*60000
        bool tf_new = tfIsNew(z.tf)

        if not z.broken and past_formation and tf_new
            float ncl = tfClose(z.tf)
            float nhi = tfHigh(z.tf)
            float nlo = tfLow(z.tf)

            // Touch counting: native wick re-enters the zone after having
            // fully closed back out (per the manual: "only after price has
            // closed fully back outside since the last touch").
            bool inside = nlo <= z.top and nhi >= z.bottom
            bool outside = z.dir==1 ? ncl > z.top : ncl < z.bottom
            if inside and z.armed
                z.touches := z.touches + 1
                z.armed := false
            if outside
                z.armed := true

            // Break / flip on a NATIVE close through the far side.
            bool brokeThrough = z.dir==1 ? ncl < z.bottom : ncl > z.top
            if brokeThrough
                if show_flip and not z.isFlip
                    z.isFlip := true
                    z.dir := -z.dir
                    z.touches := 0
                    z.armed := true
                    z.flipBar := bar_index
                else
                    z.broken := true
                    z.breakT := time

        // Flip lookback expiry: remove a flip zone after N bars (chart bars,
        // matching the input's own "bars" label).
        if z.isFlip and (bar_index - z.flipBar) > flip_lookback_bars
            array.remove(zones, idx)
        idx := idx - 1

// ============================================================================
// BATCH 2 — CTF candle highlighting + MC/AMC candle labels.
// Self-contained: does not touch the zone engine above.
// ============================================================================

// CTF native detection (on the chart's own candles — like the 5m that works).
ctf_mc_bull  = low < low[1] and close > open[1] and close > high[1]
ctf_mc_bear  = high > high[1] and close < open[1] and close < low[1]
ctf_amc_bull = low < low[1] and high > open[1] and close >= (open[1]+close[1])/2 and close <= high[1]
ctf_amc_bear = high > high[1] and low < open[1] and close <= (open[1]+close[1])/2 and close >= low[1]

ctf_vsma = ta.sma(volume, vol_lookback)
ctf_vr = ctf_vsma[1] > 0 ? volume / ctf_vsma[1] : 0.0
ctf_rat = math.round(math.max(0, math.min(10, (ctf_vr - min_vol_ratio) / (max_vol_ratio - min_vol_ratio) * 9 + 1)))
ctf_biw_bull = math.max(open[1],close[1]) <= open and math.min(open[1],close[1]) >= low
ctf_biw_bear = math.min(open[1],close[1]) >= open and math.max(open[1],close[1]) <= high

lblSize = mc_label_size_str=="tiny"?size.tiny:mc_label_size_str=="small"?size.small:mc_label_size_str=="large"?size.large:size.normal

// CTF candle highlight (bar colour)
bool ctf_hl = ctf_mc_display_mode=="Highlight" or ctf_mc_display_mode=="Both"
color bcol = na
if show_ctf_mc and ctf_hl and ctf_mc_bull
    bcol := bullish_mc_highlight_color
if show_ctf_mc and ctf_hl and ctf_mc_bear
    bcol := bearish_mc_highlight_color
if enable_amc_detection and highlight_ctf_amcs and ctf_amc_bull
    bcol := bullish_amc_color
if enable_amc_detection and highlight_ctf_amcs and ctf_amc_bear
    bcol := bearish_amc_color
barcolor(bcol)

// CTF MC label
bool ctf_lbl = ctf_mc_display_mode=="Label" or ctf_mc_display_mode=="Both"
if show_ctf_mc and ctf_lbl and (ctf_mc_bull or ctf_mc_bear)
    bt = (ctf_biw_bull or ctf_biw_bear) and enable_biw_detection ? "+" : ""
    rt = enable_strength_rating and show_rating_mc ? " ["+bt+str.tostring(ctf_rat)+"]" : ""
    label.new(bar_index, ctf_mc_bull?low:high, "CTF-MC "+(ctf_mc_bull?"↑":"↓")+rt, style=ctf_mc_bull?label.style_label_up:label.style_label_down, color=ctf_mc_bull?bullish_mc_label_col:bearish_mc_label_col, textcolor=ctf_mc_bull?bullish_mc_text_col:bearish_mc_text_col, size=lblSize, force_overlay=true)

// (MTF MC candle labels removed — they cluttered the chart with bubbles on every
//  candle and leaked lower-TF labels. Zone labels at the right edge are the only
//  labels, matching the intended clean look.)
// (rows 5, 6 MTF MC labels also removed)

// ---------------- draw (reference's mz_clearDrawn + redraw on islast) ----------------
var array<box>   mz_dBoxes  = array.new<box>()
var array<line>  mz_dLines  = array.new<line>()
var array<label> mz_dLabels = array.new<label>()

mz_clearDrawn() =>
    if array.size(mz_dBoxes) > 0
        for i = 0 to array.size(mz_dBoxes)-1
            box.delete(array.get(mz_dBoxes, i))
    if array.size(mz_dLines) > 0
        for i = 0 to array.size(mz_dLines)-1
            line.delete(array.get(mz_dLines, i))
    if array.size(mz_dLabels) > 0
        for i = 0 to array.size(mz_dLabels)-1
            label.delete(array.get(mz_dLabels, i))
    array.clear(mz_dBoxes)
    array.clear(mz_dLines)
    array.clear(mz_dLabels)

zcolor(z) =>
    z.isFlip ? (z.dir==1 ? bull_flip_col : bear_flip_col) : (z.dir==1 ? bull_zone_col : bear_zone_col)

zlabel(z) =>
    arr = z.dir==1 ? "↑" : "↓"
    z.isFlip ? mz_tfName(z.tf)+" "+arr+" FLIP"+(z.touches>0?" ×"+str.tostring(z.touches):"") : mz_tfName(z.tf)+" "+arr+" ["+(z.biw?"+":"")+str.tostring(z.rating)+"]"+(z.confirmed?" ✓":"")+(z.touches>0?" ×"+str.tostring(z.touches):"")

// Zones actually drawn this bar (for the consolidated-label pass).
var array<Zone> drawnZones = array.new<Zone>()

// Draw EVERY zone of a (tf, dir). No cap, no nearest-N, no filtering — every
// unmitigated zone is drawn. Filters/caps NEVER remove a zone from the chart;
// only real mitigation or flip-expiry (handled elsewhere) removes one. Boxes
// are pushed here; labels are placed afterwards, side by side.
drawTFdir(tf, dir) =>
    if array.size(zones) > 0
        for i = 0 to array.size(zones)-1
            z = array.get(zones, i)
            if z.tf==tf and z.dir==dir and not z.broken
                // Max Touches to Show: hide (don't draw) zones touched more than N times.
                bool over_touch = false
                if max_touches_to_show != "Show All"
                    over_touch := z.touches > str.tonumber(max_touches_to_show)

                // Unconfirmed MC Action: a fresh (non-flip) zone whose own BOS
                // confirmation window has elapsed without confirming.
                float barsElapsed = (time - z.t) / (mz_tfMin(z.tf) * 60000.0)
                bool window_expired = enable_bos_tracking and not z.isFlip and not z.confirmed and barsElapsed > bos_window
                bool remove_unconf = window_expired and unconfirmed_mc_action == "Remove Zones"
                bool fade_unconf   = window_expired and unconfirmed_mc_action == "Fade"

                if not over_touch and not remove_unconf
                    rightT = z.broken ? z.breakT : time
                    col = zcolor(z)
                    int trans = fade_unconf ? math.max(mz_boxOpacity, fade_transparency) : mz_boxOpacity
                    // Clamp the left edge to the oldest loaded bar. Without this,
                    // a zone whose source candle is older than the chart's loaded
                    // history has nowhere to anchor and can fail to render at all
                    // — the direct cause of HTF zones being present on a 15m+
                    // chart (more loaded calendar time) but missing on 5m.
                    int leftT = math.max(z.t, first_bar_time)
                    bx = box.new(leftT, z.top, rightT, z.bottom, xloc=xloc.bar_time, border_color=col, bgcolor=color.new(col, trans), force_overlay=true)
                    array.push(mz_dBoxes, bx)
                    if show_50_midline
                        mid = (z.top + z.bottom) / 2
                        ml2 = line.new(leftT, mid, rightT, mid, xloc=xloc.bar_time, color=midline_color, width=midline_width, style=(midline_style_input=="Solid"?line.style_solid:midline_style_input=="Dashed"?line.style_dashed:line.style_dotted), force_overlay=true)
                        array.push(mz_dLines, ml2)
                    array.push(drawnZones, z)

if barstate.islast
    mz_clearDrawn()
    array.clear(drawnZones)
    // draw ALL zones, every tf (current-and-above) and both directions
    for tf = 0 to 6
        if mz_activeTF(tf)
            drawTFdir(tf, 1)    // bullish/demand
            drawTFdir(tf, -1)   // bearish/supply

    // ---- labels: zones at nearly the same price MERGE into one "A | B" label ----
    // (the manual's documented format, e.g. "1H ↓ [+0] ✓ ×2 | 4H ↓ [+0] ✓ ×2").
    // consolidate_overlapping toggles this; off = each zone gets its own label
    // at its own price with no merging.
    if show_labels and array.size(drawnZones) > 0
        tick = syminfo.mintick
        float tol = consolidate_overlapping ? mz_labelStackT * tick : 0.0
        int nZones = array.size(drawnZones)

        // sort drawnZones by price (simple insertion sort into an index order
        // array — nZones is small, at most a few dozen, so O(n^2) is fine)
        order = array.new<int>()
        for i = 0 to nZones-1
            array.push(order, i)
        if nZones > 1
            for i = 0 to nZones-2
                for j = 0 to nZones-2-i
                    za = array.get(drawnZones, array.get(order, j))
                    zb = array.get(drawnZones, array.get(order, j+1))
                    if (za.top+za.bottom)/2 > (zb.top+zb.bottom)/2
                        tmp = array.get(order, j)
                        array.set(order, j, array.get(order, j+1))
                        array.set(order, j+1, tmp)

        i = 0
        while i < nZones
            zGroupFirst = array.get(drawnZones, array.get(order, i))
            float basePrice = (zGroupFirst.top + zGroupFirst.bottom) / 2
            j = i
            while j+1 < nZones and math.abs((array.get(drawnZones, array.get(order, j+1)).top + array.get(drawnZones, array.get(order, j+1)).bottom)/2 - basePrice) <= tol
                j := j + 1
            // merge zlabel() text for indices i..j, separated by " | "
            string merged = ""
            float sumPrice = 0.0
            for k = i to j
                zk = array.get(drawnZones, array.get(order, k))
                merged := merged + (k > i ? " | " : "") + zlabel(zk)
                sumPrice += (zk.top + zk.bottom) / 2
            float labelPrice = sumPrice / (j - i + 1)
            col = zcolor(zGroupFirst)
            lb = label.new(bar_index + zone_extension_offset + mz_labelStep, labelPrice, merged, xloc=xloc.bar_index, style=label.style_label_left, color=color.new(color.black,100), textcolor=col, size=size.small, force_overlay=true)
            array.push(mz_dLabels, lb)
            i := j + 1