Arrow.AlgoNexta

// ============================================================================
// © algonexta
// This script is for education and research; it does not guarantee results.
// Verify this source in TradingView before use.
// ============================================================================

//@version=6
indicator(
     "B&A - Bow & Arrow",
     shorttitle = "B&A",
     overlay = true,
     max_labels_count = 500,
     max_lines_count = 500,
     max_boxes_count = 500
)

//──────────────────────────────────────────────────────────────────────────────
// Input groups
//──────────────────────────────────────────────────────────────────────────────
string gFast = "1. Fast MACD - MACD 60"
string gSlow = "2. Slow MACD - MACD 240"
string gDiv = "3. Hidden Divergence"
string gConfirm = "4. Signal Confirmation"
string gCycle = "5. Cycle Control"
string gEma = "6. EMA Trend Filter"
string gRange = "7. Range Filter"
string gSession = "8. Session Filter"
string gVisual = "9. Visual Settings"
string gRisk = "10. SL/TP Projection"
string gDebug = "11. Alerts and Debug"

src = input.source(close, "Source", group = gFast)
fastMacdFastLen = input.int(12, "Fast MACD Fast Length", minval = 1, group = gFast, tooltip = "Fast length for MACD 60.")
fastMacdSlowLen = input.int(26, "Fast MACD Slow Length", minval = 1, group = gFast, tooltip = "Slow length for MACD 60.")
fastMacdSignalLen = input.int(9, "Fast MACD Signal Length", minval = 1, group = gFast, tooltip = "Signal EMA length for MACD 60.")

slowMacdFastLen = input.int(48, "Slow MACD Fast Length", minval = 1, group = gSlow, tooltip = "Fast length for MACD 240.")
slowMacdSlowLen = input.int(104, "Slow MACD Slow Length", minval = 1, group = gSlow, tooltip = "Slow length for MACD 240.")
slowMacdSignalLen = input.int(36, "Slow MACD Signal Length", minval = 1, group = gSlow, tooltip = "Signal EMA length for MACD 240.")
slowZeroBuffer = input.float(0.0, "Slow MACD Zero Buffer", minval = 0.0, step = 0.00001, group = gSlow, tooltip = "Neutral zone around zero. No directional signals are allowed inside this band.")

divOscSource = input.string("MACD Value", "Divergence Oscillator Source", options = ["MACD Value", "Histogram"], group = gDiv)
pivotLeft = input.int(3, "Pivot Left Bars", minval = 1, group = gDiv)
pivotRight = input.int(3, "Pivot Right Bars", minval = 1, group = gDiv)
minPivotDistance = input.int(5, "Minimum Pivot Distance", minval = 1, group = gDiv)
maxPivotDistance = input.int(100, "Maximum Pivot Distance", minval = 2, group = gDiv)
maxDivLines = input.int(50, "Maximum Divergence Lines", minval = 1, maxval = 500, group = gDiv)

requireFastBelowAtBuyTrigger = input.bool(true, "Require Fast MACD Below Zero At Trigger", group = gConfirm, tooltip = "When disabled, the fast MACD may cross its signal slightly above zero after a prior below-zero correction.")
requireFastAboveAtSellTrigger = input.bool(true, "Require Fast MACD Above Zero At Trigger", group = gConfirm, tooltip = "When disabled, the fast MACD may cross its signal slightly below zero after a prior above-zero correction.")
hiddenConfirmMode = input.string("Fast MACD Crosses Signal Line", "Hidden Divergence Confirmation", options = ["Immediate On Pivot Confirmation", "Oscillator Turns Up", "Fast MACD Crosses Signal Line"], group = gConfirm)
maxTriggerWaitBars = input.int(20, "Maximum Trigger Wait Bars", minval = 1, group = gConfirm)

minBarsBetweenSameDirection = input.int(20, "Minimum Bars Between Same-Direction Signals", minval = 0, group = gCycle)
minCorrectionDepthAtrRatio = input.float(0.05, "Minimum Correction Depth (ATR Ratio)", minval = 0.0, step = 0.01, group = gCycle, tooltip = "Fast MACD correction depth must reach this ATR-normalized amount before Type A or hidden-divergence triggers are allowed. Set to 0 for original loose behavior.")

enableEmaFilter = input.bool(true, "Enable EMA Trend Filter", group = gEma)
fastEmaLen = input.int(60, "Fast EMA Length", minval = 1, group = gEma)
slowEmaLen = input.int(240, "Slow EMA Length", minval = 1, group = gEma)
enableSlowEmaSlopeFilter = input.bool(true, "Enable Slow EMA Slope Filter", group = gEma)
slowEmaSlopeLookback = input.int(10, "Slow EMA Slope Lookback", minval = 1, group = gEma)
minSlowEmaSlopeAtrRatio = input.float(0.05, "Minimum Slow EMA Slope ATR Ratio", minval = 0.0, step = 0.01, group = gEma)

