ROC Advanced [WavesUnchained]

//@version=6
// ============================================================================
// ROC Advanced [WavesUnchained]
// Version: 1.4.2
// Author: WavesUnchained
// Build: 2026-10-02 00:00:00
// ============================================================================
// Rate of Change with trend context, stall/absorption, conviction markers, and
// directional long/short coloring on a zero-centered momentum core.
//
// Features:
//   ✓ Classic percentage ROC core with pluggable smoothing and signal line
//   ✓ Zero-centered panel with configurable positive/negative stretch zones
//   ✓ Stall/absorption context: marks crosses contradicted by flat price as weak
//   ✓ Trend context line (slow ROC): support the fast line rests on
//   ✓ Trend↔ROC divergence wedge: fast and trend move opposite
//   ✓ Long/Short coloring for trend context, histogram, and divergence wedge
//   ✓ Sentiment Bar — live ±100 stretch-zone extremity score + mini bar
//   ✓ Signal Quality — optional 0-100 conviction score per Bull/Bear cross
//   ✓ Gradient line color, shadow fills, and alerts
//
// ============================================================================

indicator("ROC Advanced [WavesUnchained]", "ROC·ADV", format=format.price, precision=2, overlay=false, max_labels_count=500)

// ─────────────────────────────────────────────────────────────────────────────
// INPUTS
// ─────────────────────────────────────────────────────────────────────────────

g_core = "1 · Core"
src    = input.source(close, "Source",         group=g_core)
rocLen = input.int(12,     "ROC Length",       minval=1, group=g_core)
avgLen = input.int(3,      "Average Length",   minval=1, group=g_core)
sigLen = input.int(9,      "Signal Length",    minval=1, group=g_core)
smoothType = input.string("EMA", "Smoothing Type",
     options=["EMA", "SMA", "RMA", "WMA", "SuperSmoother", "T3", "KAMA", "JMA Approx"],
     group=g_core)
jmaPhase = input.int(50,    "  JMA Phase", minval=-100, maxval=100,             group=g_core)
jmaPower = input.float(2.0, "  JMA Power", minval=1.0,  maxval=4.0, step=0.25, group=g_core)

g_levels = "2 · Mid / Levels"
midLine    = input.float(0.0,  "Midline",             group=g_levels)
obLevel    = input.float(5.0,  "Positive Stretch",    minval=0, step=0.5, group=g_levels)
osLevel    = input.float(-5.0, "Negative Stretch",    maxval=0, step=0.5, group=g_levels)

g_stall = "3 · Stall / Absorption"
useStall     = input.bool(true, "Detect Stall (ROC moves, price holds)", group=g_stall)
stallLen     = input.int(5,     "Stall Lookback (bars)", minval=1, group=g_stall)
stallFlatATR = input.float(0.5, "Max Price Move (ATR)",  minval=0.0, step=0.1, group=g_stall)
stallRocMin  = input.float(3.0, "Min ROC Move",          minval=0,   step=0.5, group=g_stall)

g_ctx = "4 · Trend Context"
useCtx = input.bool(true, "Show Trend Context Line", group=g_ctx)
ctxLen = input.int(50, "Trend ROC Length", minval=2, group=g_ctx)

g_conv = "5 · Conviction"
useExtremeOnly  = input.bool(true, "Extreme Signals: require stretch zone", group=g_conv)
lookbackExtreme = input.int(5,     "Stretch Lookback (bars)",               minval=1, group=g_conv)
showMidCross    = input.bool(true, "Show Zero-Cross Markers",               group=g_conv)

g_div = "6 · Divergence"
showDiv = input.bool(true, "Highlight Trend ↔ ROC Divergence", group=g_div)
divLen  = input.int(4,    "Divergence Slope Lookback", minval=1, group=g_div)
divMin  = input.float(2,  "Min Fast Slope",            minval=0, step=0.5, group=g_div)

g_plots = "7 · Plots"
showShadow   = input.bool(true, "Shadow Fill (ROC vs Zero)", group=g_plots)
showFill     = input.bool(true, "Fill ROC / Signal",         group=g_plots)
showHist     = input.bool(true, "Show Histogram",            group=g_plots)
showSignals  = input.bool(true, "Show Signal Markers",       group=g_plots)

