//@version=6
strategy("Options BOS v6 — Valid Pullback Research", overlay=true, pyramiding=0, process_orders_on_close=false, calc_on_every_tick=false, calc_on_order_fills=false, default_qty_type=strategy.fixed, default_qty_value=1, initial_capital=10000, max_lines_count=500, max_labels_count=500, max_bars_back=500)
// Developed from the user's Valid BOS Pullback v2-v5. One Pine strategy file.
// Underlying structure signals are NOT historical option profits.
// Optional Strategy Tester orders are stock-direction proxies, never option orders.
// No brokerage connection. Order-fill alerts are disabled.
gSignal = "01 · Original BOS structure"
window = input.string("1–3 days", "Expiration window", options=["1–3 days", "7–14 days"], group=gSignal)
pivotLength = input.int(5, "Strict confirmed swing length", minval=1, maxval=100, group=gSignal)
atrLength = input.int(14, "ATR length", minval=1, group=gSignal)
minBars = input.int(5, "Minimum bars since impulse extreme", minval=1, group=gSignal)
maxBars = input.int(40, "Maximum pullback bars", minval=1, group=gSignal)
tolATR = input.float(0.25, "Frozen retest / hold tolerance (ATR)", minval=0, step=0.05, group=gSignal)
holdMode = input.string("Close", "Hold rule", options=["Close", "Wick"], group=gSignal)
needConfirm = input.bool(true, "Require directional pullback confirmation candle", group=gSignal)
breakByClose = input.bool(true, "Confirm BOS by close (off = wick at bar close)", group=gSignal)
maxWaitBOS = input.int(0, "Maximum bars after valid pullback (0 = unlimited)", minval=0, group=gSignal)
entryMode = input.string("BOS", "Entry research model", options=["Pullback", "BOS"], group=gSignal)
stopBufATR = input.float(0.1, "Fixed stop buffer (setup ATR)", minval=0, step=0.05, group=gSignal)
rr = input.float(2, "Underlying target R multiple", minval=0.5, step=0.5, group=gSignal)
allowCalls = input.bool(true, "Enable purchased Call candidates", group=gSignal)
allowPuts = input.bool(true, "Enable purchased Put candidates", group=gSignal)

gFilter = "02 · Optional candidate filters"
useTrend = input.bool(false, "Enable chart-timeframe EMA filter", group=gFilter)
emaLength = input.int(50, "Trend EMA length", minval=1, group=gFilter)
volumeMultiple = input.float(0, "Minimum relative volume (0 = off)", minval=0, step=0.1, group=gFilter)
regularHours = input.bool(true, "Restrict intraday entries to regular hours", group=gFilter)
marketSession = input.session("0930-1600", "New York entry session", group=gFilter)
eventBlock = input.bool(false, "Block entries for known earnings / events (manual)", group=gFilter)
allowCustom = input.bool(false, "Allow an additional technology stock (user verified)", group=gFilter)
// Filters gate entry candidates, not structural success counters.

gDisplay = "05 · Research and display"
proxyEnabled = input.bool(false, "Enable stock proxy backtest (NOT option returns)", group=gDisplay)
maxHoldBars = input.int(20, "Maximum stock proxy holding bars", minval=1, group=gDisplay)
infoAlerts = input.bool(false, "Enable informational candidate alerts", group=gDisplay)
showStructure = input.bool(true, "Show structure events and reference lines", group=gDisplay)
showMA = input.bool(false, "Show chart EMA", group=gDisplay)
showRisk = input.bool(true, "Show fixed underlying risk levels", group=gDisplay)
displayMode = input.string("History", "Trade display", options=["History", "Latest"], group=gDisplay)
retainTrades = input.int(30, "Maximum displayed trade cards", minval=1, maxval=60, group=gDisplay)
if barstate.isfirst and maxBars < minBars
    runtime.error("Maximum pullback bars must be at least minimum pullback bars.")