rangeFilterMode = input.string("Balanced", "Range Filter Mode", options = ["Off", "Balanced", "Strict"], group = gRange)
adxLen = input.int(14, "ADX Length", minval = 1, group = gRange)
minAdx = input.float(20.0, "Minimum ADX", minval = 0.0, step = 0.5, group = gRange)
minEmaSeparationAtr = input.float(0.20, "Minimum EMA Separation (ATR)", minval = 0.0, step = 0.01, group = gRange)
strengthLookback = input.int(50, "Strength Lookback", minval = 1, group = gRange)
minStrengthMultiplier = input.float(0.50, "Minimum Strength Multiplier", minval = 0.0, step = 0.05, group = gRange)

enableSessionFilter = input.bool(false, "Enable Session Filter", group = gSession)
sessionMode = input.string("London + New York", "Session Mode", options = ["London", "New York", "London + New York", "Custom"], group = gSession)
sessionTimezone = input.string("Etc/UTC", "Timezone", group = gSession)
londonSession = input.session("0700-1600", "London Session", group = gSession)
newYorkSession = input.session("1300-2200", "New York Session", group = gSession)
customSession = input.session("0000-2359", "Custom Session", group = gSession)

showCorrectionSignals = input.bool(true, "Show Correction Release Signals", group = gVisual)
showHiddenSignals = input.bool(true, "Show Hidden Divergence Signals", group = gVisual)
showCombinedSignals = input.bool(true, "Show Combined Signals", group = gVisual)
showSignalText = input.bool(true, "Show Signal Text", group = gVisual)
showDivergenceLines = input.bool(true, "Show Divergence Lines", group = gVisual)
showRejectedSignals = input.bool(false, "Show Rejected Signals", group = gVisual)
showEma60 = input.bool(false, "Show EMA 60", group = gVisual)
showEma240 = input.bool(false, "Show EMA 240", group = gVisual)
showRegimeBackground = input.bool(false, "Show Regime Background", group = gVisual)
showMacdDataWindow = input.bool(true, "Show MACD Values In Data Window", group = gVisual)

showRiskProjection = input.bool(true, "Show SL/TP Projection", group = gRisk)
slMode = input.string("Pivot + ATR Buffer", "SL Mode", options = ["Pivot", "ATR", "Pivot + ATR Buffer"], group = gRisk)
riskAtrLen = input.int(14, "Risk ATR Length", minval = 1, group = gRisk)
slAtrFallback = input.float(1.5, "ATR SL Fallback Multiplier", minval = 0.1, step = 0.1, group = gRisk, tooltip = "Used when ATR mode is selected or no valid pivot exists on the correct side of entry.")
slAtrBuffer = input.float(0.2, "Pivot SL ATR Buffer", minval = 0.0, step = 0.05, group = gRisk)
tp1Rr = input.float(1.0, "TP1 RR", minval = 0.1, step = 0.1, group = gRisk)
tp2Rr = input.float(2.0, "TP2 RR", minval = 0.1, step = 0.1, group = gRisk)
tp3Rr = input.float(3.0, "TP3 RR", minval = 0.1, step = 0.1, group = gRisk)
projectionBars = input.int(25, "Projection Width (Bars)", minval = 1, maxval = 300, group = gRisk)
maxRiskProjections = input.int(20, "Maximum SL/TP Projections", minval = 1, maxval = 50, group = gRisk)

enableDebug = input.bool(false, "Enable Debug Mode", group = gDebug)
showDebugMarkers = input.bool(false, "Show Debug Markers", group = gDebug)

//──────────────────────────────────────────────────────────────────────────────
// Helpers
//──────────────────────────────────────────────────────────────────────────────
f_macd(series float source, int fastLen, int slowLen, int signalLen) =>
    float value = ta.ema(source, fastLen) - ta.ema(source, slowLen)
    float signal = ta.ema(value, signalLen)
    float hist = value - signal
    [value, signal, hist]

f_inSession() =>
    bool london = not na(time(timeframe.period, londonSession, sessionTimezone))
    bool ny = not na(time(timeframe.period, newYorkSession, sessionTimezone))
    bool custom = not na(time(timeframe.period, customSession, sessionTimezone))
    bool allowed = switch sessionMode
        "London" => london
        "New York" => ny
        "London + New York" => london or ny
        => custom
    not enableSessionFilter or allowed

f_rangeFilter(float slowMacd, float emaFast, float emaSlow, float atrValue) =>
    float safeAtr = math.max(atrValue, syminfo.mintick)
    [plusDi, minusDi, adxValue] = ta.dmi(adxLen, adxLen)
    bool adxValid = adxValue >= minAdx
    bool emaSepValid = math.abs(emaFast - emaSlow) / safeAtr >= minEmaSeparationAtr
    float slowStrengthAvg = ta.sma(math.abs(slowMacd), strengthLookback)
    bool strengthValid = math.abs(slowMacd) > slowStrengthAvg * minStrengthMultiplier
    int passCount = (adxValid ? 1 : 0) + (emaSepValid ? 1 : 0) + (strengthValid ? 1 : 0)
    bool rangeOk = switch rangeFilterMode
        "Off" => true
        "Balanced" => passCount >= 2
        => adxValid and emaSepValid and strengthValid
    [rangeOk, adxValid, emaSepValid, strengthValid]