g_col = "7 · Plots · Colors"
colBull   = input.color(#00bcd4,                "Bull (level)",           group=g_col)
colBear   = input.color(#f06292,                "Bear (level)",           group=g_col)
colLong   = input.color(#00c853,                "Long (trend/momentum)",  group=g_col)
colShort  = input.color(#d50000,                "Short (trend/momentum)", group=g_col)

g_score = "8 · Score"
showSentiment = input.bool(true,  "Show Sentiment Bar", group=g_score,
     tooltip="Live label at the panel's right edge — how far ROC sits inside its own stretch zone, signed ±100. Not a fixed Bullish/Bearish claim. Mirrors Williams VIX Fix Advanced's Sentiment Bar.")
showQuality   = input.bool(false, "Show Signal Quality Labels", group=g_score,
     tooltip="Adds a 0-100 quality score next to each Bull/Bear Stretch marker: 50% stretch-zone depth + 25% context agreement + 25% stall-free. Mirrors Williams VIX Fix Advanced's Spike Quality.")

// ─────────────────────────────────────────────────────────────────────────────
// SMOOTHING FUNCTIONS
// ─────────────────────────────────────────────────────────────────────────────

f_supersmoother(series float x, simple int len) =>
    float a1 = math.exp(-1.414 * math.pi / len)
    float b1 = 2.0 * a1 * math.cos(1.414 * math.pi / len)
    float c2 = b1
    float c3 = -(a1 * a1)
    float c1 = 1.0 - c2 - c3
    var float ss = na
    ss := c1 * (x + nz(x[1])) / 2.0 + c2 * nz(ss[1]) + c3 * nz(ss[2])
    ss

f_t3(series float x, simple int len) =>
    float b = 0.7
    float e1 = ta.ema(x, len)
    float e2 = ta.ema(e1, len)
    float e3 = ta.ema(e2, len)
    float e4 = ta.ema(e3, len)
    float e5 = ta.ema(e4, len)
    float e6 = ta.ema(e5, len)
    -(b * b * b) * e6 + (3.0 * b * b + 3.0 * b * b * b) * e5 + (-6.0 * b * b - 3.0 * b - 3.0 * b * b * b) * e4 + (1.0 + 3.0 * b + b * b * b + 3.0 * b * b) * e3

f_kama(series float x, simple int len) =>
    float change = math.abs(x - x[len])
    float vol = math.sum(math.abs(x - x[1]), len)
    float er = vol != 0.0 ? change / vol : 0.0
    float sc = math.pow(er * (2.0 / 3.0 - 2.0 / 31.0) + 2.0 / 31.0, 2)
    var float kama = na
    kama := nz(kama[1], x) + sc * (x - nz(kama[1], x))
    kama

f_jma(series float x, simple int len, simple int phase, simple float power) =>
    var float jma = na
    var float e0 = na
    var float e1 = na
    var float e2 = na
    float phaseRatio = phase < -100 ? 0.5 : phase > 100 ? 2.5 : phase / 100.0 + 1.5
    float beta = 0.45 * (len - 1) / (0.45 * (len - 1) + 2.0)
    float alpha = math.pow(beta, power)
    e0 := (1.0 - alpha) * x + alpha * nz(e0[1], x)
    e1 := (x - e0) * (1.0 - beta) + beta * nz(e1[1], 0.0)
    e2 := (e0 + phaseRatio * e1 - nz(jma[1], x)) * math.pow(1.0 - alpha, 2.0) + math.pow(alpha, 2.0) * nz(e2[1], 0.0)
    jma := nz(jma[1], x) + e2
    jma

f_smooth(series float x, simple int len, simple string mode) =>
    switch mode
        "SMA"           => ta.sma(x, len)
        "RMA"           => ta.rma(x, len)
        "WMA"           => ta.wma(x, len)
        "SuperSmoother" => f_supersmoother(x, len)
        "T3"            => f_t3(x, len)
        "KAMA"          => f_kama(x, len)
        "JMA Approx"    => f_jma(x, len, jmaPhase, jmaPower)
        =>                 ta.ema(x, len)

f_roc(series float x, simple int len) =>
    x[len] != 0.0 ? 100.0 * (x - x[len]) / x[len] : 0.0

// ─────────────────────────────────────────────────────────────────────────────
// ROC CORE
// ─────────────────────────────────────────────────────────────────────────────

rocRaw  = f_roc(src, rocLen)
rocLine = f_smooth(rocRaw, avgLen, smoothType)
signal  = f_smooth(rocLine, sigLen, smoothType)
hist    = rocLine - signal

ctxRaw  = f_roc(src, ctxLen)
ctxLine = f_smooth(ctxRaw, avgLen, smoothType)

// ─────────────────────────────────────────────────────────────────────────────
// MID / LEVELS
// ─────────────────────────────────────────────────────────────────────────────

wasOversold   = ta.lowest(rocLine,  lookbackExtreme) <= osLevel
wasOverbought = ta.highest(rocLine, lookbackExtreme) >= obLevel

// ─────────────────────────────────────────────────────────────────────────────
// STALL / ABSORPTION
// ─────────────────────────────────────────────────────────────────────────────

bullCross    = ta.crossover(rocLine, signal)
bearCross    = ta.crossunder(rocLine, signal)
bullExtreme  = bullCross and (not useExtremeOnly or wasOversold)
bearExtreme  = bearCross and (not useExtremeOnly or wasOverbought)
bullMidCross = ta.crossover(rocLine, midLine)
bearMidCross = ta.crossunder(rocLine, midLine)

float atrRef = ta.atr(14)
float rocChg = rocLine - rocLine[stallLen]
float priceChg = atrRef != 0.0 ? (close - close[stallLen]) / atrRef : 0.0
bool flatPx = math.abs(priceChg) < stallFlatATR
bool stallBull = useStall and rocChg < -stallRocMin and flatPx
bool stallBear = useStall and rocChg >  stallRocMin and flatPx
bool stallNow = stallBull or stallBear

// ─────────────────────────────────────────────────────────────────────────────
// TREND CONTEXT
// ─────────────────────────────────────────────────────────────────────────────

bool ctxBull = ctxLine > midLine
bool ctxBear = ctxLine < midLine
bool bearCounter = useCtx and bearExtreme and ctxBull
bool bullCounter = useCtx and bullExtreme and ctxBear

// ─────────────────────────────────────────────────────────────────────────────
// CONVICTION
// ─────────────────────────────────────────────────────────────────────────────

bool bearStrong = bearExtreme and not (stallBull or bearCounter)
bool bearWeak = bearExtreme and (stallBull or bearCounter)
bool bullStrong = bullExtreme and not (stallBear or bullCounter)
bool bullWeak = bullExtreme and (stallBear or bullCounter)

// ─────────────────────────────────────────────────────────────────────────────
// SCORE — Sentiment Bar (live extremity read) and Signal Quality (0-100 per
// cross), same weighting as Williams VIX Fix Advanced's Spike Quality, adapted
// to a single signed line instead of two independent bull/bear formulas.
// ─────────────────────────────────────────────────────────────────────────────

float sentBullPct  = (obLevel - midLine) != 0.0 ? math.max(0.0, rocLine - midLine) / (obLevel - midLine) * 100.0 : 0.0
float sentBearPct  = (midLine - osLevel) != 0.0 ? math.max(0.0, midLine - rocLine) / (midLine - osLevel) * 100.0 : 0.0
float sentScore    = math.max(-100.0, math.min(100.0, sentBullPct - sentBearPct))
float sentAbsScore = math.abs(sentScore)

// Depth = penetration beyond the zone in units of the zone-to-midline distance,
// capped at 1 so it contributes at most its documented 50 points
float bullDepth   = (midLine - osLevel) != 0.0 ? math.max(0.0, math.min(1.0, (osLevel - ta.lowest(rocLine, lookbackExtreme)) / math.abs(midLine - osLevel))) : 0.0
float bearDepth   = (obLevel - midLine) != 0.0 ? math.max(0.0, math.min(1.0, (ta.highest(rocLine, lookbackExtreme) - obLevel) / math.abs(obLevel - midLine))) : 0.0
float bullQuality = math.min(100.0, bullDepth * 50.0 + (ctxBull ? 25.0 : 0.0) + (not stallBear ? 25.0 : 0.0))
float bearQuality = math.min(100.0, bearDepth * 50.0 + (ctxBear ? 25.0 : 0.0) + (not stallBull ? 25.0 : 0.0))

// ─────────────────────────────────────────────────────────────────────────────
// DIVERGENCE
// ─────────────────────────────────────────────────────────────────────────────

float fastDir = rocLine - rocLine[divLen]
float slowDir = ctxLine - ctxLine[divLen]
bool divBull = useCtx and showDiv and fastDir < -divMin and slowDir > 0.0
bool divBear = useCtx and showDiv and fastDir >  divMin and slowDir < 0.0

// ─────────────────────────────────────────────────────────────────────────────
// COLORS
// ─────────────────────────────────────────────────────────────────────────────

color lineCol = color.from_gradient(rocLine, osLevel, obLevel, colBull, colBear)
color lineCol2 = color.from_gradient(signal, osLevel, obLevel, color.new(colBull, 40), color.new(colBear, 40))
color ctxCol = ctxLine >= midLine ? color.new(colLong, 55) : color.new(colShort, 55)

histRising = hist >= hist[1]
histColor = hist >= 0.0
     ? (histRising ? colLong : color.new(colLong, 55))
     : (not histRising ? colShort : color.new(colShort, 55))

// ─────────────────────────────────────────────────────────────────────────────
// HLINES + ZONE FILLS
// ─────────────────────────────────────────────────────────────────────────────

hMid = hline(midLine, "Zero", color=color.new(color.gray, 60), linestyle=hline.style_dotted, linewidth=1)
hOB  = hline(obLevel, "Positive Stretch", color=color.new(color.red, 65), linestyle=hline.style_dashed, linewidth=1)
hOS  = hline(osLevel, "Negative Stretch", color=color.new(#00bcd4, 65), linestyle=hline.style_dashed, linewidth=1)

// ─────────────────────────────────────────────────────────────────────────────
// PLOTS
// ─────────────────────────────────────────────────────────────────────────────

color histColorFinal = stallNow ? color.new(histColor, 78) : histColor
plot(showHist ? hist : na, "Histogram", style=plot.style_columns, color=histColorFinal)

pMid = plot(midLine, display=display.none)
pCtx = plot(useCtx ? ctxLine : na, "Trend Context", color=ctxCol, linewidth=2)
pSig = plot(signal, "ROC Signal", color=lineCol2, linewidth=1)
pROC = plot(rocLine, "ROC", color=lineCol, linewidth=2)

fill(pROC, pCtx, color=divBull ? color.new(colLong, 80) : divBear ? color.new(colShort, 80) : na,
     title="Trend Divergence")

fill(pROC, pMid, obLevel, midLine, color.new(colBear, 78), color.new(colBear, 100),
     title="Bear Shadow", display=showShadow ? display.all : display.none)
fill(pROC, pMid, midLine, osLevel, color.new(colBull, 100), color.new(colBull, 78),
     title="Bull Shadow", display=showShadow ? display.all : display.none)

fill(pROC, pSig, color=showFill ? (rocLine >= signal ? color.new(colBull, 88) : color.new(colBear, 88)) : na,
     title="ROC Fill")

// ─────────────────────────────────────────────────────────────────────────────
// SIGNAL MARKERS
// ─────────────────────────────────────────────────────────────────────────────

plotshape(showSignals and bullStrong, "Bull Stretch", style=shape.triangleup, location=location.bottom, color=colBull, size=size.small)
plotshape(showSignals and bullWeak, "Bull Stretch (absorbed)", style=shape.triangleup, location=location.bottom, color=color.new(colBull, 65), size=size.tiny)
plotshape(showSignals and bearStrong, "Bear Stretch", style=shape.triangledown, location=location.top, color=colBear, size=size.small)
plotshape(showSignals and bearWeak, "Bear Stretch (absorbed)", style=shape.triangledown, location=location.top, color=color.new(colBear, 65), size=size.tiny)

plotshape(showSignals and showMidCross and bullMidCross ? rocLine : na, "Bull Zero Cross", style=shape.circle, location=location.absolute, color=color.new(colBull, 20), size=size.tiny)
plotshape(showSignals and showMidCross and bearMidCross ? rocLine : na, "Bear Zero Cross", style=shape.circle, location=location.absolute, color=color.new(colBear, 20), size=size.tiny)

// ─────────────────────────────────────────────────────────────────────────────
// SCORE DISPLAY — Sentiment Bar (always-on read of current extremity) and
// per-cross Quality labels (why a Strong/Weak marker was graded that way)
// ─────────────────────────────────────────────────────────────────────────────

f_scoreColor(score, absS) =>
    base = score > 0 ? colBear : colBull
    color result = na
    if absS < 15
        result := color.new(color.gray, 40)
    else if absS >= 80
        result := color.new(base, 10)
    else if absS >= 60
        result := color.new(base, 30)
    else if absS >= 40
        result := color.new(base, 50)
    else
        result := color.new(base, 70)
    result

int    scoreBarSegments = 8
int    scoreFilled      = int(math.round(sentAbsScore / 100.0 * scoreBarSegments))
string scoreBarStr      = str.repeat("■", scoreFilled) + str.repeat("·", scoreBarSegments - scoreFilled)
string scoreSignStr     = sentScore > 0 ? "+" : ""
string sentTxt          = scoreSignStr + str.tostring(sentScore, "#") + "  " + scoreBarStr
color  sentColor        = f_scoreColor(sentScore, sentAbsScore)

var label sentLabel = na
if showSentiment and barstate.islast
    label.delete(sentLabel)
    sentLabel := label.new(bar_index + 3, midLine, sentTxt,
         xloc=xloc.bar_index, yloc=yloc.price, style=label.style_label_left,
         color=sentColor, textcolor=color.white, size=size.normal,
         tooltip="How far ROC sits inside its own stretch zone: 100×(ROC−midline)/(Positive Stretch−midline) when bullish, 100×(midline−ROC)/(midline−Negative Stretch) when bearish, clamped to ±100. |score| < 15 reads as balanced.")
else if not showSentiment and barstate.islast
    label.delete(sentLabel)

if showQuality and bullExtreme
    label.new(bar_index, rocLine, str.tostring(bullQuality, "#"),
         style=label.style_label_up, color=bullStrong ? colBull : color.new(colBull, 65), textcolor=color.white, size=size.tiny,
         tooltip="Bull Signal Quality " + str.tostring(bullQuality, "#") + "/100 — stretch-zone depth 50% + context agreement 25% + stall-free 25%.")
if showQuality and bearExtreme
    label.new(bar_index, rocLine, str.tostring(bearQuality, "#"),
         style=label.style_label_down, color=bearStrong ? colBear : color.new(colBear, 65), textcolor=color.white, size=size.tiny,
         tooltip="Bear Signal Quality " + str.tostring(bearQuality, "#") + "/100 — stretch-zone depth 50% + context agreement 25% + stall-free 25%.")

// ─────────────────────────────────────────────────────────────────────────────
// ALERTS
// ─────────────────────────────────────────────────────────────────────────────

bool alertsOnBarClose = input.bool(true, "Alerts only on bar close (confirmed)", group="9 · Alerts")
bool alertOk = not alertsOnBarClose or barstate.isconfirmed

alertcondition(alertOk and bullExtreme,  "ROC Bull Signal",       "ROCA · BULL CROSS NEGATIVE STRETCH · {{ticker}} {{interval}}")
alertcondition(alertOk and bearExtreme,  "ROC Bear Signal",       "ROCA · BEAR CROSS POSITIVE STRETCH · {{ticker}} {{interval}}")
alertcondition(alertOk and bullMidCross, "ROC Cross Above Zero",  "ROCA · CROSS ABOVE ZERO · {{ticker}} {{interval}}")
alertcondition(alertOk and bearMidCross, "ROC Cross Below Zero",  "ROCA · CROSS BELOW ZERO · {{ticker}} {{interval}}")