Volume Delta Trend Reversal Long Only

// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Gotrade

//@version=6
// ── How it works ──────────────────────────────────────────────────────────────
// Volume Delta = buying volume - selling volume per bar
//   Buying volume  = volume × (close - low)  / (high - low)
//   Selling volume = volume × (high - close) / (high - low)
//
// Cumulative Volume Delta (CVD) = rolling sum of delta over N bars
//
// ENTRY: Higher-timeframe uptrend + no bear regime + reversal confirmed
//        by N consecutive bars above trend MA + CVD buyers dominating + RSI ok
//        + session filter (active trading hours only)
// EXIT:  CVD sellers dominant for M bars + trend MA crossunder + trailing stop
// ─────────────────────────────────────────────────────────────────────────────
strategy("Volume Delta Trend Reversal – Long Only", overlay=true,
         default_qty_type=strategy.fixed, default_qty_value=1,
         initial_capital=1000000, margin_long=0.1,
         commission_type=strategy.commission.percent, commission_value=0.04,
         fill_orders_on_standard_ohlc=true)

// ═══════════════════════════════════════════════════════════════════════════════
// INPUTS
// ═══════════════════════════════════════════════════════════════════════════════
grp0 = "Cumulative Volume Delta (CVD)"
cvdPeriod       = input.int(50,    "CVD rolling window (bars)",              group=grp0, minval=5,
                     tooltip="50 bars on 1h = last 2 days of net flow. Longer window = less noise, more reliable signal.")
cvdThresholdPct = input.float(20.0,"Entry: buy% must exceed sell% by X%",   group=grp0, minval=0.0, step=1.0,
                     tooltip="20% = buying volume must be 60%+ of total (vs 40% selling). Stricter = fewer but better entries.")
cvdExitBars     = input.int(3,     "Exit: sellers must dominate for N bars", group=grp0, minval=1,
                     tooltip="Require sellers to dominate CVD for N consecutive bars before exiting. Prevents single noisy bar from closing a winner.")
cvdExitPct      = input.float(25.0,"Exit: sell% must exceed buy% by X%",    group=grp0, minval=0.0, step=1.0,
                     tooltip="25% = selling must be 62.5%+ of total volume. Higher = holds longer through noise.")
useDailyReset   = input.bool(false,"Reset CVD at session open each day",    group=grp0,
                     tooltip="ON: CVD resets each day. OFF: rolling window of last N bars.")
minHoldBars     = input.int(5,     "Minimum bars to hold before CVD exit",  group=grp0, minval=1,
                     tooltip="Prevents CVD exit from firing immediately after entry during volatile open. 5 bars on 1h = 5 hours minimum hold.")

grp1 = "Bear Market Regime Filter"
useBearFilter   = input.bool(true, "Block entries in bear regime",          group=grp1,
                     tooltip="Stops buying longs during sustained downtrends. Main fix for 2022-2025 losses.")
bearMAPeriod    = input.int(200,   "Bear regime MA period",                 group=grp1, minval=20,
                     tooltip="200-bar SMA on 1h = ~200 hours = ~1 month trend reference.")
bearConsecBars  = input.int(10,    "Bars below bear MA to confirm bear",    group=grp1, minval=1,
                     tooltip="10 consecutive bars below 200-SMA = confirmed bear. Prevents false triggers.")
bearExitBars    = input.int(5,     "Bars above bear MA to exit regime",     group=grp1, minval=1)

grp2 = "Trend Reversal Detection"
trendMAPeriod   = input.int(200,   "Trend MA period (SMA)",                 group=grp2, minval=5,
                     tooltip="200-bar SMA on 1h ≈ 1 month. Price must recover above this for a reversal to be meaningful. 50 was too short — caused 449 trades.")
trendMABuffer   = input.float(0.5, "Min % above trend MA to enter",        group=grp2, minval=0.0, step=0.1,
                     tooltip="Small buffer to avoid entries right at the boundary where exits fire immediately.")
confirmBars     = input.int(5,     "Confirm bars above MA before entry",    group=grp2, minval=1,
                     tooltip="5 bars on 1h = 5 consecutive hours above the trend MA. Filters out brief spikes.")
useRsiFilter    = input.bool(true, "RSI momentum filter",                   group=grp2)
rsiPeriod       = input.int(14,    "RSI period",                            group=grp2, minval=2)
rsiMinLevel     = input.float(50.0,"Min RSI to allow entry",                group=grp2, minval=1, maxval=99,
                     tooltip="RSI > 50 = momentum turning positive. 45 was too easy — allowed dead-cat bounces.")

grp3 = "Session Filter"
useSessionFilter = input.bool(true, "Only trade during active session",     group=grp3,
                      tooltip="Blocks entries outside active trading hours. Volume delta is unreliable in thin overnight markets.")