gPlan = "03 · Manual option plan"
optionType = input.string("Call", "Purchased option type", options=["Call", "Put"], group=gPlan)
strike = input.float(0, "Actual option strike ($)", minval=0, group=gPlan)
entryPremium = input.float(0, "Actual entry premium per share ($)", minval=0, step=0.01, group=gPlan)
exitPremium = input.float(0, "Current / planned exit premium per share ($)", minval=0, step=0.01, group=gPlan)
contracts = input.int(1, "Option contracts (100 shares each)", minval=1, maxval=10000, group=gPlan)
entryDate = input.time(0, "Actual option entry date/time", group=gPlan)
expiryDate = input.time(0, "Actual option expiration date/time", group=gPlan)
includeSell = input.bool(true, "Include a closing sell execution", group=gPlan)
premiumTick = input.float(0.01, "Allowed premium price increment ($)", minval=0.01, step=0.01, group=gPlan)
planCapital = input.float(10000, "Planning capital ($)", minval=1, group=gPlan)
riskPercent = input.float(2, "Maximum premium capital at risk (%)", minval=0.1, maxval=100, step=0.1, group=gPlan)
profitTarget = input.float(25, "Target net return on entry cost (%)", minval=0, step=1, group=gPlan)

gFees = "04 · Sahm fees (per execution)"
vatEnabled = input.bool(true, "Apply Saudi VAT: 15% on fees", group=gFees)
orfRate = input.float(0.01171, "Estimated ORF per contract ($)", minval=0, step=0.00001, group=gFees)
secRate = input.float(27.8, "Estimated SEC fee per $1 million of sell proceeds", minval=0, group=gFees)
tafRate = input.float(0.00279, "Estimated FINRA TAF per sold contract ($)", minval=0, step=0.00001, group=gFees)
tafCap = input.float(7.27, "TAF cap per sell execution ($; 0 = no cap)", minval=0, group=gFees)
regConfirmed = input.bool(false, "Confirm SEC / TAF inputs (zero only if applicable)", group=gFees)
// SEC/TAF defaults are user-supplied estimates, not independently verified current rates.
// Full precision is retained; display rounds to cents. Invoice rounding may differ.
f_fee(float premium, int qty, bool selling) =>
    bool low = premium <= 0.10
    float commission = math.max(qty * (low ? 0.49 : 0.99), low ? 0.99 : 1.99)
    float settlement = qty * 0.18
    float occ = math.min(qty * 0.02, 55.0)
    float orf = qty * orfRate
    float sec = selling ? premium * 100 * qty * secRate / 1000000 : 0
    float tafRaw = selling ? qty * tafRate : 0
    float taf = tafCap > 0 ? math.min(tafRaw, tafCap) : tafRaw
    float subtotal = commission + settlement + occ + orf + sec + taf
    float vat = vatEnabled ? subtotal * 0.15 : 0
    [commission, settlement, occ, orf, sec, taf, vat, subtotal + vat]
f_total(float premium, bool selling) =>
    [commission, settlement, occ, orf, sec, taf, vat, total] = f_fee(premium, contracts, selling)
    total
f_net(float sellPremium) =>
    (sellPremium - entryPremium) * 100 * contracts - f_total(entryPremium, false) - (includeSell ? f_total(sellPremium, true) : 0)
// Integer-tick search within each fee tier separately. A single global binary search
// would be incorrect across the discontinuity at a premium of $0.10.
f_target(float desiredNet) =>
    int lastLow = int(math.floor((0.10 + 0.000000000001) / premiumTick))
    int firstHigh = lastLow + 1
    bool lowWorks = f_net(lastLow * premiumTick) >= desiredNet
    int lo = lowWorks ? 0 : firstHigh
    int hi = lowWorks ? lastLow : math.max(firstHigh, int(math.ceil((entryPremium + 1) / premiumTick)))
    int expand = 0
    while not lowWorks and f_net(hi * premiumTick) < desiredNet and expand < 30
        hi *= 2
        expand += 1
    bool possible = f_net(hi * premiumTick) >= desiredNet
    int iterations = 0
    while possible and lo < hi and iterations < 60
        int mid = int(math.floor((lo + hi) / 2.0))
        if f_net(mid * premiumTick) >= desiredNet
            hi := mid
        else
            lo := mid + 1
        iterations += 1
    possible ? lo * premiumTick : na