f_emaFilter(bool isBuy, float emaFast, float emaSlow, float atrValue) =>
    bool trendOk = not enableEmaFilter or (isBuy ? emaFast > emaSlow : emaFast < emaSlow)
    float slope = emaSlow - emaSlow[slowEmaSlopeLookback]
    float slopeRatio = math.abs(slope) / math.max(atrValue, syminfo.mintick)
    bool slopeDirectionOk = isBuy ? slope > 0 : slope < 0
    bool slopeOk = not enableSlowEmaSlopeFilter or (slopeDirectionOk and slopeRatio >= minSlowEmaSlopeAtrRatio)
    trendOk and slopeOk

f_signalText(bool isBuy, int signalType) =>
    string dir = isBuy ? "BUY" : "SELL"
    string kind = signalType == 3 ? "COMBO" : signalType == 2 ? "HID" : "REL"
    showSignalText ? "B&A " + dir + "\n" + kind : ""

f_signalColor(bool isBuy, int signalType) =>
    signalType == 3 ? color.yellow : signalType == 2 ? (isBuy ? color.lime : color.red) : (isBuy ? color.aqua : color.orange)

//──────────────────────────────────────────────────────────────────────────────
// MACD, filters, and regime
//──────────────────────────────────────────────────────────────────────────────
[fastMacd, fastSignal, fastHist] = f_macd(src, fastMacdFastLen, fastMacdSlowLen, fastMacdSignalLen)
[slowMacd, slowSignal, slowHist] = f_macd(src, slowMacdFastLen, slowMacdSlowLen, slowMacdSignalLen)

fastDivOsc = divOscSource == "MACD Value" ? fastMacd : fastHist
emaFast = ta.ema(src, fastEmaLen)
emaSlow = ta.ema(src, slowEmaLen)
atr = ta.atr(14)
riskAtr = ta.atr(riskAtrLen)

bullRegime = slowMacd > slowZeroBuffer
bearRegime = slowMacd < -slowZeroBuffer
neutralRegime = not bullRegime and not bearRegime

[rangeOk, adxOk, emaSepOk, strengthOk] = f_rangeFilter(slowMacd, emaFast, emaSlow, atr)
sessionOk = f_inSession()
emaBuyOk = f_emaFilter(true, emaFast, emaSlow, atr)
emaSellOk = f_emaFilter(false, emaFast, emaSlow, atr)

//──────────────────────────────────────────────────────────────────────────────
// State
//──────────────────────────────────────────────────────────────────────────────
var bool bullCorrectionArmed = false
var bool bearCorrectionArmed = false
var bool bullHiddenArmed = false
var bool bearHiddenArmed = false
var bool bullLocked = false
var bool bearLocked = false
var bool bullSawPositiveAfterLock = false
var bool bearSawNegativeAfterLock = false
var float bullCorrectionDepth = 0.0
var float bearCorrectionDepth = 0.0
var int bullHiddenArmedBar = na
var int bearHiddenArmedBar = na
var int lastBuyBar = na
var int lastSellBar = na
var int lastSignalType = 0

var float prevLowPrice = na
var float prevLowOsc = na
var int prevLowBar = na
var float currLowPrice = na
var float currLowOsc = na
var int currLowBar = na

var float prevHighPrice = na
var float prevHighOsc = na
var int prevHighBar = na
var float currHighPrice = na
var float currHighOsc = na
var int currHighBar = na

var array<line> divLines = array.new<line>()
var array<line> riskLines = array.new<line>()
var array<label> riskLabels = array.new<label>()
var array<box> riskBoxes = array.new<box>()

// Reset directional state on opposite/neutral regimes.
if not bullRegime
    bullCorrectionArmed := false
    bullHiddenArmed := false
    bullHiddenArmedBar := na
    bullCorrectionDepth := 0.0

if not bearRegime
    bearCorrectionArmed := false
    bearHiddenArmed := false
    bearHiddenArmedBar := na
    bearCorrectionDepth := 0.0

// A cycle unlocks only after the fast MACD visits the opposite side and then
// starts a fresh correction. This avoids duplicate arrows inside one correction.
if bullLocked
    bullSawPositiveAfterLock := bullSawPositiveAfterLock or fastMacd > 0
    if bullSawPositiveAfterLock and fastMacd <= 0 and bullRegime
        bullLocked := false
        bullSawPositiveAfterLock := false
        bullCorrectionArmed := true
        bullCorrectionDepth := math.abs(fastMacd)