sessionStr       = input.session("0800-1700", "Active session (exchange time)", group=grp3,
                      tooltip="UK100: 0800-1700 London. SPX: 0930-1600 NY. Adjust to your asset.")

grp4 = "Exit Rules"
useCvdExit      = input.bool(true, "Exit when CVD sellers dominate",        group=grp4)
useTrendExit    = input.bool(true, "Exit on trend MA crossunder",           group=grp4)
useTrailStop    = input.bool(true, "Use trailing stop",                     group=grp4)
trailPct        = input.float(4.0, "Trail stop % from peak",                group=grp4, minval=0.1, step=0.1)
trailActivate   = input.float(6.0, "Activate trail after X% profit",       group=grp4, minval=0.1, step=0.1)

grp5 = "Risk Management"
useEquityPct     = input.bool(true,  "Size as % of equity",                 group=grp5)
marginEquityPct  = input.float(0.2,  "Margin % of equity per trade",        group=grp5, minval=0.01, step=0.01)
marginAmt        = input.float(2000, "Fixed margin (when % mode OFF)",      group=grp5, minval=1)
leverage         = input.int(1000,   "Leverage (x)",                        group=grp5, minval=1, maxval=1000)
portfolioStopPct = input.float(50.0, "Emergency stop: X% loss of peak equity", group=grp5, minval=1.0, maxval=100.0)
equityDDPct      = input.float(20.0, "Halt entries if equity DD > X% from peak", group=grp5, minval=1.0,
                      tooltip="Circuit breaker: pauses new entries if equity has fallen more than X% from its peak.")

// ═══════════════════════════════════════════════════════════════════════════════
// VOLUME DELTA CALCULATION
// ═══════════════════════════════════════════════════════════════════════════════
hlRange  = math.max(high - low, syminfo.mintick)
buyVol   = volume * (close - low)  / hlRange
sellVol  = volume * (high - close) / hlRange
barDelta = buyVol - sellVol

// Daily reset option
var float sessionCumDelta = 0.0
var float sessionCumBuy   = 0.0
var float sessionCumSell  = 0.0
isNewDay = ta.change(time("D")) != 0
if useDailyReset
    if isNewDay
        sessionCumDelta := 0.0
        sessionCumBuy   := 0.0
        sessionCumSell  := 0.0
    sessionCumDelta += barDelta
    sessionCumBuy   += buyVol
    sessionCumSell  += sellVol

// Rolling CVD
rollingCumBuy   = math.sum(buyVol,   cvdPeriod)
rollingCumSell  = math.sum(sellVol,  cvdPeriod)
rollingCumDelta = math.sum(barDelta, cvdPeriod)

activeCumBuy   = useDailyReset ? sessionCumBuy   : rollingCumBuy
activeCumSell  = useDailyReset ? sessionCumSell  : rollingCumSell
activeCumDelta = useDailyReset ? sessionCumDelta : rollingCumDelta

totalFlow      = activeCumBuy + activeCumSell
buyPct         = totalFlow > 0 ? activeCumBuy  / totalFlow * 100 : 50.0
sellPct        = totalFlow > 0 ? activeCumSell / totalFlow * 100 : 50.0
buyersDominate = buyPct  >= (50 + cvdThresholdPct / 2)
sellersDominate= sellPct >= (50 + cvdExitPct     / 2)

// Require N consecutive bars of seller dominance before CVD exit fires
var int cvdSellCount = 0
if sellersDominate
    cvdSellCount := cvdSellCount + 1
else
    cvdSellCount := 0
cvdExitConfirmed = cvdSellCount >= cvdExitBars

// ═══════════════════════════════════════════════════════════════════════════════
// BEAR MARKET REGIME DETECTION
// ═══════════════════════════════════════════════════════════════════════════════
bearMA = ta.sma(close, bearMAPeriod)
var int barsBelow = 0
var int barsAboveBear = 0
if close < bearMA
    barsBelow     := barsBelow + 1
    barsAboveBear := 0
else
    barsAboveBear := barsAboveBear + 1
    barsBelow     := 0

var bool inBearRegime = false
if barsBelow     >= bearConsecBars
    inBearRegime := true
if barsAboveBear >= bearExitBars
    inBearRegime := false

bearBlock = useBearFilter and inBearRegime

// ═══════════════════════════════════════════════════════════════════════════════
// TREND REVERSAL DETECTION
// ═══════════════════════════════════════════════════════════════════════════════
trendMA          = ta.sma(close, trendMAPeriod)
trendMAThreshold = trendMA * (1 + trendMABuffer / 100)
aboveMA          = close > trendMAThreshold

var int barsAboveMA = 0
if aboveMA
    barsAboveMA := barsAboveMA + 1
else
    barsAboveMA := 0