allowed = syminfo.ticker == "AAPL" or syminfo.ticker == "MSFT" or syminfo.ticker == "NVDA" or syminfo.ticker == "AMD" or syminfo.ticker == "GOOGL" or syminfo.ticker == "META" or syminfo.ticker == "AMZN" or syminfo.ticker == "AVGO" or syminfo.ticker == "ORCL" or syminfo.ticker == "CRM" or syminfo.ticker == "ADBE" or syminfo.ticker == "PLTR"
supported = chart.is_standard and syminfo.type == "stock" and (allowed or allowCustom) and (timeframe.isintraday or timeframe.isdaily)
atr = ta.atr(atrLength)
ema = ta.ema(close, emaLength)
volAvg = ta.sma(volume, 20)
sessionOK = not regularHours or not timeframe.isintraday or not na(time(timeframe.period, marketSession, "America/New_York"))
volumeOK = volumeMultiple == 0 or (not na(volume) and not na(volAvg) and volume >= volumeMultiple * volAvg)
// Strict pivots avoid ambiguous equal-high/low clusters, and match the offline oracle.
f_strict(bool upper) =>
    float candidate = upper ? high[pivotLength] : low[pivotLength]
    bool valid = bar_index >= 2 * pivotLength
    for k = 0 to 2 * pivotLength
        if k != pivotLength
            valid := valid and (upper ? high[k] < candidate : low[k] > candidate)
    valid ? candidate : na
ph = f_strict(true)
pl = f_strict(false)
var float lastPH = na
var float lastPL = na
var int phConfirmed = na
var int plConfirmed = na
var bool phUsed = true
var bool plUsed = true
var int state = 0
var int dir = 0
var float ref = na
var float leg = na
var int legBar = na
var int pbBar = na
var float pbLow = na
var float setupATR = na
var float tolerance = na
var int pbCount = 0
var int bosCount = 0
var int failCount = 0
bool pbSignal = false
bool bosSignal = false
bool failed = false
float candidateStop = na
float candidateInvalidation = na
float structureLevel = na
int signalDir = 0
if barstate.isconfirmed
    if not na(ph)
        lastPH := ph
        phConfirmed := bar_index
        phUsed := false
    if not na(pl)
        lastPL := pl
        plConfirmed := bar_index
        plUsed := false
    if state == 0 and not na(atr)
        bool up = not phUsed and not na(lastPH) and phConfirmed < bar_index and close > lastPH
        bool down = not plUsed and not na(lastPL) and plConfirmed < bar_index and close < lastPL
        if up or down
            dir := up ? 1 : -1
            if up
                phUsed := true
            else
                plUsed := true
            ref := up ? lastPH : -lastPL
            leg := up ? high : -low
            legBar := bar_index
            pbLow := leg
            setupATR := atr
            tolerance := tolATR * setupATR
            state := 1
    else if state != 0
        float nh = dir == 1 ? high : -low
        float nl = dir == 1 ? low : -high
        float nc = dir * close
        float no = dir * open
        bool failHold = (holdMode == "Close" ? nc : nl) < ref - tolerance
        bool expired = state == 1 ? bar_index - legBar > maxBars : maxWaitBOS > 0 and bar_index - pbBar > maxWaitBOS
        // Failure takes priority, including an outside bar that also breaks the impulse.
        if failHold or expired
            state := 0
            failCount += 1
            failed := true
            if showStructure
                label.new(bar_index, close, expired ? "Expired" : "Invalidation", color=color.new(color.gray, 60), textcolor=color.white, size=size.tiny)
        else if state == 1
            if nh > leg
                leg := nh
                legBar := bar_index
                pbLow := leg
            else
                pbLow := math.min(pbLow, nl)
                bool confirmed = not needConfirm or (nc > no and nc > ref)
                if pbLow <= ref + tolerance and bar_index - legBar >= minBars and confirmed
                    state := 2
                    pbBar := bar_index
                    pbCount += 1
                    pbSignal := true
                    signalDir := dir
                    structureLevel := dir * ref
                    candidateStop := dir * (pbLow - stopBufATR * setupATR)
                    candidateInvalidation := dir * (ref - tolerance)
        else
            float priorLow = pbLow
            pbLow := math.min(pbLow, nl)
            if (breakByClose ? nc : nh) > leg
                bosCount += 1
                bosSignal := true
                signalDir := dir
                structureLevel := dir * leg
                // Use only the protective extreme known BEFORE the BOS candle.
                candidateStop := dir * (priorLow - stopBufATR * setupATR)
                candidateInvalidation := dir * (ref - tolerance)
                state := 1
                ref := leg
                leg := nh
                legBar := bar_index
                pbLow := leg
                setupATR := atr
                tolerance := tolATR * setupATR

