Stoch RSI Advanced [WavesUnchained]

//@version=6
// ============================================================================
// Stoch RSI Advanced [WavesUnchained]
// Version: 1.2.2
// Author: WavesUnchained
// Build: 2026-10-02 00:00:00
// ============================================================================
// Stoch RSI with trend context, stall/absorption, conviction markers, and
// directional long/short coloring on a bounded 0-100 oscillator core.
//
// Features:
//   ✓ Stoch RSI K/D core with pluggable smoothing
//   ✓ Bounded 0-100 panel with 50 midline and 80/20 OB/OS zones
//   ✓ Stall/absorption context: marks crosses contradicted by flat price as weak
//   ✓ Trend context line (slow Stoch RSI): support the fast line rests on
//   ✓ Trend↔Stoch RSI divergence wedge: fast and trend move opposite
//   ✓ Long/Short coloring for trend context, histogram, and divergence wedge
//   ✓ Sentiment Bar — live ±100 OB/OS extremity score + mini bar
//   ✓ Signal Quality — optional 0-100 conviction score per Bull/Bear cross
//   ✓ Gradient line color, shadow fills, OB/OS zone fills, and alerts
//
// ============================================================================

indicator("Stoch RSI Advanced [WavesUnchained]", "StochRSI·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)
rsiLen   = input.int(14,     "RSI Length",     minval=1, group=g_core)
stochLen = input.int(14,     "Stoch Length",   minval=1, group=g_core)
kLen     = input.int(3,      "K Smoothing",    minval=1, group=g_core)
dLen     = input.int(3,      "D Smoothing",    minval=1, group=g_core)
smoothType = input.string("SMA", "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(50, "Midline",    minval=0,   maxval=100, group=g_levels)
obLevel = input.float(80, "Overbought", minval=50,  maxval=100, group=g_levels)
osLevel = input.float(20, "Oversold",   minval=0,   maxval=50,  group=g_levels)

g_stall = "3 · Stall / Absorption"
useStall     = input.bool(true, "Detect Stall (oscillator moves, price holds)", group=g_stall,
     tooltip="Flags bars where Stoch RSI cools/heats sharply but price barely moves. Annotates crosses and fades the histogram; never changes the cross logic itself.")
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)
stallOscMin  = input.float(15,  "Min Stoch RSI Move",    minval=0,   step=1,   group=g_stall)

g_ctx = "4 · Trend Context"
useCtx = input.bool(true, "Show Trend Context Line", group=g_ctx,
     tooltip="A slow Stoch RSI plotted faint behind the fast K line. While it holds its side of 50, an opposite fast cross is treated as counter-trend.")
ctxRsiLen   = input.int(50, "Trend RSI Length",   minval=2, group=g_ctx)
ctxStochLen = input.int(50, "Trend Stoch Length", minval=2, group=g_ctx)

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

g_div = "6 · Divergence"
showDiv = input.bool(true, "Highlight Trend ↔ Stoch RSI Divergence", group=g_div,
     tooltip="Fills the wedge between fast K and the trend context line only when they move in opposite directions.")
divLen  = input.int(4,    "Divergence Slope Lookback", minval=1, group=g_div)
divMin  = input.float(10, "Min Fast Slope",            minval=0, step=1, group=g_div)

g_plots = "7 · Plots"
showShadow   = input.bool(true,  "Shadow Fill (K vs 50)",      group=g_plots)
showFill     = input.bool(true,  "Fill K / D",                 group=g_plots)
showZoneFill = input.bool(true,  "Fill OB / OS Zones",         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)
colZoneOB = input.color(color.new(#f06292, 90),  "OB Zone Fill",          group=g_col)
colZoneOS = input.color(color.new(#00bcd4, 90),  "OS Zone Fill",          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 K sits inside its own OB/OS 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 Extreme marker: 50% OB/OS-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 pi = math.pi
    float a1 = math.exp(-1.414 * pi / len)
    float b1 = 2.0 * a1 * math.cos(1.414 * 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)
    float c1 = -(b * b * b)
    float c2 =  3.0 * b * b + 3.0 * b * b * b
    float c3 = -6.0 * b * b - 3.0 * b - 3.0 * b * b * b
    float c4 =  1.0 + 3.0 * b + b * b * b + 3.0 * b * b
    c1 * e6 + c2 * e5 + c3 * e4 + c4 * 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_stoch_rsi(series float x, simple int rLen, simple int sLen) =>
    float r = ta.rsi(x, rLen)
    ta.stoch(r, r, r, sLen)

// ─────────────────────────────────────────────────────────────────────────────
// STOCH RSI CORE
// ─────────────────────────────────────────────────────────────────────────────

stochRaw = f_stoch_rsi(src, rsiLen, stochLen)
kLine    = f_smooth(stochRaw, kLen, smoothType)
signal   = f_smooth(kLine,    dLen, smoothType)
hist     = kLine - signal

ctxRaw  = f_stoch_rsi(src, ctxRsiLen, ctxStochLen)
ctxLine = f_smooth(ctxRaw, kLen, smoothType)

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

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

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

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

float atrRef   = ta.atr(14)
float oscChg   = kLine - kLine[stallLen]
float priceChg = atrRef != 0.0 ? (close - close[stallLen]) / atrRef : 0.0
bool  flatPx   = math.abs(priceChg) < stallFlatATR
bool  stallBull = useStall and oscChg < -stallOscMin and flatPx
bool  stallBear = useStall and oscChg >  stallOscMin 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, kLine - midLine) / (obLevel - midLine) * 100.0 : 0.0
float sentBearPct  = (midLine - osLevel) != 0.0 ? math.max(0.0, midLine - kLine) / (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-bound distance
// (0 / 100 — this oscillator saturates at its bounds), capped at 1 so it
// contributes at most its documented 50 points and can actually reach them
float bullDepth   = osLevel > 0.0 ? math.max(0.0, math.min(1.0, (osLevel - ta.lowest(kLine, lookbackExtreme)) / osLevel)) : 0.0
float bearDepth   = obLevel < 100.0 ? math.max(0.0, math.min(1.0, (ta.highest(kLine, lookbackExtreme) - obLevel) / (100.0 - obLevel))) : 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 = kLine - kLine[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(kLine, 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
// ─────────────────────────────────────────────────────────────────────────────

hTop = hline(100, "Top", color=color.new(color.gray, 85))
hMid = hline(midLine, "50", color=color.new(color.gray, 60), linestyle=hline.style_dotted, linewidth=1)
hBot = hline(0, "Bottom", color=color.new(color.gray, 85))
hOB  = hline(obLevel, "Overbought", color=color.new(color.red, 65), linestyle=hline.style_dashed, linewidth=1)
hOS  = hline(osLevel, "Oversold",   color=color.new(#00bcd4, 65),   linestyle=hline.style_dashed, linewidth=1)

fill(hOB, hTop, color=showZoneFill ? colZoneOB : na, title="OB Zone")
fill(hBot, hOS, color=showZoneFill ? colZoneOS : na, title="OS Zone")

// ─────────────────────────────────────────────────────────────────────────────
// 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, "D Signal", color=lineCol2, linewidth=1)
pK   = plot(kLine,  "K",        color=lineCol,  linewidth=2)

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

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

fill(pK, pSig,
     color=showFill ? (kLine >= signal ? color.new(colBull, 88) : color.new(colBear, 88)) : na,
     title="K/D Fill")

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

plotshape(showSignals and bullStrong, "Bull Extreme",
     style=shape.triangleup, location=location.bottom,
     color=colBull, size=size.small)

plotshape(showSignals and bullWeak, "Bull Extreme (absorbed)",
     style=shape.triangleup, location=location.bottom,
     color=color.new(colBull, 65), size=size.tiny)

plotshape(showSignals and bearStrong, "Bear Extreme",
     style=shape.triangledown, location=location.top,
     color=colBear, size=size.small)

plotshape(showSignals and bearWeak, "Bear Extreme (absorbed)",
     style=shape.triangledown, location=location.top,
     color=color.new(colBear, 65), size=size.tiny)

plotshape(showSignals and showMidCross and bullMidCross ? kLine : na, "Bull 50 Cross",
     style=shape.circle, location=location.absolute,
     color=color.new(colBull, 20), size=size.tiny)

plotshape(showSignals and showMidCross and bearMidCross ? kLine : na, "Bear 50 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 K sits inside its own OB/OS zone: 100×(K−midline)/(Overbought−midline) when bullish, 100×(midline−K)/(midline−Oversold) 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, kLine, 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 — OB/OS-zone depth 50% + context agreement 25% + stall-free 25%.")
if showQuality and bearExtreme
    label.new(bar_index, kLine, 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 — OB/OS-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,  "Stoch RSI Bull Signal",      "SRSIA · BULL CROSS OVERSOLD · {{ticker}} {{interval}}")
alertcondition(alertOk and bearExtreme,  "Stoch RSI Bear Signal",      "SRSIA · BEAR CROSS OVERBOUGHT · {{ticker}} {{interval}}")
alertcondition(alertOk and bullMidCross, "Stoch RSI Cross Above 50",   "SRSIA · CROSS ABOVE 50 · {{ticker}} {{interval}}")
alertcondition(alertOk and bearMidCross, "Stoch RSI Cross Below 50",   "SRSIA · CROSS BELOW 50 · {{ticker}} {{interval}}")