if bearLocked
    bearSawNegativeAfterLock := bearSawNegativeAfterLock or fastMacd < 0
    if bearSawNegativeAfterLock and fastMacd >= 0 and bearRegime
        bearLocked := false
        bearSawNegativeAfterLock := false
        bearCorrectionArmed := true
        bearCorrectionDepth := math.abs(fastMacd)

if bullRegime and fastMacd < 0 and not bullLocked
    bullCorrectionArmed := true
    bullCorrectionDepth := math.max(bullCorrectionDepth, math.abs(fastMacd))

if bearRegime and fastMacd > 0 and not bearLocked
    bearCorrectionArmed := true
    bearCorrectionDepth := math.max(bearCorrectionDepth, math.abs(fastMacd))

minCorrectionDepth = minCorrectionDepthAtrRatio * math.max(atr, syminfo.mintick)
bullCorrectionDepthOk = bullCorrectionArmed and bullCorrectionDepth >= minCorrectionDepth
bearCorrectionDepthOk = bearCorrectionArmed and bearCorrectionDepth >= minCorrectionDepth

//──────────────────────────────────────────────────────────────────────────────
// Confirmed hidden divergence
// Pivot lines are drawn back on the actual pivot bars after confirmation.
// Signal markers are never backdated; they appear only on the confirmation or
// trigger candle after bar close.
//──────────────────────────────────────────────────────────────────────────────
pivotLow = ta.pivotlow(low, pivotLeft, pivotRight)
pivotHigh = ta.pivothigh(high, pivotLeft, pivotRight)
newLowPivot = not na(pivotLow)
newHighPivot = not na(pivotHigh)

bullHiddenConfirmed = false
bearHiddenConfirmed = false

if newLowPivot
    int pivotBar = bar_index - pivotRight
    float pivotOsc = fastDivOsc[pivotRight]
    prevLowPrice := currLowPrice
    prevLowOsc := currLowOsc
    prevLowBar := currLowBar
    currLowPrice := pivotLow
    currLowOsc := pivotOsc
    currLowBar := pivotBar
    int dist = na(prevLowBar) ? na : currLowBar - prevLowBar
    bool distanceOk = not na(dist) and dist >= minPivotDistance and dist <= maxPivotDistance
    bullHiddenConfirmed := bullRegime and not bullLocked and bullCorrectionDepthOk and distanceOk and not na(prevLowPrice) and not na(prevLowOsc) and currLowPrice > prevLowPrice and currLowOsc < prevLowOsc
    if bullHiddenConfirmed
        bullHiddenArmed := true
        bullHiddenArmedBar := bar_index
        if showDivergenceLines and not na(prevLowBar)
            line ln = line.new(prevLowBar, prevLowPrice, currLowBar, currLowPrice, xloc = xloc.bar_index, extend = extend.none, color = color.lime, width = 2)
            array.push(divLines, ln)
            if array.size(divLines) > maxDivLines
                line.delete(array.shift(divLines))

if newHighPivot
    int pivotBar = bar_index - pivotRight
    float pivotOsc = fastDivOsc[pivotRight]
    prevHighPrice := currHighPrice
    prevHighOsc := currHighOsc
    prevHighBar := currHighBar
    currHighPrice := pivotHigh
    currHighOsc := pivotOsc
    currHighBar := pivotBar
    int dist = na(prevHighBar) ? na : currHighBar - prevHighBar
    bool distanceOk = not na(dist) and dist >= minPivotDistance and dist <= maxPivotDistance
    bearHiddenConfirmed := bearRegime and not bearLocked and bearCorrectionDepthOk and distanceOk and not na(prevHighPrice) and not na(prevHighOsc) and currHighPrice < prevHighPrice and currHighOsc > prevHighOsc
    if bearHiddenConfirmed
        bearHiddenArmed := true
        bearHiddenArmedBar := bar_index
        if showDivergenceLines and not na(prevHighBar)
            line ln = line.new(prevHighBar, prevHighPrice, currHighBar, currHighPrice, xloc = xloc.bar_index, extend = extend.none, color = color.red, width = 2)
            array.push(divLines, ln)
            if array.size(divLines) > maxDivLines
                line.delete(array.shift(divLines))

if bullHiddenArmed and (not bullRegime or bar_index - bullHiddenArmedBar > maxTriggerWaitBars)
    bullHiddenArmed := false
    bullHiddenArmedBar := na

if bearHiddenArmed and (not bearRegime or bar_index - bearHiddenArmedBar > maxTriggerWaitBars)
    bearHiddenArmed := false
    bearHiddenArmedBar := na

//──────────────────────────────────────────────────────────────────────────────
// Core triggers
//──────────────────────────────────────────────────────────────────────────────
buyReleaseCore = bullRegime and not bullLocked and bullCorrectionDepthOk and ta.crossover(fastMacd, fastSignal) and (not requireFastBelowAtBuyTrigger or fastMacd < 0)
sellReleaseCore = bearRegime and not bearLocked and bearCorrectionDepthOk and ta.crossunder(fastMacd, fastSignal) and (not requireFastAboveAtSellTrigger or fastMacd > 0)