var array<label> cards = array.new<label>()
var array<line> levels = array.new<line>()
f_card(int x, float y, string text, color c, bool below) =>
    label id = label.new(x, y, text, style=below ? label.style_label_up : label.style_label_down, color=c, textcolor=color.white, size=size.small)
    array.push(cards, id)
    if array.size(cards) > (displayMode == "Latest" ? 4 : retainTrades * 4)
        label.delete(array.shift(cards))
f_line(float price, color c, bool dashed) =>
    line id = line.new(bar_index, price, bar_index + 15, price, color=c, style=dashed ? line.style_dashed : line.style_solid)
    array.push(levels, id)
    if array.size(levels) > (displayMode == "Latest" ? 5 : retainTrades * 5)
        line.delete(array.shift(levels))
if showStructure and (pbSignal or bosSignal)
    label.new(bar_index, structureLevel, bosSignal ? "Valid BOS ✓" : "Valid Pullback", style=signalDir == 1 ? label.style_label_down : label.style_label_up, color=color.new(signalDir == 1 ? color.green : color.red, 65), textcolor=color.white, size=size.tiny)
    line.new(bar_index - 1, structureLevel, bar_index, structureLevel, color=color.gray, style=line.style_dashed)
bool chosen = entryMode == "Pullback" ? pbSignal : bosSignal
bool trendOK = not useTrend or (signalDir == 1 ? close > ema : close < ema)
bool directionOK = signalDir == 1 ? allowCalls : allowPuts
bool candidate = barstate.isconfirmed and chosen and supported and directionOK and sessionOK and volumeOK and trendOK and not eventBlock and signalDir * (close - candidateStop) > syminfo.mintick
var string lastCandidate = "None"
var float fixedStop = na
var float fixedTarget = na
var float fixedInvalidation = na
var int tradeDir = 0
var int closedSeen = 0
if candidate and (not proxyEnabled or strategy.position_size == 0)
    if displayMode == "Latest"
        while array.size(cards) > 0
            label.delete(array.shift(cards))
        while array.size(levels) > 0
            line.delete(array.shift(levels))
    string kind = signalDir == 1 ? "Call" : "Put"
    lastCandidate := kind + " · " + str.format_time(time_close, "yyyy-MM-dd HH:mm", "America/New_York")
    float target = close + signalDir * rr * math.abs(close - candidateStop)
    f_card(bar_index, close, "Entry signal · " + kind + "\nUnderlying $" + str.tostring(close, format.mintick) + "\n" + str.format_time(time_close, "yyyy-MM-dd HH:mm", "America/New_York") + "\nContract Candidate · Unverified\nTarget DTE " + window, color.blue, signalDir == 1)
    line marker = line.new(bar_index, low, bar_index, high, color=color.blue, style=line.style_dashed)
    array.push(levels, marker)
    if showRisk
        f_line(close, color.blue, false)
        f_line(candidateInvalidation, color.red, true)
        f_line(candidateStop, color.orange, false)
        f_line(target, color.green, false)
    while array.size(levels) > (displayMode == "Latest" ? 5 : retainTrades * 5)
        line.delete(array.shift(levels))
    if infoAlerts
        alert(kind + " candidate | " + syminfo.ticker + " | " + entryMode + " | " + window + " | Underlying structure only; contract unverified", alert.freq_once_per_bar_close)
    if proxyEnabled
        fixedStop := candidateStop
        fixedTarget := target
        fixedInvalidation := candidateInvalidation
        tradeDir := signalDir
        strategy.entry("Underlying proxy", signalDir == 1 ? strategy.long : strategy.short, comment=kind + " direction · STOCK PROXY", disable_alert=true)
        strategy.exit("Proxy bracket", "Underlying proxy", stop=fixedStop, limit=fixedTarget, comment_loss="Stop Loss", comment_profit="Take Profit", disable_alert=true)