// Reversal fires exactly when price completes the confirmation window
reversalConfirmed = barsAboveMA == confirmBars

// RSI
rsi   = ta.rsi(close, rsiPeriod)
rsiOk = not useRsiFilter or rsi >= rsiMinLevel

// Session filter
inSession = not useSessionFilter or not na(time(timeframe.period, sessionStr))

// ═══════════════════════════════════════════════════════════════════════════════
// POSITION SIZING & EQUITY PROTECTION
// ═══════════════════════════════════════════════════════════════════════════════
safeEquity      = math.max(strategy.equity, strategy.initial_capital * 0.001)
effectiveMargin = useEquityPct ? safeEquity * marginEquityPct / 100 : marginAmt
qtyContracts    = (effectiveMargin * leverage) / math.max(close, 0.000001)

// Equity peak circuit breaker
var float equityPeak = strategy.initial_capital
equityPeak       := math.max(equityPeak, strategy.equity)
equityDDNow       = (equityPeak - strategy.equity) / equityPeak * 100.0
circuitBreaker    = equityDDNow >= equityDDPct

// Consolidated entry gate
entryGate = not bearBlock and not circuitBreaker and inSession

// ═══════════════════════════════════════════════════════════════════════════════
// POSITION STATE & TRAILING STOP
// ═══════════════════════════════════════════════════════════════════════════════
inPos    = strategy.position_size > 0
avgEntry = strategy.position_avg_price

var float peakSinceEntry = na
var int   barsInPos      = 0
if inPos
    peakSinceEntry := math.max(nz(peakSinceEntry, close), high)
    barsInPos      := barsInPos + 1
else
    peakSinceEntry := na
    barsInPos      := 0

rawTrail    = not na(peakSinceEntry) ? peakSinceEntry * (1 - trailPct / 100) : na
trailStop   = (not na(rawTrail) and avgEntry > 0) ? math.max(avgEntry, rawTrail) : na
trailActive = inPos and not na(peakSinceEntry) and
              peakSinceEntry >= avgEntry * (1 + trailActivate / 100)

portfolioStopAmt = equityPeak * portfolioStopPct / 100

// ═══════════════════════════════════════════════════════════════════════════════
// ORDERS
// ═══════════════════════════════════════════════════════════════════════════════
// ENTRY: reversal + CVD buyers + RSI ok + session + no bear regime + no circuit breaker
if reversalConfirmed and buyersDominate and rsiOk and entryGate and not inPos
    strategy.entry("Long", strategy.long, qty=qtyContracts,
                   comment="BUY " + str.tostring(math.round(buyPct, 1)) + "% | RSI " + str.tostring(math.round(rsi, 0)))

// EXIT 1: CVD sellers confirmed for N bars (minimum hold enforced)
if useCvdExit and inPos and cvdExitConfirmed and barsInPos >= minHoldBars
    strategy.close("Long", comment="CVD SELL " + str.tostring(math.round(sellPct, 1)) + "% x" + str.tostring(cvdSellCount))

// EXIT 2: trend MA crossunder
if useTrendExit and inPos and ta.crossunder(close, trendMA)
    strategy.close("Long", comment="TREND EXIT MA" + str.tostring(trendMAPeriod))

// EXIT 3: trailing stop (after activation threshold)
if useTrailStop and trailActive and close <= trailStop
    strategy.close("Long", comment="TRAIL EXIT")

// EXIT 4: emergency stop
if inPos and strategy.openprofit <= -portfolioStopAmt
    strategy.close("Long", comment="EMRG STOP")

// ═══════════════════════════════════════════════════════════════════════════════
// PLOTS
// ═══════════════════════════════════════════════════════════════════════════════
plot(trendMA, "Trend MA",  color=color.new(color.blue,   20), linewidth=2)
plot(bearMA,  "Bear MA",   color=color.new(color.red,    20), linewidth=1)
plot(inPos ? trailStop : na, "Trail Stop",
     color=color.new(color.yellow, 0), linewidth=2, style=plot.style_linebr)

plotshape(reversalConfirmed and buyersDominate and rsiOk and entryGate and not inPos,
          "BUY — CVD confirmed", shape.triangleup, location.belowbar,
          color.new(color.green, 0), size=size.normal)
plotshape(reversalConfirmed and (not buyersDominate or bearBlock),
          "Reversal blocked", shape.xcross, location.belowbar,
          color.new(color.gray, 30), size=size.tiny)
plotshape(inPos and cvdExitConfirmed and useCvdExit and barsInPos >= minHoldBars,
          "EXIT — CVD sellers", shape.triangledown, location.abovebar,
          color.new(color.red, 0), size=size.small)