buyHiddenCore = false
sellHiddenCore = false

if bullHiddenArmed and bullRegime and not bullLocked
    buyHiddenCore := switch hiddenConfirmMode
        "Immediate On Pivot Confirmation" => bullHiddenConfirmed
        "Oscillator Turns Up" => fastDivOsc > fastDivOsc[1]
        => ta.crossover(fastMacd, fastSignal)

if bearHiddenArmed and bearRegime and not bearLocked
    sellHiddenCore := switch hiddenConfirmMode
        "Immediate On Pivot Confirmation" => bearHiddenConfirmed
        "Oscillator Turns Down" => fastDivOsc < fastDivOsc[1]
        => ta.crossunder(fastMacd, fastSignal)

// The options list uses "Oscillator Turns Up" for both directions in TradingView's
// single shared input. For bearish logic, that mode is interpreted symmetrically.
if bearHiddenArmed and bearRegime and not bearLocked and hiddenConfirmMode == "Oscillator Turns Up"
    sellHiddenCore := fastDivOsc < fastDivOsc[1]

buyTypeCore = buyReleaseCore and buyHiddenCore ? 3 : buyHiddenCore ? 2 : buyReleaseCore ? 1 : 0
sellTypeCore = sellReleaseCore and sellHiddenCore ? 3 : sellHiddenCore ? 2 : sellReleaseCore ? 1 : 0

buyCore = buyTypeCore > 0
sellCore = sellTypeCore > 0
buyFiltersOk = bullRegime and emaBuyOk and rangeOk and sessionOk
sellFiltersOk = bearRegime and emaSellOk and rangeOk and sessionOk
buyBarsOk = na(lastBuyBar) or bar_index - lastBuyBar >= minBarsBetweenSameDirection
sellBarsOk = na(lastSellBar) or bar_index - lastSellBar >= minBarsBetweenSameDirection

buyAccepted = barstate.isconfirmed and buyCore and buyFiltersOk and buyBarsOk
sellAccepted = barstate.isconfirmed and sellCore and sellFiltersOk and sellBarsOk
buyRejected = barstate.isconfirmed and buyCore and not buyAccepted
sellRejected = barstate.isconfirmed and sellCore and not sellAccepted

// Consume accepted or rejected core signals so blocked setups do not repeatedly
// produce markers for the same correction.
if buyAccepted or buyRejected
    bullLocked := true
    bullSawPositiveAfterLock := fastMacd > 0
    bullCorrectionArmed := false
    bullCorrectionDepth := 0.0
    bullHiddenArmed := false
    bullHiddenArmedBar := na
    lastSignalType := buyTypeCore
    if buyAccepted
        lastBuyBar := bar_index

if sellAccepted or sellRejected
    bearLocked := true
    bearSawNegativeAfterLock := fastMacd < 0
    bearCorrectionArmed := false
    bearCorrectionDepth := 0.0
    bearHiddenArmed := false
    bearHiddenArmedBar := na
    lastSignalType := sellTypeCore
    if sellAccepted
        lastSellBar := bar_index

buyReleaseSignal = buyAccepted and buyTypeCore == 1
sellReleaseSignal = sellAccepted and sellTypeCore == 1
buyHiddenSignal = buyAccepted and buyTypeCore == 2
sellHiddenSignal = sellAccepted and sellTypeCore == 2
buyCombinedSignal = buyAccepted and buyTypeCore == 3
sellCombinedSignal = sellAccepted and sellTypeCore == 3

buyAny = buyAccepted
sellAny = sellAccepted

//──────────────────────────────────────────────────────────────────────────────
// SL/TP projection
// This remains indicator-only: projected levels are visual guidance from the
// signal close and never place, manage, or simulate orders.
//──────────────────────────────────────────────────────────────────────────────
recentPivotWindow = pivotLeft + pivotRight + 1
recentLowFallback = ta.lowest(low, recentPivotWindow)
recentHighFallback = ta.highest(high, recentPivotWindow)