// Frozen bracket prices never widen. Entries execute at next available bar open.
if proxyEnabled and strategy.position_size != 0
    bool invalidated = tradeDir * close < tradeDir * fixedInvalidation
    bool timedOut = bar_index - strategy.opentrades.entry_bar_index(0) >= maxHoldBars
    if invalidated or timedOut
        strategy.close("Underlying proxy", comment=invalidated ? "Invalidation" : "Time Exit", disable_alert=true)
if proxyEnabled and strategy.closedtrades > closedSeen
    int n = strategy.closedtrades - 1
    f_card(strategy.closedtrades.exit_bar_index(n), strategy.closedtrades.exit_price(n), "Exit · " + strategy.closedtrades.exit_comment(n) + "\nClosed · STOCK PROXY\nOption Net P&L: Unavailable", color.gray, false)
    closedSeen := strategy.closedtrades
plot(showMA ? ema : na, "Chart EMA", color=color.gray)

var table stats = table.new(position.bottom_right, 2, 5, bgcolor=color.new(color.black, 15))
if barstate.islast
    table.cell(stats, 0, 0, "Structure state", text_color=color.white)
    table.cell(stats, 1, 0, state == 0 ? "Idle" : state == 1 ? "Tracking Pullback" : "Waiting for BOS", text_color=color.white)
    table.cell(stats, 0, 1, "Valid Pullbacks / BOS", text_color=color.white)
    table.cell(stats, 1, 1, str.tostring(pbCount) + " / " + str.tostring(bosCount), text_color=color.white)
    table.cell(stats, 0, 2, "Failed / expired setups", text_color=color.white)
    table.cell(stats, 1, 2, str.tostring(failCount), text_color=color.white)
    table.cell(stats, 0, 3, "BOS confirmation rate", text_color=color.white)
    table.cell(stats, 1, 3, pbCount > 0 ? str.tostring(100.0 * bosCount / pbCount, "#.0") + "% · NOT win rate" : "Unavailable", text_color=color.yellow)
    table.cell(stats, 0, 4, "Option backtest", text_color=color.white)
    table.cell(stats, 1, 4, "Not available · premiums required", text_color=color.yellow)

f_usd(float value) =>
    na(value) ? "Unavailable" : "$" + str.tostring(value, "#.00")
f_row(table panel, int row, string label, string value, color valueColor) =>
    table.cell(panel, 0, row, label, text_color=color.silver, bgcolor=color.new(color.black, 15), text_halign=text.align_left)
    table.cell(panel, 1, row, value, text_color=valueColor, bgcolor=color.new(color.black, 15), text_halign=text.align_left)
