/**
 * Backtest: hold extension hypothesis.
 *
 * Hypothesis: when a time exit is due AND the position is at a loss AND
 * the current signal still points the same direction → extend rather than
 * close+reopen. Saves 2× fee round-trip (exit + re-entry).
 *
 * Tests:
 *   A. Baseline: always close at deadline
 *   B. Extend once: if losing + same signal → hold one more period
 *   C. Extend unlimited: keep extending while losing + same signal
 *   D. Extend if ANY same-direction signal (even small): extend threshold sweeps
 *
 * For each: net bps, t-stat, WR, monthly consistency, fee savings vs losses avoided.
 */
import fs from 'node:fs'
import readline from 'node:readline'

interface Bar { ts: number; o: number; h: number; l: number; c: number }

async function load(): Promise<Bar[]> {
  const bars: Bar[] = []
  const rl = readline.createInterface({ input: fs.createReadStream('data/klines/BTCUSDT-1m.jsonl') })
  for await (const line of rl) { if (line.trim()) bars.push(JSON.parse(line)) }
  return bars
}

// ── Signal helpers ──
function lbRet(b: Bar[], i: number, n: number) {
  return i >= n && b[i-n].c > 0 ? (b[i].c - b[i-n].c) / b[i-n].c * 10000 : 0
}
function closePos(b: Bar) { return b.h > b.l ? (b.c - b.l) / (b.h - b.l) : 0.5 }
function avgCP(b: Bar[], i: number, n: number) {
  let s = 0; for (let j = Math.max(0,i-n+1); j<=i; j++) s += closePos(b[j]); return s / Math.min(n,i+1)
}
function rsi(b: Bar[], i: number, n: number) {
  if (i < n) return 50; let u = 0, d = 0
  for (let j = i-n+1; j<=i; j++) { const dd = b[j].c - b[j-1].c; if(dd>0)u+=dd; else d-=dd }
  return d === 0 ? 100 : 100 - 100/(1+u/d)
}

function getScore(bars: Bar[], i: number): { score: number; holdBars: number } {
  let w = 0, hW = 0, tW = 0
  const d = new Date(bars[i].ts), h = d.getUTCHours(), m = d.getUTCMinutes(), dow = d.getUTCDay()
  const add = (dir: number, wt: number, hold: number) => { w += dir*wt; hW += hold*wt; tW += wt }
  if(dow===4)add(-1,34.41,240); if(dow===3)add(1,19.05,240); if(dow===0)add(1,15.05,240)
  if(dow===1)add(1,10.61,240); if(dow===5)add(-1,10.84,240)
  if(h===21)add(1,17.90,60); if(h===20)add(1,9.49,60); if(h===23)add(-1,8.94,30)
  const bp = avgCP(bars,i,60)
  if(bp>0.58)add(1,15.49,240); if(bp<0.42)add(-1,15.49,240)
  if((h===13||(h===14&&m<=15))&&m<=15&&i>=60){const g=lbRet(bars,i,60);if(Math.abs(g)>5)add(g>0?-1:1,6.87,120)}
  const rv = rsi(bars,i,60); if(rv<30)add(1,4.63,120); if(rv>70)add(-1,4.63,120)
  if(i>=1440){const dy=lbRet(bars,i,1440);if(Math.abs(dy)>30)add(dy>0?-1:1,5.0,240)}
  return { score: w, holdBars: tW>0?Math.max(60,Math.min(240,Math.round(hW/tW))):120 }
}

interface Trade {
  grossBps: number; netBps: number; month: string
  extended: boolean; extensionCount: number; feeSaved: number
}

const ENTRY_FEE = 2, EXIT_FEE = 2  // bps each way, maker
const SCORE_THRESH = 10