if showRiskProjection and (buyAccepted or sellAccepted)
    bool isBuyProjection = buyAccepted
    int signalType = isBuyProjection ? buyTypeCore : sellTypeCore
    string signalKind = signalType == 3 ? "COMBO" : signalType == 2 ? "HID" : "REL"
    float entry = close
    float pivotCandidate = isBuyProjection ? currLowPrice : currHighPrice
    float recentFallback = isBuyProjection ? recentLowFallback : recentHighFallback
    bool pivotCandidateOk = not na(pivotCandidate) and (isBuyProjection ? pivotCandidate < entry : pivotCandidate > entry)
    bool recentFallbackOk = not na(recentFallback) and (isBuyProjection ? recentFallback < entry : recentFallback > entry)
    float basePivot = pivotCandidateOk ? pivotCandidate : recentFallbackOk ? recentFallback : na
    float atrStop = isBuyProjection ? entry - riskAtr * slAtrFallback : entry + riskAtr * slAtrFallback
    float pivotStop = na(basePivot) ? atrStop : basePivot
    float sl = switch slMode
        "ATR" => atrStop
        "Pivot" => pivotStop
        => isBuyProjection ? pivotStop - riskAtr * slAtrBuffer : pivotStop + riskAtr * slAtrBuffer
    bool slOk = isBuyProjection ? sl < entry : sl > entry
    if slOk
        float risk = math.abs(entry - sl)
        if risk > syminfo.mintick
            float tp1 = isBuyProjection ? entry + risk * tp1Rr : entry - risk * tp1Rr
            float tp2 = isBuyProjection ? entry + risk * tp2Rr : entry - risk * tp2Rr
            float tp3 = isBuyProjection ? entry + risk * tp3Rr : entry - risk * tp3Rr
            int x1 = bar_index
            int x2 = bar_index + projectionBars
            float riskTop = math.max(entry, sl)
            float riskBottom = math.min(entry, sl)
            float rewardTop = math.max(entry, tp3)
            float rewardBottom = math.min(entry, tp3)

            box riskBox = box.new(left = x1, top = riskTop, right = x2, bottom = riskBottom, xloc = xloc.bar_index, border_color = color.new(color.red, 40), bgcolor = color.new(color.red, 82))
            box rewardBox = box.new(left = x1, top = rewardTop, right = x2, bottom = rewardBottom, xloc = xloc.bar_index, border_color = color.new(color.teal, 40), bgcolor = color.new(color.teal, 82))
            array.push(riskBoxes, riskBox)
            array.push(riskBoxes, rewardBox)

            line entryLine = line.new(x1 = x1, y1 = entry, x2 = x2, y2 = entry, xloc = xloc.bar_index, color = color.new(color.white, 0), style = line.style_dotted, width = 1)
            line slLine = line.new(x1 = x1, y1 = sl, x2 = x2, y2 = sl, xloc = xloc.bar_index, color = color.new(color.red, 0), style = line.style_solid, width = 1)
            line tp1Line = line.new(x1 = x1, y1 = tp1, x2 = x2, y2 = tp1, xloc = xloc.bar_index, color = color.new(color.lime, 0), style = line.style_dotted, width = 1)
            line tp2Line = line.new(x1 = x1, y1 = tp2, x2 = x2, y2 = tp2, xloc = xloc.bar_index, color = color.new(color.lime, 0), style = line.style_dashed, width = 1)
            line tp3Line = line.new(x1 = x1, y1 = tp3, x2 = x2, y2 = tp3, xloc = xloc.bar_index, color = color.new(color.lime, 0), style = line.style_solid, width = 1)
            array.push(riskLines, entryLine)
            array.push(riskLines, slLine)
            array.push(riskLines, tp1Line)
            array.push(riskLines, tp2Line)
            array.push(riskLines, tp3Line)

            label entryLabel = label.new(x = x2, y = entry, xloc = xloc.bar_index, style = label.style_label_left, color = color.new(color.white, 10), textcolor = color.black, text = "Entry " + signalKind)
            label slLabel = label.new(x = x2, y = sl, xloc = xloc.bar_index, style = label.style_label_left, color = color.new(color.red, 0), textcolor = color.white, text = "SL")
            label tp1Label = label.new(x = x2, y = tp1, xloc = xloc.bar_index, style = label.style_label_left, color = color.new(color.lime, 0), textcolor = color.black, text = "TP1 " + str.tostring(tp1Rr) + "R")
            label tp2Label = label.new(x = x2, y = tp2, xloc = xloc.bar_index, style = label.style_label_left, color = color.new(color.lime, 0), textcolor = color.black, text = "TP2 " + str.tostring(tp2Rr) + "R")
            label tp3Label = label.new(x = x2, y = tp3, xloc = xloc.bar_index, style = label.style_label_left, color = color.new(color.lime, 0), textcolor = color.black, text = "TP3 " + str.tostring(tp3Rr) + "R")
            array.push(riskLabels, entryLabel)
            array.push(riskLabels, slLabel)
            array.push(riskLabels, tp1Label)
            array.push(riskLabels, tp2Label)
            array.push(riskLabels, tp3Label)

            while array.size(riskBoxes) > maxRiskProjections * 2
                box.delete(array.shift(riskBoxes))
            while array.size(riskLines) > maxRiskProjections * 5
                line.delete(array.shift(riskLines))
            while array.size(riskLabels) > maxRiskProjections * 5
                label.delete(array.shift(riskLabels))

//──────────────────────────────────────────────────────────────────────────────
// Visual output
//──────────────────────────────────────────────────────────────────────────────
plot(showEma60 ? emaFast : na, "EMA 60", color = color.new(color.aqua, 0), linewidth = 2)
plot(showEma240 ? emaSlow : na, "EMA 240", color = color.new(color.orange, 0), linewidth = 2)