bgcolor(inBearRegime   ? color.new(color.red,    88) : na, title="Bear Regime")
bgcolor(circuitBreaker ? color.new(color.purple, 88) : na, title="Circuit Breaker")
bgcolor(not inSession and useSessionFilter ? color.new(color.gray, 92) : na, title="Off Session")
bgcolor(inPos          ? color.new(color.green,  92) : na, title="In Position")

// ═══════════════════════════════════════════════════════════════════════════════
// DASHBOARD
// ═══════════════════════════════════════════════════════════════════════════════
var table dash = table.new(position.top_right, 2, 14,
     bgcolor=color.new(color.black, 55), border_width=1, border_color=color.new(color.gray, 60))

if barstate.islast
    pnlCol  = strategy.openprofit >= 0 ? color.lime : color.red
    netCol  = strategy.netprofit  >= 0 ? color.lime : color.red
    buyCol  = buyersDominate  ? color.lime : color.silver
    sellCol = sellersDominate ? color.red  : color.silver

    table.cell(dash, 0, 0,  "Vol Delta Reversal",   text_color=color.white,
               text_size=size.small, bgcolor=color.new(color.navy, 30))
    table.cell(dash, 1, 0,  "Long Only",             text_color=color.white,
               text_size=size.small, bgcolor=color.new(color.navy, 30))

    table.cell(dash, 0, 1,  "Buy Volume%",  text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 1,  str.tostring(math.round(buyPct,  1)) + "%" + (buyersDominate ? " ✓ BUYERS" : ""),
               text_color=buyCol, text_size=size.small)

    table.cell(dash, 0, 2,  "Sell Volume%", text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 2,  str.tostring(math.round(sellPct, 1)) + "%" + (sellersDominate ? " ✓ SELLERS" : ""),
               text_color=sellCol, text_size=size.small)

    table.cell(dash, 0, 3,  "CVD Net",      text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 3,  str.tostring(math.round(activeCumDelta, 0)),
               text_color=activeCumDelta >= 0 ? color.lime : color.red, text_size=size.small)

    table.cell(dash, 0, 4,  "Bear Regime",  text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 4,  inBearRegime ? ("🐻 BEAR " + str.tostring(barsBelow) + "bars") : ("✓ BULL " + str.tostring(barsAboveBear) + "bars"),
               text_color=inBearRegime ? color.red : color.lime, text_size=size.small)

    table.cell(dash, 0, 5,  "Trend MA",     text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 5,  (aboveMA ? "▲ ABOVE" : "▼ BELOW") + " | " + str.tostring(barsAboveMA) + " bars",
               text_color=aboveMA ? color.lime : color.red, text_size=size.small)

    table.cell(dash, 0, 6,  "RSI(" + str.tostring(rsiPeriod) + ")", text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 6,  str.tostring(math.round(rsi, 1)) + (rsiOk ? " ✓" : " ✗ <" + str.tostring(rsiMinLevel) + ")"),
               text_color=rsiOk ? color.lime : color.red, text_size=size.small)

    table.cell(dash, 0, 7,  "Session",      text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 7,  inSession ? "✓ Active" : "✗ Closed",
               text_color=inSession ? color.lime : color.gray, text_size=size.small)

    table.cell(dash, 0, 8,  "Circuit Breaker", text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 8,  circuitBreaker ? ("⛔ HALTED DD=" + str.tostring(math.round(equityDDNow, 1)) + "%") : "✓ ACTIVE",
               text_color=circuitBreaker ? color.red : color.lime, text_size=size.small)

    table.cell(dash, 0, 9,  "Position",     text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 9,  inPos ? ("LONG " + str.tostring(barsInPos) + "bars @ " + str.tostring(math.round(avgEntry, 2))) : "FLAT",
               text_color=inPos ? color.lime : color.gray, text_size=size.small)

    table.cell(dash, 0, 10, "Trail Stop",   text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 10, inPos ? (trailActive ? str.tostring(math.round(trailStop, 2)) : "wait +" + str.tostring(trailActivate) + "%") : "–",
               text_color=trailActive ? color.yellow : color.gray, text_size=size.small)

    table.cell(dash, 0, 11, "Equity Peak",  text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 11, str.tostring(math.round(equityPeak, 0)) + " | DD: " + str.tostring(math.round(equityDDNow, 1)) + "%",
               text_color=equityDDNow > equityDDPct * 0.75 ? color.red : color.lime, text_size=size.small)

    table.cell(dash, 0, 12, "Open P&L",     text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 12, "$" + str.tostring(math.round(strategy.openprofit, 2)),
               text_color=pnlCol, text_size=size.small)

    table.cell(dash, 0, 13, "Net Profit",   text_color=color.silver, text_size=size.small)
    table.cell(dash, 1, 13, "$" + str.tostring(math.round(strategy.netprofit, 2)) +
               " (" + str.tostring(strategy.closedtrades) + " trades)",
               text_color=netCol, text_size=size.small)