function simulate(
  bars: Bar[],
  extendMode: 'none' | 'once' | 'unlimited',
  extendScoreThresh: number,  // min |score| in same direction to extend
  extendOnlyIfLosing: boolean  // if false, extend even if profitable
): Trade[] {
  const trades: Trade[] = []
  let cd = 0

  for (let i = 1440; i < bars.length; i++) {
    if (i < cd) continue
    const { score, holdBars } = getScore(bars, i)
    if (Math.abs(score) < SCORE_THRESH) continue

    const dir = score > 0 ? 1 : -1
    const entry = bars[i].c
    let exitBar = i + holdBars
    if (exitBar >= bars.length) continue

    let extensions = 0
    const maxExtensions = extendMode === 'none' ? 0 : extendMode === 'once' ? 1 : 10

    // Walk forward with possible extensions
    while (extensions <= maxExtensions) {
      if (exitBar >= bars.length) { exitBar = bars.length - 1; break }

      const grossAtExit = dir * (bars[exitBar].c - entry) / entry * 10000
      const losing = grossAtExit < 0

      // Should we extend?
      if (extensions < maxExtensions) {
        const shouldExtend = extendOnlyIfLosing ? losing : true
        if (shouldExtend) {
          const { score: exitScore, holdBars: nextHold } = getScore(bars, exitBar)
          const sameDir = (exitScore * dir) > 0  // score agrees with position
          const strongEnough = Math.abs(exitScore) >= extendScoreThresh

          if (sameDir && strongEnough) {
            extensions++
            exitBar = Math.min(bars.length - 1, exitBar + nextHold)
            continue
          }
        }
      }
      break
    }

    const grossBps = dir * (bars[exitBar].c - entry) / entry * 10000
    // Fee saving: for each extension we avoided 1 exit + 1 re-entry = 2×(EXIT_FEE + ENTRY_FEE) = 8bps
    const feeSaved = extensions * (EXIT_FEE + ENTRY_FEE) * 2
    const netBps = grossBps - ENTRY_FEE - EXIT_FEE  // entry+exit fees (no re-entry fees saved)
    const month = new Date(bars[i].ts).toISOString().slice(0,7)

    trades.push({ grossBps, netBps, month, extended: extensions > 0, extensionCount: extensions, feeSaved })
    // cooldown: after exit + 5 bars
    cd = Math.max(exitBar + 5, i + 1)
  }
  return trades
}

function stats(trades: Trade[]) {
  const nets = trades.map(t => t.netBps)
  const n = nets.length; if (n < 3) return { mean: 0, t: 0, n, wr: 0, cum: 0 }
  const mean = nets.reduce((a,b)=>a+b,0)/n
  const se = Math.sqrt(nets.reduce((s,x)=>s+(x-mean)**2,0)/(n-1)/n)
  const t = se > 0 ? mean/se : 0
  const wr = nets.filter(v=>v>0).length/n
  const cum = nets.reduce((a,b)=>a+b,0)
  return { mean, t, n, wr, cum }
}

function sig(t: number) {
  const a = Math.abs(t); return a>3.89?'****':a>3.29?'***':a>2.58?'**':a>1.96?'*':''
}

function monthlyPositive(trades: Trade[]) {
  const byM = new Map<string,number[]>()
  trades.forEach(t => { if(!byM.has(t.month))byM.set(t.month,[]); byM.get(t.month)!.push(t.netBps) })
  let pos = 0
  for (const ns of byM.values()) if (ns.reduce((a,b)=>a+b,0) > 0) pos++
  return `${pos}/${byM.size}`
}