bgcolor(showRegimeBackground ? (bullRegime ? color.new(color.green, 90) : bearRegime ? color.new(color.red, 90) : color.new(color.gray, 92)) : na)

plotshape(showSignalText and showCorrectionSignals and buyReleaseSignal, title = "Buy Correction Release", style = shape.labelup, location = location.belowbar, color = f_signalColor(true, 1), textcolor = color.black, text = "B&A BUY\nREL", size = size.small)
plotshape(showSignalText and showCorrectionSignals and sellReleaseSignal, title = "Sell Correction Release", style = shape.labeldown, location = location.abovebar, color = f_signalColor(false, 1), textcolor = color.black, text = "B&A SELL\nREL", size = size.small)
plotshape(showSignalText and showHiddenSignals and buyHiddenSignal, title = "Buy Hidden Divergence", style = shape.labelup, location = location.belowbar, color = f_signalColor(true, 2), textcolor = color.black, text = "B&A BUY\nHID", size = size.small)
plotshape(showSignalText and showHiddenSignals and sellHiddenSignal, title = "Sell Hidden Divergence", style = shape.labeldown, location = location.abovebar, color = f_signalColor(false, 2), textcolor = color.white, text = "B&A SELL\nHID", size = size.small)
plotshape(showSignalText and showCombinedSignals and buyCombinedSignal, title = "Buy Combined", style = shape.labelup, location = location.belowbar, color = f_signalColor(true, 3), textcolor = color.black, text = "B&A BUY\nCOMBO", size = size.normal)
plotshape(showSignalText and showCombinedSignals and sellCombinedSignal, title = "Sell Combined", style = shape.labeldown, location = location.abovebar, color = f_signalColor(false, 3), textcolor = color.black, text = "B&A SELL\nCOMBO", size = size.normal)
plotshape(not showSignalText and showCorrectionSignals and buyReleaseSignal, title = "Buy Correction Release Arrow", style = shape.triangleup, location = location.belowbar, color = f_signalColor(true, 1), size = size.small)
plotshape(not showSignalText and showCorrectionSignals and sellReleaseSignal, title = "Sell Correction Release Arrow", style = shape.triangledown, location = location.abovebar, color = f_signalColor(false, 1), size = size.small)
plotshape(not showSignalText and showHiddenSignals and buyHiddenSignal, title = "Buy Hidden Divergence Arrow", style = shape.triangleup, location = location.belowbar, color = f_signalColor(true, 2), size = size.small)
plotshape(not showSignalText and showHiddenSignals and sellHiddenSignal, title = "Sell Hidden Divergence Arrow", style = shape.triangledown, location = location.abovebar, color = f_signalColor(false, 2), size = size.small)
plotshape(not showSignalText and showCombinedSignals and buyCombinedSignal, title = "Buy Combined Arrow", style = shape.triangleup, location = location.belowbar, color = f_signalColor(true, 3), size = size.normal)
plotshape(not showSignalText and showCombinedSignals and sellCombinedSignal, title = "Sell Combined Arrow", style = shape.triangledown, location = location.abovebar, color = f_signalColor(false, 3), size = size.normal)

plotshape(showRejectedSignals and buyRejected, title = "Rejected Buy", style = shape.circle, location = location.belowbar, color = color.gray, size = size.tiny)
plotshape(showRejectedSignals and sellRejected, title = "Rejected Sell", style = shape.circle, location = location.abovebar, color = color.gray, size = size.tiny)

plotshape(showDebugMarkers and ta.cross(fastMacd, 0), title = "Fast MACD Zero Cross", style = shape.xcross, location = location.bottom, color = color.gray, size = size.tiny)
plotshape(showDebugMarkers and ta.cross(fastMacd, fastSignal), title = "Fast MACD Signal Cross", style = shape.diamond, location = location.bottom, color = color.blue, size = size.tiny)
plotshape(showDebugMarkers and newLowPivot, title = "Confirmed Pivot Low", style = shape.triangleup, location = location.belowbar, color = color.new(color.lime, 30), size = size.tiny)
plotshape(showDebugMarkers and newHighPivot, title = "Confirmed Pivot High", style = shape.triangledown, location = location.abovebar, color = color.new(color.red, 30), size = size.tiny)
plotshape(showDebugMarkers and bullHiddenConfirmed, title = "Bull Hidden Confirmed", style = shape.circle, location = location.belowbar, color = color.lime, size = size.tiny)
plotshape(showDebugMarkers and bearHiddenConfirmed, title = "Bear Hidden Confirmed", style = shape.circle, location = location.abovebar, color = color.red, size = size.tiny)