var table panel = table.new(position.top_right, 2, 19, border_width=1)
if barstate.islast
    string entryDay = str.format_time(entryDate, "yyyy-MM-dd", "America/New_York")
    string expiryDay = str.format_time(expiryDate, "yyyy-MM-dd", "America/New_York")
    int calendarDays = int(math.round((timestamp("UTC", year(expiryDate, "America/New_York"), month(expiryDate, "America/New_York"), dayofmonth(expiryDate, "America/New_York"), 0, 0) - timestamp("UTC", year(entryDate, "America/New_York"), month(entryDate, "America/New_York"), dayofmonth(entryDate, "America/New_York"), 0, 0)) / 86400000.0))
    bool datesOK = entryDate > 0 and expiryDate > entryDate and (window == "1–3 days" ? calendarDays >= 1 and calendarDays <= 3 : calendarDays >= 7 and calendarDays <= 14)
    bool planOK = entryPremium > 0 and strike > 0 and datesOK
    [buyCommission, buySettlement, buyOCC, buyORF, buySEC, buyTAF, buyVAT, buyTotal] = f_fee(entryPremium, contracts, false)
    [sellCommission, sellSettlement, sellOCC, sellORF, sellSEC, sellTAF, sellVAT, sellTotal] = f_fee(exitPremium, contracts, true)
    float closingFee = includeSell ? sellTotal : 0
    float totalFees = buyTotal + closingFee
    float gross = (exitPremium - entryPremium) * 100 * contracts
    float net = gross - totalFees
    float cost = entryPremium * 100 * contracts + buyTotal
    float budget = planCapital * riskPercent / 100
    float breakEven = planOK ? f_target(0) : na
    float targetExit = planOK ? f_target(cost * profitTarget / 100) : na
    float breakEvenStock = optionType == "Call" ? strike + breakEven : strike - breakEven
    f_row(panel, 0, "Options BOS v6", window + " · LONG OPTIONS ONLY", color.white)
    f_row(panel, 1, "Mode", proxyEnabled ? "Stock proxy backtest · NOT options" : "Original BOS + manual option scenario", color.yellow)
    f_row(panel, 2, "Chart", supported ? syminfo.ticker : "Unsupported symbol / timeframe", supported ? color.white : color.red)
    f_row(panel, 3, "Last candidate", lastCandidate, color.white)
    f_row(panel, 4, "Event filter", eventBlock ? "New candidates blocked manually" : "No automatic earnings calendar", color.yellow)
    f_row(panel, 5, "Purchased option", optionType + " · " + str.tostring(contracts) + " contract(s)", color.white)
    f_row(panel, 6, "Dates", planOK ? entryDay + " → " + expiryDay : "Enter premiums, strike and valid dates", planOK ? color.white : color.yellow)
    f_row(panel, 7, "Entry / exit premium", planOK ? f_usd(entryPremium) + " / " + f_usd(exitPremium) : "Not entered", color.white)
    f_row(panel, 8, "Buy brokerage minimum applied", planOK ? f_usd(buyCommission) : "—", color.white)
    f_row(panel, 9, "Sell brokerage minimum applied", planOK ? (includeSell ? f_usd(sellCommission) : "No closing execution") : "—", color.white)
    f_row(panel, 10, "Buy fees incl. VAT", planOK ? f_usd(buyTotal) : "—", color.white)
    f_row(panel, 11, "Sell fees incl. VAT", planOK ? f_usd(closingFee) : "—", color.white)
    f_row(panel, 12, "SEC / TAF inputs", regConfirmed ? "Confirmed by user · ORF estimated" : "User-supplied rates · estimated net", color.yellow)
    f_row(panel, 13, "Scenario gross / estimated net", planOK ? f_usd(gross) + " / " + f_usd(net) : "—", net >= 0 ? color.lime : color.red)
    f_row(panel, 14, "Entry cost / risk budget", planOK ? f_usd(cost) + " / " + f_usd(budget) + (cost > budget ? " · OVER BUDGET" : " · Within budget") : "—", cost > budget ? color.red : color.lime)
    f_row(panel, 15, "Break-even sell premium", f_usd(breakEven), color.white)
    f_row(panel, 16, "Indicative stock break-even", optionType == "Put" and breakEven > strike ? "Not reachable by intrinsic value" : f_usd(breakEvenStock), color.white)
    f_row(panel, 17, "Target net sell premium", f_usd(targetExit), color.white)
    f_row(panel, 18, "VAT / fee basis", vatEnabled ? "15% on fees · Per execution minima" : "No VAT · Per execution minima", color.yellow)