// © 2026 HYPERSPY LLC. All rights reserved.
// HYPERSPY Forecaster Lite is free for personal use. You may share this file UNMODIFIED with this notice intact.
// Modified copies may not use the HYPERSPY name or logo. Terms: hypespy.ai/legal
// Educational and informational software only. Not financial advice. Trading involves risk of loss.

//@version=6
// ═══════════════════════════════════════════════════════════════════════════════
//  HYPERSPY Forecaster Lite V1.0
//
//  A 10-day volatility cone for SPY: where price could reasonably travel over the
//  next N trading days, with 50% and 80% ranges and the expected (median) move.
//
//  How it works (Lite engine):
//   • Volatility is measured close-to-close on the regular-session DAILY series,
//     with a fast (≈ 2 weeks) and a slow (≈ 6 months) exponential average. The
//     cone blends them: near days follow current volatility, far days drift
//     toward the long-run level.
//   • The centre line uses a long-run drift (annual Sharpe input), nothing more.
//   • Intraday charts use the volatility known at the last daily close (no
//     repaint); the cone is anchored at the current price.
//
//  The full HYPERSPY Forecaster adds the AI factor model, P(up), Up/Down calls,
//  calibrated bands, alerts and a live scorecard: hypespy.ai
// ═══════════════════════════════════════════════════════════════════════════════
indicator("HYPERSPY Forecaster Lite", shorttitle = "HSF Lite", overlay = true,
     max_lines_count = 10, max_labels_count = 80, max_polylines_count = 5)

// ── Inputs ───────────────────────────────────────────────────────────────────
grpF = "Forecast"
hzLen    = input.int(10, "Horizon (trading days)", minval = 2, maxval = 30, group = grpF)
coverage = input.int(80, "Outer range %", options = [68, 80, 90, 95], group = grpF)
showIn   = input.bool(true, "Inner 50% range", group = grpF)
priorSR  = input.float(0.5, "Long-run drift (annual Sharpe)", minval = -1.0, maxval = 1.5, step = 0.1, tooltip = "SPY's long-run Sharpe ratio is roughly 0.5. Use 0 for a driftless cone.", group = grpF)
lockBar  = input.bool(true, "Anchor on last closed bar (no repaint)", group = grpF)

grpV = "Display"
showDots  = input.bool(true, "Daily forecast dots", group = grpV)
showLines = input.bool(true, "Now / horizon lines", group = grpV)
showPanel = input.bool(true, "Panel", group = grpV)
tblPos    = input.string("Bottom Right", "Panel position", options = ["Top Left", "Top Right", "Bottom Right", "Bottom Left"], group = grpV)