plot(showMacdDataWindow ? fastMacd : na, "Fast MACD Value", display = display.data_window, color = color.aqua)
plot(showMacdDataWindow ? fastSignal : na, "Fast Signal Line", display = display.data_window, color = color.red)
plot(showMacdDataWindow ? fastHist : na, "Fast Histogram", display = display.data_window, color = color.gray)
plot(showMacdDataWindow ? slowMacd : na, "Slow MACD Value", display = display.data_window, color = color.blue)
plot(showMacdDataWindow ? slowSignal : na, "Slow Signal Line", display = display.data_window, color = color.orange)
plot(showMacdDataWindow ? slowHist : na, "Slow Histogram", display = display.data_window, color = color.gray)

//──────────────────────────────────────────────────────────────────────────────
// Alerts
//──────────────────────────────────────────────────────────────────────────────
alertcondition(buyAny, "B&A Buy - Any", "B&A BUY | Any | {{ticker}} | {{interval}} | Close: {{close}}")
alertcondition(sellAny, "B&A Sell - Any", "B&A SELL | Any | {{ticker}} | {{interval}} | Close: {{close}}")
alertcondition(buyReleaseSignal, "B&A Buy - Correction Release", "B&A BUY | Correction Release | {{ticker}} | {{interval}} | Close: {{close}}")
alertcondition(sellReleaseSignal, "B&A Sell - Correction Release", "B&A SELL | Correction Release | {{ticker}} | {{interval}} | Close: {{close}}")
alertcondition(buyHiddenSignal, "B&A Buy - Hidden Divergence", "B&A BUY | Hidden Divergence | {{ticker}} | {{interval}} | Close: {{close}}")
alertcondition(sellHiddenSignal, "B&A Sell - Hidden Divergence", "B&A SELL | Hidden Divergence | {{ticker}} | {{interval}} | Close: {{close}}")
alertcondition(buyCombinedSignal, "B&A Buy - Combined", "B&A BUY | Combined | {{ticker}} | {{interval}} | Close: {{close}}")
alertcondition(sellCombinedSignal, "B&A Sell - Combined", "B&A SELL | Combined | {{ticker}} | {{interval}} | Close: {{close}}")

//──────────────────────────────────────────────────────────────────────────────
// Debug table
//──────────────────────────────────────────────────────────────────────────────
var table dbg = table.new(position.top_right, 2, 11, border_width = 1)

if enableDebug and barstate.islast
    string regime = bullRegime ? "Bullish" : bearRegime ? "Bearish" : "Neutral"
    string fastPos = fastMacd > 0 ? "Above 0" : fastMacd < 0 ? "Below 0" : "At 0"
    string lastTypeText = lastSignalType == 3 ? "Combined" : lastSignalType == 2 ? "Hidden" : lastSignalType == 1 ? "Release" : "None"
    string barsSinceBuy = na(lastBuyBar) ? "na" : str.tostring(bar_index - lastBuyBar)
    string barsSinceSell = na(lastSellBar) ? "na" : str.tostring(bar_index - lastSellBar)
    table.cell(dbg, 0, 0, "Slow regime", text_color = color.white)
    table.cell(dbg, 1, 0, regime, text_color = color.white)
    table.cell(dbg, 0, 1, "Fast MACD", text_color = color.white)
    table.cell(dbg, 1, 1, fastPos, text_color = color.white)
    table.cell(dbg, 0, 2, "Bull correction", text_color = color.white)
    table.cell(dbg, 1, 2, str.tostring(bullCorrectionArmed), text_color = color.white)
    table.cell(dbg, 0, 3, "Bear correction", text_color = color.white)
    table.cell(dbg, 1, 3, str.tostring(bearCorrectionArmed), text_color = color.white)
    table.cell(dbg, 0, 4, "Bull hidden", text_color = color.white)
    table.cell(dbg, 1, 4, str.tostring(bullHiddenArmed), text_color = color.white)
    table.cell(dbg, 0, 5, "Bear hidden", text_color = color.white)
    table.cell(dbg, 1, 5, str.tostring(bearHiddenArmed), text_color = color.white)
    table.cell(dbg, 0, 6, "Range filter", text_color = color.white)
    table.cell(dbg, 1, 6, str.tostring(rangeOk), text_color = color.white)
    table.cell(dbg, 0, 7, "EMA filter", text_color = color.white)
    table.cell(dbg, 1, 7, "B:" + str.tostring(emaBuyOk) + " S:" + str.tostring(emaSellOk), text_color = color.white)
    table.cell(dbg, 0, 8, "Session filter", text_color = color.white)
    table.cell(dbg, 1, 8, str.tostring(sessionOk), text_color = color.white)
    table.cell(dbg, 0, 9, "Last signal", text_color = color.white)
    table.cell(dbg, 1, 9, lastTypeText, text_color = color.white)
    table.cell(dbg, 0, 10, "Bars since B/S", text_color = color.white)
    table.cell(dbg, 1, 10, barsSinceBuy + " / " + barsSinceSell, text_color = color.white)