async function main() {
  process.stderr.write('Loading...')
  const bars = await load()
  process.stderr.write(` ${bars.length}\n\n`)

  const DAYS = 365
  const TPD = 1993 / DAYS  // ~5.5 trades/day from earlier backtest

  console.log('═'.repeat(100))
  console.log('HOLD EXTENSION HYPOTHESIS BACKTEST')
  console.log('When time-exit is due AND position losing AND same signal active → extend instead of close+reopen')
  console.log('Fee saving per extension: skip 1 exit (2bps) + 1 re-entry (2bps) = 4bps saved')
  console.log('Risk: position may continue moving against you')
  console.log('═'.repeat(100))
  console.log()

  // ── Section 1: Basic comparison ──
  console.log('1. BASIC COMPARISON')
  console.log('─'.repeat(100))
  console.log()

  const configs: [string, 'none'|'once'|'unlimited', number, boolean][] = [
    ['Baseline (no extension)',                          'none',      0,  true],
    ['Extend once if losing + same signal (thresh=10)',  'once',     10,  true],
    ['Extend once if losing + same signal (thresh=5)',   'once',      5,  true],
    ['Extend once regardless of P&L (thresh=10)',        'once',     10, false],
    ['Extend unlimited if losing + same signal (t=10)',  'unlimited',10,  true],
    ['Extend unlimited if losing + same signal (t=5)',   'unlimited', 5,  true],
  ]

  console.log('  Config'.padEnd(55) + 'n'.padStart(6) + '  mean'.padStart(8) + '  t'.padStart(8) + '  WR'.padStart(6) + '  cum bps'.padStart(10) + '  pos/mo'.padStart(10) + '  exts')
  console.log('  ' + '─'.repeat(95))

  const results: { label: string; trades: Trade[]; s: ReturnType<typeof stats> }[] = []
  for (const [label, mode, thresh, loseOnly] of configs) {
    const trades = simulate(bars, mode, thresh, loseOnly)
    const s = stats(trades)
    const exts = trades.filter(t => t.extended).length
    const mo = monthlyPositive(trades)
    results.push({ label, trades, s })
    console.log(
      '  ' + label.padEnd(55) +
      String(s.n).padStart(6) +
      s.mean.toFixed(2).padStart(9) +
      s.t.toFixed(2).padStart(8) + ' ' + sig(s.t).padEnd(4) +
      (s.wr*100).toFixed(0).padStart(5) + '%' +
      s.cum.toFixed(0).padStart(10) +
      mo.padStart(10) +
      String(exts).padStart(6) + ' exts'
    )
  }

  // ── Section 2: Extension threshold sweep ──
  console.log()
  console.log('2. SCORE THRESHOLD SWEEP (extend-once, losing-only)')
  console.log('─'.repeat(100))
  console.log()
  console.log('  MinScore'.padEnd(15) + 'n'.padStart(6) + '  mean'.padStart(8) + '  t'.padStart(8) + '  WR'.padStart(6) + '  cum bps'.padStart(10) + '  exts'.padStart(8) + '  vs baseline')
  console.log('  ' + '─'.repeat(65))

  const baseline = simulate(bars, 'none', 0, true)
  const baseStats = stats(baseline)

  for (const thresh of [0, 5, 8, 10, 15, 20, 25, 30]) {
    const trades = simulate(bars, 'once', thresh, true)
    const s = stats(trades)
    const exts = trades.filter(t => t.extended).length
    const diff = s.mean - baseStats.mean
    console.log(
      '  thresh>=' + String(thresh).padEnd(7) +
      String(s.n).padStart(6) +
      s.mean.toFixed(2).padStart(9) +
      s.t.toFixed(2).padStart(8) + ' ' + sig(s.t).padEnd(4) +
      (s.wr*100).toFixed(0).padStart(5) + '%' +
      s.cum.toFixed(0).padStart(10) +
      String(exts).padStart(8) +
      ('  ' + (diff >= 0 ? '+' : '') + diff.toFixed(2) + 'bps').padStart(12)
    )
  }

  // ── Section 3: P&L of extended vs non-extended trades ──
  console.log()
  console.log('3. DEEP DIVE: WHAT HAPPENS TO EXTENDED TRADES')
  console.log('─'.repeat(100))
  console.log()

  const extTrades = simulate(bars, 'once', 10, true)
  const extended = extTrades.filter(t => t.extended)
  const notExtended = extTrades.filter(t => !t.extended)
  const extStats = stats(extended)
  const noExtStats = stats(notExtended)

  console.log(`  Extended trades (${extended.length}):`)
  console.log(`    Mean net:    ${extStats.mean.toFixed(2)} bps  (t=${extStats.t.toFixed(2)})`)
  console.log(`    Win rate:    ${(extStats.wr*100).toFixed(0)}%`)
  console.log(`    Cumulative:  ${extStats.cum.toFixed(0)} bps`)
  console.log()
  console.log(`  Non-extended trades (${notExtended.length}):`)
  console.log(`    Mean net:    ${noExtStats.mean.toFixed(2)} bps  (t=${noExtStats.t.toFixed(2)})`)
  console.log(`    Win rate:    ${(noExtStats.wr*100).toFixed(0)}%`)
  console.log(`    Cumulative:  ${noExtStats.cum.toFixed(0)} bps`)
  console.log()

  // For extended trades: compare what would have happened WITHOUT extension
  const baseMap = new Map<number, number>()
  {
    let cd = 0
    for (let i = 1440; i < bars.length; i++) {
      if (i < cd) continue
      const { score, holdBars } = getScore(bars, i)
      if (Math.abs(score) < SCORE_THRESH) continue
      const dir = score > 0 ? 1 : -1
      const exitBar = Math.min(bars.length-1, i + holdBars)
      const gross = dir * (bars[exitBar].c - bars[i].c) / bars[i].c * 10000
      baseMap.set(i, gross)
      cd = Math.max(exitBar + 5, i + 1)
    }
  }

  // Match extended trades to their baseline equivalents
  let totalGainFromExtension = 0, extBetter = 0, extWorse = 0
  for (const t of extended) {
    // Find baseline gross for same entry approximately
    // We can check if extension helped or hurt
    totalGainFromExtension += t.grossBps  // rough proxy
  }

  console.log(`  What extension changed vs closing at original deadline:`)
  // Re-run baseline for extended subset
  const extBaseGross = extended.map(t => {
    // baseline gross = t.grossBps - effect of extension
    // We can't easily recover this without re-running, but we know:
    // extended trade's first segment was a loss (that's the condition)
    // Extended gross = t.grossBps, original would have been negative
    return t.grossBps  // just look at the final outcome
  })
  const extWins = extBaseGross.filter(g => g > 0).length
  const extLosses = extBaseGross.filter(g => g <= 0).length
  console.log(`    After extension: ${extWins} winners / ${extLosses} losers`)
  console.log(`    Avg gross after extension: ${(extBaseGross.reduce((a,b)=>a+b,0)/extBaseGross.length).toFixed(2)} bps`)
  console.log(`    If we had closed at original deadline: all ${extended.length} were LOSING`)
  console.log(`    Fee saved per extension: ${EXIT_FEE + ENTRY_FEE} bps (skip exit + re-entry)`)
  console.log(`    Total fee saved: ${extended.length * (EXIT_FEE + ENTRY_FEE)} bps`)
  console.log()

  // ── Section 4: Monthly breakdown for best config ──
  console.log('4. MONTHLY BREAKDOWN — baseline vs best extension')
  console.log('─'.repeat(100))
  console.log()

  // Find best extension config
  const extResults = [5,10,15,20].map(thresh => ({
    thresh,
    trades: simulate(bars,'once',thresh,true),
    s: stats(simulate(bars,'once',thresh,true))
  })).sort((a,b) => b.s.t - a.s.t)
  const best = extResults[0]

  console.log(`  Best: extend-once, thresh=${best.thresh}, vs baseline`)
  console.log()
  console.log('  Month      Baseline_cum  Extension_cum  Diff')
  console.log('  ' + '─'.repeat(50))

  const byMonth = new Map<string, {base: number[]; ext: number[]}>()
  baseline.forEach(t => { if(!byMonth.has(t.month))byMonth.set(t.month,{base:[],ext:[]}); byMonth.get(t.month)!.base.push(t.netBps) })
  best.trades.forEach(t => { if(!byMonth.has(t.month))byMonth.set(t.month,{base:[],ext:[]}); byMonth.get(t.month)!.ext.push(t.netBps) })

  let baseCum = 0, extCum = 0, extBetterMonths = 0, totalMonths = 0
  for (const [m, v] of [...byMonth.entries()].sort()) {
    const bc = v.base.reduce((a,b)=>a+b,0), ec = v.ext.reduce((a,b)=>a+b,0)
    baseCum += bc; extCum += ec; totalMonths++
    if (ec > bc) extBetterMonths++
    const diff = ec - bc
    const flag = diff > 0 ? '↑' : diff < 0 ? '↓' : '='
    console.log(`  ${m}  ${baseCum.toFixed(0).padStart(12)}  ${extCum.toFixed(0).padStart(13)}  ${(diff>=0?'+':'')+diff.toFixed(0)} ${flag}`)
  }
  console.log()
  console.log(`  Extension better in ${extBetterMonths}/${totalMonths} months`)
  console.log(`  Baseline total: ${baseStats.cum.toFixed(0)} bps (mean ${baseStats.mean.toFixed(2)}, t=${baseStats.t.toFixed(2)})`)
  console.log(`  Extension total: ${best.s.cum.toFixed(0)} bps (mean ${best.s.mean.toFixed(2)}, t=${best.s.t.toFixed(2)})`)

  // ── Section 5: The real question — does the extended portion have positive expectancy? ──
  console.log()
  console.log('5. CORE QUESTION: does the EXTENSION PERIOD itself have positive EV?')
  console.log('─'.repeat(100))
  console.log()
  console.log('  Each extension is equivalent to entering a new trade at the old deadline bar.')
  console.log('  What is the PnL of just the extension segment (deadline bar → new exit bar)?')
  console.log()

  // Simulate extensions as standalone trades
  const extensionSegments: number[] = []
  {
    let cd = 0
    for (let i = 1440; i < bars.length; i++) {
      if (i < cd) continue
      const { score, holdBars } = getScore(bars, i)
      if (Math.abs(score) < SCORE_THRESH) continue
      const dir = score > 0 ? 1 : -1
      const exitBar = Math.min(bars.length-1, i + holdBars)
      if (exitBar >= bars.length) { cd = exitBar + 5; continue }

      const grossAtExit = dir * (bars[exitBar].c - bars[i].c) / bars[i].c * 10000
      const isLosing = grossAtExit < 0

      if (isLosing) {
        // Check if extension would fire
        const { score: extScore, holdBars: extHold } = getScore(bars, exitBar)
        const sameDir = (extScore * dir) > 0
        if (sameDir && Math.abs(extScore) >= 10) {
          // Extension segment: from exitBar to exitBar+extHold
          const extExitBar = Math.min(bars.length-1, exitBar + extHold)
          const extGross = dir * (bars[extExitBar].c - bars[exitBar].c) / bars[exitBar].c * 10000
          extensionSegments.push(extGross)
        }
      }
      cd = Math.max(exitBar + 5, i + 1)
    }
  }

  const extSegStats = stats(extensionSegments.map(g => ({ netBps: g - EXIT_FEE - ENTRY_FEE, grossBps: g, month: '', extended: false, extensionCount: 0, feeSaved: 0 })))
  const extSegGrossStats = stats(extensionSegments.map(g => ({ netBps: g, grossBps: g, month: '', extended: false, extensionCount: 0, feeSaved: 0 })))
  console.log(`  Extension segments: ${extensionSegments.length}`)
  console.log(`  Gross per segment:  ${extSegGrossStats.mean.toFixed(2)} bps (t=${extSegGrossStats.t.toFixed(2)} ${sig(extSegGrossStats.t)})`)
  console.log(`  Net per segment:    ${extSegStats.mean.toFixed(2)} bps (t=${extSegStats.t.toFixed(2)} ${sig(extSegStats.t)})`)
  console.log(`    = extension period has ${extSegStats.mean > 0 ? 'POSITIVE' : 'NEGATIVE'} EV on its own`)
  console.log()
  console.log(`  But WITH extension we skip the re-entry fee (+4bps effective saving)`)
  console.log(`  Net benefit of extending vs close+reopen: ${(extSegStats.mean + 4).toFixed(2)} bps vs ${extSegGrossStats.mean.toFixed(2)} bps gross stand-alone`)
  console.log()

  // ── Final verdict ──
  console.log('═'.repeat(100))
  console.log('VERDICT')
  console.log('═'.repeat(100))
  console.log()
  const improved = best.s.mean > baseStats.mean
  const improvement = best.s.mean - baseStats.mean
  const tImproved = best.s.t > baseStats.t
  console.log(`  Baseline:         mean=${baseStats.mean.toFixed(2)}bps  t=${baseStats.t.toFixed(2)}  cum=${baseStats.cum.toFixed(0)}bps`)
  console.log(`  Best extension:   mean=${best.s.mean.toFixed(2)}bps  t=${best.s.t.toFixed(2)}  cum=${best.s.cum.toFixed(0)}bps  (thresh=${best.thresh})`)
  console.log()
  if (improved) {
    console.log(`  ✅ Extension IMPROVES edge by +${improvement.toFixed(2)} bps/trade (+${(improvement/baseStats.mean*100).toFixed(0)}%)`)
    console.log(`  ✅ t-stat: ${baseStats.t.toFixed(2)} → ${best.s.t.toFixed(2)}`)
    console.log(`  Reason: extended trades recover ${extensionSegments.filter(g=>g>0).length}/${extensionSegments.length} times (${(extensionSegments.filter(g=>g>0).length/extensionSegments.length*100).toFixed(0)}%)`)
    console.log(`          The same signal active at deadline = continuation, not reversal`)
  } else {
    console.log(`  ✗ Extension does NOT improve edge (−${Math.abs(improvement).toFixed(2)} bps/trade)`)
    console.log(`  Reason: extended positions continued losing more often than they recovered`)
    console.log(`          The signal being active at deadline doesn't predict recovery`)
  }
}

main().catch(e => { process.stderr.write(`FATAL: ${e instanceof Error ? e.stack : e}\n`); process.exit(1) })