grpC = "Colors"
cFc   = input.color(#F5A623, "Forecast", group = grpC)
cUp   = input.color(#26A69A, "Up", group = grpC)
cDn   = input.color(#EF5350, "Down / horizon", group = grpC)
trOut = input.int(88, "Outer range transparency", minval = 50, maxval = 98, group = grpC)
trIn  = input.int(80, "Inner range transparency", minval = 40, maxval = 98, group = grpC)

C_MUTED = #787B86
C_TEXT  = #D1D4DC
C_BG    = #131722
C_EDGE  = #2A2E39

f_pos(string s) =>
    s == "Top Left" ? position.top_left : s == "Top Right" ? position.top_right : s == "Bottom Left" ? position.bottom_left : position.bottom_right

f_pctTxt(float frac) =>
    (frac >= 0 ? "+" : "") + str.tostring(100.0 * frac, "0.0") + "%"

// Variance over tau steps with fast→slow mean reversion (ph per step)
f_hVar(float f_, float s_, float tau, float ph) =>
    math.max(tau * math.max(s_, 1e-12) + (f_ - s_) * (1 - math.pow(ph, tau)) / (1 - ph), 1e-12)

// ── Daily volatility engine (runs on the regular-session daily series) ───────
f_vol() =>
    int   dps  = timeframe.isweekly ? 5 * timeframe.multiplier : timeframe.ismonthly ? 21 * timeframe.multiplier : timeframe.isdaily ? timeframe.multiplier : 1
    float lamF = math.pow(0.94, dps)
    float lamS = math.pow(0.995, dps)
    float r    = nz(math.log(close / close[1]))
    var float vFn = 0.0
    var float vFw = 0.0
    var float vSn = 0.0
    var float vSw = 0.0
    var int   n   = 0
    if bar_index > 0
        vFn := lamF * vFn + (1 - lamF) * r * r
        vFw := lamF * vFw + (1 - lamF)
        vSn := lamS * vSn + (1 - lamS) * r * r
        vSw := lamS * vSw + (1 - lamS)
        n += 1
    float vF = vFw > 0 ? vFn / vFw : na
    float vS = vSw > 0 ? vSn / vSw : na
    [vF, vS, n]

// Lag 1 on intraday charts (yesterday's completed daily values, no repaint), lag 0 otherwise
f_volOut(simple int lg) =>
    [vF, vS, n] = f_vol()
    [vF[lg], vS[lg], n[lg]]

bool   intra = timeframe.isintraday
int    lagE  = intra ? 1 : 0
string engTf = intra ? "D" : timeframe.period
string dTk   = ticker.new(syminfo.prefix, syminfo.ticker, session.regular)
[vF, vS, nVol] = request.security(dTk, engTf, f_volOut(lagE), lookahead = barmerge.lookahead_on)

// steps per trading day on the engine timeframe (1 on intraday/1D charts)
int   dpsC = timeframe.isweekly ? 5 * timeframe.multiplier : timeframe.ismonthly ? 21 * timeframe.multiplier : timeframe.isdaily ? timeframe.multiplier : 1
float phC  = math.pow(0.97, dpsC)
int   hzS  = math.max(1, int(math.round(hzLen * 1.0 / dpsC)))      // horizon in engine steps
float zOut = coverage == 68 ? 0.9945 : coverage == 80 ? 1.2816 : coverage == 90 ? 1.6449 : 1.96
float zIn  = 0.6745

// ── Calendar (NYSE rules; crypto trades every day) ───────────────────────────
string TZ       = syminfo.timezone
bool   isCrypto = syminfo.type == "crypto"
bool   usCal    = not isCrypto and (syminfo.country == "US" or TZ == "America/New_York")

f_easterKey(int Y) =>
    int a = Y % 19
    int b = int(math.floor(Y / 100.0))
    int c = Y % 100
    int d = int(math.floor(b / 4.0))
    int e = b % 4
    int f = int(math.floor((b + 8) / 25.0))
    int g = int(math.floor((b - f + 1) / 3.0))
    int h = (19 * a + b - d - g + 15) % 30
    int i = int(math.floor(c / 4.0))
    int k = c % 4
    int l = (32 + 2 * e + 2 * i - h - k) % 7
    int m = int(math.floor((a + 11 * h + 22 * l) / 451.0))
    int mo = int(math.floor((h + l - 7 * m + 114) / 31.0))
    int da = (h + l - 7 * m + 114) % 31 + 1
    Y * 10000 + mo * 100 + da

f_goodFridayKey(int Y) =>
    int ek = f_easterKey(Y)
    int mo = int(math.floor((ek % 10000) / 100.0))
    int da = ek % 100 - 2
    if da < 1
        mo := 3
        da := 31 + da
    Y * 10000 + mo * 100 + da

f_isUSHoliday(int t) =>
    int Y  = year(t, TZ)
    int mo = month(t, TZ)
    int d  = dayofmonth(t, TZ)
    int dw = dayofweek(t, TZ)
    bool mon = dw == dayofweek.monday
    bool fri = dw == dayofweek.friday
    bool wkd = dw != dayofweek.saturday and dw != dayofweek.sunday
    bool h = (mo == 1 and d == 1) or (mo == 1 and d == 2 and mon)
    h := h or (mo == 1 and mon and d >= 15 and d <= 21) or (mo == 2 and mon and d >= 15 and d <= 21)
    h := h or Y * 10000 + mo * 100 + d == f_goodFridayKey(Y)
    h := h or (mo == 5 and mon and d >= 25)
    h := h or (Y >= 2022 and ((mo == 6 and d == 19) or (mo == 6 and d == 18 and fri) or (mo == 6 and d == 20 and mon)))
    h := h or (mo == 7 and d == 4) or (mo == 7 and d == 3 and fri) or (mo == 7 and d == 5 and mon)
    h := h or (mo == 9 and mon and d <= 7)
    h := h or (mo == 11 and dw == dayofweek.thursday and d >= 22 and d <= 28)
    h := h or (mo == 12 and d == 25) or (mo == 12 and d == 24 and fri) or (mo == 12 and d == 26 and mon)
    h and wkd

f_isTradingDay(int t) =>
    int dw = dayofweek(t, TZ)
    isCrypto ? true : (dw != dayofweek.saturday and dw != dayofweek.sunday and not (usCal and f_isUSHoliday(t)))

// t shifted forward by n trading days, keeping hh:mm
f_addTradingDays(int t, int n) =>
    int hh = hour(t, TZ)
    int mm = minute(t, TZ)
    int noon = timestamp(TZ, year(t, TZ), month(t, TZ), dayofmonth(t, TZ), 12, 0, 0)
    int added = 0
    int guard = 0
    while added < n and guard < 120
        noon += 86400000
        guard += 1
        if f_isTradingDay(noon)
            added += 1
    timestamp(TZ, year(noon, TZ), month(noon, TZ), dayofmonth(noon, TZ), hh, mm, 0)

// time of future step k (trading days on intraday/daily charts, bars on W/M)
f_stepTime(int t0, int k) =>
    timeframe.isweekly or timeframe.ismonthly ? t0 + k * timeframe.in_seconds() * 1000 : f_addTradingDays(t0, k * dpsC)

f_fmt(int t) =>
    str.format_time(t, "MMM dd", TZ)

// ── Drawing ──────────────────────────────────────────────────────────────────
var polyline outPoly = na
var polyline inPoly  = na
var polyline medLine = na
var label    tgtLbl  = na
var label    hiLbl   = na
var label    loLbl   = na
var line     nowLine = na
var line     endLine = na
var label[]  dots    = array.new<label>()
var table    tbl     = table.new(f_pos(tblPos), 2, 7, bgcolor = color.new(C_BG, 5), frame_color = C_EDGE, frame_width = 1, border_color = C_EDGE, border_width = 1)

bool ready = not na(vF) and not na(vS) and nz(nVol) >= 30

if barstate.islast
    polyline.delete(outPoly)
    polyline.delete(inPoly)
    polyline.delete(medLine)
    label.delete(tgtLbl)
    label.delete(hiLbl)
    label.delete(loLbl)
    line.delete(nowLine)
    line.delete(endLine)
    for lb in dots
        label.delete(lb)
    dots.clear()

    if ready
        int   a  = lockBar and not barstate.isconfirmed and bar_index > 0 ? 1 : 0
        float aC = close[a]
        int   aT = time[a]
        // drift per step from the long-run Sharpe, scaled by long-run volatility
        float sdS  = math.sqrt(math.max(vS, 1e-12))
        float muS  = priorSR * sdS * math.sqrt(dpsC / 252.0)
        med = array.new<chart.point>()
        oHi = array.new<chart.point>()
        oLo = array.new<chart.point>()
        iHi = array.new<chart.point>()
        iLo = array.new<chart.point>()
        chart.point p0 = chart.point.from_time(aT, aC)
        med.push(p0)
        oHi.push(p0)
        oLo.push(p0)
        iHi.push(p0)
        iLo.push(p0)
        float pm = aC
        float oH = aC
        float oL = aC
        float iH = aC
        float iL = aC
        int   tk = aT
        for k = 1 to hzS
            tk := f_stepTime(aT, k)
            float sh = math.sqrt(f_hVar(vF, vS, k, phC))
            float d  = muS * k
            pm := aC * math.exp(d)
            oH := aC * math.exp(d + zOut * sh)
            oL := aC * math.exp(d - zOut * sh)
            iH := aC * math.exp(d + zIn * sh)
            iL := aC * math.exp(d - zIn * sh)
            med.push(chart.point.from_time(tk, pm))
            oHi.push(chart.point.from_time(tk, oH))
            oLo.push(chart.point.from_time(tk, oL))
            iHi.push(chart.point.from_time(tk, iH))
            iLo.push(chart.point.from_time(tk, iL))
            if showDots and k < hzS
                dots.push(label.new(tk, pm, "●", xloc = xloc.bar_time, style = label.style_none, size = size.tiny, textcolor = cFc))

        outPts = array.new<chart.point>()
        for pt in oHi
            outPts.push(pt)
        for i = oLo.size() - 1 to 0
            outPts.push(oLo.get(i))
        outPoly := polyline.new(outPts, closed = true, xloc = xloc.bar_time, line_color = color.new(cFc, 100), fill_color = color.new(cFc, trOut))
        if showIn
            inPts = array.new<chart.point>()
            for pt in iHi
                inPts.push(pt)
            for i = iLo.size() - 1 to 0
                inPts.push(iLo.get(i))
            inPoly := polyline.new(inPts, closed = true, xloc = xloc.bar_time, line_color = color.new(cFc, 100), fill_color = color.new(cFc, trIn))
        medLine := polyline.new(med, xloc = xloc.bar_time, line_color = cFc, line_style = line.style_dotted, line_width = 2)

        float expMove = pm / aC - 1
        color cDir    = expMove >= 0 ? cUp : cDn
        string endTxt = f_fmt(tk)
        tgtLbl := label.new(tk, pm, "$" + str.tostring(pm, "0.00") + " (" + f_pctTxt(expMove) + ") · " + str.tostring(hzLen) + " td → " + endTxt, xloc = xloc.bar_time, style = label.style_label_lower_left, color = color.new(cDir, 80), textcolor = cDir, size = size.small, text_font_family = font.family_monospace)
        hiLbl  := label.new(tk, oH, "$" + str.tostring(oH, "0.00") + " (" + f_pctTxt(oH / aC - 1) + ")", xloc = xloc.bar_time, style = label.style_label_left, color = color.new(C_BG, 100), textcolor = cFc, size = size.tiny)
        loLbl  := label.new(tk, oL, "$" + str.tostring(oL, "0.00") + " (" + f_pctTxt(oL / aC - 1) + ")", xloc = xloc.bar_time, style = label.style_label_left, color = color.new(C_BG, 100), textcolor = cFc, size = size.tiny)
        if showLines
            nowLine := line.new(aT, aC, aT, aC * 1.001, xloc = xloc.bar_time, extend = extend.both, color = color.new(C_MUTED, 30), style = line.style_dashed)
            endLine := line.new(tk, aC, tk, aC * 1.001, xloc = xloc.bar_time, extend = extend.both, color = color.new(cDn, 35), style = line.style_dotted)

        if showPanel
            float shEnd = math.sqrt(f_hVar(vF, vS, hzS, phC))
            table.cell(tbl, 0, 0, "HYPERSPY FORECASTER LITE", text_color = cFc, text_size = size.small, text_halign = text.align_left)
            table.cell(tbl, 1, 0, syminfo.ticker + " · " + timeframe.period, text_color = C_MUTED, text_size = size.small, text_halign = text.align_right)
            table.cell(tbl, 0, 1, "Expected move · " + str.tostring(hzLen) + " td → " + endTxt, text_color = C_MUTED, text_size = size.small, text_halign = text.align_left)
            table.cell(tbl, 1, 1, f_pctTxt(expMove) + " → $" + str.tostring(pm, "0.00"), text_color = cDir, text_size = size.small, text_halign = text.align_right)
            table.cell(tbl, 0, 2, str.tostring(coverage) + "% range", text_color = C_MUTED, text_size = size.small, text_halign = text.align_left)
            table.cell(tbl, 1, 2, "$" + str.tostring(oL, "0.00") + " – $" + str.tostring(oH, "0.00") + " (" + f_pctTxt(oL / aC - 1) + " … " + f_pctTxt(oH / aC - 1) + ")", text_color = cFc, text_size = size.small, text_halign = text.align_right)
            table.cell(tbl, 0, 3, "50% range", text_color = C_MUTED, text_size = size.small, text_halign = text.align_left)
            table.cell(tbl, 1, 3, "$" + str.tostring(iL, "0.00") + " – $" + str.tostring(iH, "0.00"), text_color = cFc, text_size = size.small, text_halign = text.align_right)
            table.cell(tbl, 0, 4, "Volatility to horizon", text_color = C_MUTED, text_size = size.small, text_halign = text.align_left)
            table.cell(tbl, 1, 4, "σ " + str.tostring(100 * shEnd, "0.0") + "% · now " + str.tostring(100 * math.sqrt(vF * 252.0 / dpsC), "0") + "% / long-run " + str.tostring(100 * math.sqrt(vS * 252.0 / dpsC), "0") + "% ann.", text_color = C_TEXT, text_size = size.small, text_halign = text.align_right)
            table.cell(tbl, 0, 5, "Full version", text_color = C_MUTED, text_size = size.small, text_halign = text.align_left)
            table.cell(tbl, 1, 5, "AI factors · P(up) · signals · alerts → hypespy.ai", text_color = C_MUTED, text_size = size.small, text_halign = text.align_right)
            table.cell(tbl, 0, 6, "Not financial advice", text_color = C_MUTED, text_size = size.tiny, text_halign = text.align_left)
            table.cell(tbl, 1, 6, "Ranges are statistical estimates, not predictions", text_color = C_MUTED, text_size = size.tiny, text_halign = text.align_right)
    else if showPanel
        table.cell(tbl, 0, 0, "HYPERSPY FORECASTER LITE", text_color = cFc, text_size = size.small, text_halign = text.align_left)
        table.cell(tbl, 1, 0, "Warming up · " + str.tostring(nz(nVol)) + "/30 days of data", text_color = C_TEXT, text_size = size.small, text_halign = text.align_right)