"""MAX_HOLD Sweep — 5y Klines
=============================
Root cause of -99.9% ROI: MAX_HOLD=120 bars × 60s = 2 HOURS.
Legacy optimal hold = 120 bars × 5s = 600s = 10 MINUTES.
On 1m klines that's 10 bars.

This sweep tests MAX_HOLD = [3, 5, 8, 10, 12, 15, 20, 30, 60, 120] bars
on SHORT and LONG directions at the default threshold (+-0.020).

Metric: Profit Factor (gross_win / gross_loss) and edge (WR - baseline).
PF > 1.0 = profitable raw (before fees/leverage). Target: find the sweet spot.

Also sweeps TP_BPS = [60, 95, 120, 150] to find the right TP/hold combo.

Output: run_logs/maxhold_sweep_YYYYMMDD_HHMMSS.csv + console summary
Runtime: ~2-3 minutes
"""
import sys, time, csv, gc
sys.stdout.reconfigure(encoding='utf-8', errors='replace')
from pathlib import Path
from datetime import datetime
from collections import defaultdict
import numpy as np
import pandas as pd
from numpy.lib.stride_tricks import sliding_window_view

VBT_DIR = Path(r"C:\Users\Lenovo\Documents\- DOLPHIN NG HD HCM TSF Predict\vbt_cache_klines")
LOG_DIR = Path(r"C:\Users\Lenovo\Documents\- DOLPHIN NG HD HCM TSF Predict\nautilus_dolphin\run_logs")

SHORT_T = -0.020
LONG_T  = +0.020

# Sweep parameters
HOLD_TIMES = [3, 5, 8, 10, 12, 15, 20, 30, 60, 120]
TP_BPS_LIST = [60, 95, 120, 150]

MAX_HOLD_MAX = max(HOLD_TIMES)  # precompute windows up to this size

parquet_files = sorted(VBT_DIR.glob("*.parquet"))
parquet_files = [p for p in parquet_files if 'catalog' not in str(p)]
total = len(parquet_files)
print(f"Files: {total}")
print(f"Hold times (bars): {HOLD_TIMES}")
print(f"TP (bps):          {TP_BPS_LIST}")
print(f"Thresholds: SHORT<={SHORT_T}  LONG>={LONG_T}")
print()

# stats[(direction, hold, tp_bps, year)] = {wins, losses, gw, gl}
stats = defaultdict(lambda: {'wins': 0, 'losses': 0, 'gw': 0.0, 'gl': 0.0})
ctrl  = defaultdict(lambda: {'up': 0, 'dn': 0, 'n': 0})  # ctrl[(hold, tp_bps, year)]

t0 = time.time()

for i, pf in enumerate(parquet_files):
    ds   = pf.stem
    year = ds[:4]

    try:
        df = pd.read_parquet(pf)
    except Exception:
        continue
    if 'vel_div' not in df.columns or 'BTCUSDT' not in df.columns:
        continue

    vd  = df['vel_div'].values.astype(np.float64)
    btc = df['BTCUSDT'].values.astype(np.float64)
    vd  = np.where(np.isfinite(vd), vd, 0.0)
    btc = np.where(np.isfinite(btc) & (btc > 0), btc, np.nan)
    n   = len(btc)
    del df

    if n < MAX_HOLD_MAX + 5:
        del vd, btc
        continue

    n_usable = n - MAX_HOLD_MAX
    # Precompute the largest window; sub-windows reuse slices
    big_windows = sliding_window_view(btc, MAX_HOLD_MAX + 1)[:n_usable]
    ep_arr = big_windows[:, 0]
    valid  = np.isfinite(ep_arr) & (ep_arr > 0)

    short_active = (vd[:n_usable] <= SHORT_T) & valid
    long_active  = (vd[:n_usable] >= LONG_T)  & valid

    for hold in HOLD_TIMES:
        # For this hold, extract futures from the large window
        # big_windows[:,1:hold+1] covers bars 1..hold
        sub = big_windows[:, 1:hold + 1]          # shape (n_usable, hold)
        fut_min = np.nanmin(sub, axis=1)
        fut_max = np.nanmax(sub, axis=1)
        last_px = big_windows[:, hold]             # bar at exactly hold

        for tp_bps in TP_BPS_LIST:
            tp_pct = tp_bps / 10_000.0

            # Control baseline (sample every 30 bars to keep speed)
            ctrl_key = (hold, tp_bps, year)
            for j in range(0, n_usable, 30):
                ep = ep_arr[j]
                if not valid[j]:
                    continue
                lp = last_px[j]
                if not np.isfinite(lp):
                    continue
                r_dn = (ep - fut_min[j]) / ep
                r_up = (fut_max[j] - ep) / ep
                ctrl[ctrl_key]['dn'] += int(r_dn >= tp_pct)
                ctrl[ctrl_key]['up'] += int(r_up >= tp_pct)
                ctrl[ctrl_key]['n']  += 1

            for direction, sig_mask in [('S', short_active), ('L', long_active)]:
                idx = np.where(sig_mask)[0]
                if len(idx) == 0:
                    continue

                ep_s  = ep_arr[idx]
                fmin_s = fut_min[idx]
                fmax_s = fut_max[idx]
                last_s = last_px[idx]

                if direction == 'S':
                    hit  = fmin_s <= ep_s * (1.0 - tp_pct)
                    lret = np.where(np.isfinite(last_s), (ep_s - last_s) / ep_s, 0.0)
                else:
                    hit  = fmax_s >= ep_s * (1.0 + tp_pct)
                    lret = np.where(np.isfinite(last_s), (last_s - ep_s) / ep_s, 0.0)

                w  = int(np.sum(hit))
                l  = int(np.sum(~hit))
                gw = w * tp_pct
                gl = float(np.sum(np.abs(lret[~hit])))
                k  = (direction, hold, tp_bps, year)
                stats[k]['wins']   += w
                stats[k]['losses'] += l
                stats[k]['gw']     += gw
                stats[k]['gl']     += gl

    del vd, btc, big_windows, ep_arr, valid, short_active, long_active
    del sub, fut_min, fut_max, last_px

    if (i + 1) % 200 == 0:
        gc.collect()
        elapsed = time.time() - t0
        print(f"  [{i+1}/{total}] {ds}  {elapsed:.0f}s")

elapsed = time.time() - t0
print(f"\nPass complete: {elapsed:.0f}s\n")

YEARS = ['2021', '2022', '2023', '2024', '2025', '2026']

# Print summary: for each direction × tp_bps, show PF vs hold time
for direction in ['S', 'L']:
    for tp_bps in TP_BPS_LIST:
        tp_pct = tp_bps / 10_000.0
        print(f"\n{'='*85}")
        print(f"  {direction}  TP={tp_bps}bps — PF by hold time (bars=minutes on 1m klines)")
        print(f"{'='*85}")
        hdr = f"  {'hold':>6}" + "".join(f" {yr:>10}" for yr in YEARS) + f"  {'TOTAL_PF':>9}  {'WR%':>7}  {'Edge':>7}"
        print(hdr)
        print(f"  {'-'*83}")
        for hold in HOLD_TIMES:
            yr_pfs = []
            tot_w = tot_l = 0; tot_gw = tot_gl = 0.0
            for yr in YEARS:
                k  = (direction, hold, tp_bps, yr)
                s  = stats.get(k, {'wins': 0, 'losses': 0, 'gw': 0.0, 'gl': 0.0})
                ck = (hold, tp_bps, yr)
                c  = ctrl.get(ck, {'dn': 0, 'up': 0, 'n': 1})
                bl = (c['dn'] / c['n'] * 100) if direction == 'S' else (c['up'] / c['n'] * 100)
                n_t = s['wins'] + s['losses']
                pf  = s['gw'] / s['gl'] if s['gl'] > 0 else (999.0 if s['gw'] > 0 else float('nan'))
                yr_pfs.append(f"{pf:>8.3f}" if n_t > 0 else "     ---")
                tot_w += s['wins']; tot_l += s['losses']; tot_gw += s['gw']; tot_gl += s['gl']
            # Total
            tot_n  = tot_w + tot_l
            tot_pf = tot_gw / tot_gl if tot_gl > 0 else 999.0
            tot_wr = tot_w / tot_n * 100 if tot_n > 0 else 0.0
            # control baseline (aggregate across years)
            tot_ctrl_dn = sum(ctrl.get((hold, tp_bps, yr), {'dn': 0, 'n': 1})['dn'] for yr in YEARS)
            tot_ctrl_up = sum(ctrl.get((hold, tp_bps, yr), {'up': 0, 'n': 1})['up'] for yr in YEARS)
            tot_ctrl_n  = sum(ctrl.get((hold, tp_bps, yr), {'n': 1})['n'] for yr in YEARS)
            ctrl_bl = (tot_ctrl_dn / tot_ctrl_n * 100) if direction == 'S' else (tot_ctrl_up / tot_ctrl_n * 100)
            edge = tot_wr - ctrl_bl
            hold_min = hold  # on 1m klines, 1 bar = 1 minute
            print(f"  {hold:>3}b={hold_min:>2}m" + "".join(f" {pf:>10}" for pf in yr_pfs) +
                  f"  {tot_pf:>9.3f}  {tot_wr:>6.1f}%  {edge:>+6.1f}pp")

# Save CSV
LOG_DIR.mkdir(exist_ok=True)
ts = datetime.now().strftime("%Y%m%d_%H%M%S")
rows = []
for (direction, hold, tp_bps, yr), s in stats.items():
    tp_pct = tp_bps / 10_000.0
    ck = (hold, tp_bps, yr)
    c  = ctrl.get(ck, {'dn': 0, 'up': 0, 'n': 1})
    bl = (c['dn'] / c['n'] * 100) if direction == 'S' else (c['up'] / c['n'] * 100)
    n_t = s['wins'] + s['losses']
    wr  = s['wins'] / n_t * 100 if n_t > 0 else float('nan')
    pf  = s['gw'] / s['gl'] if s['gl'] > 0 else (999.0 if s['gw'] > 0 else float('nan'))
    edge = wr - bl if n_t > 0 else float('nan')
    rows.append({
        'direction': direction, 'hold_bars': hold, 'hold_min': hold,
        'tp_bps': tp_bps, 'year': yr,
        'n_trades': n_t, 'wins': s['wins'], 'losses': s['losses'],
        'wr': round(wr, 3), 'pf': round(pf, 4), 'edge_pp': round(edge, 3),
        'gross_win': round(s['gw'], 6), 'gross_loss': round(s['gl'], 6),
        'ctrl_bl': round(bl, 3),
    })

out_path = LOG_DIR / f"maxhold_sweep_{ts}.csv"
with open(out_path, 'w', newline='') as f:
    w = csv.DictWriter(f, fieldnames=rows[0].keys())
    w.writeheader(); w.writerows(rows)

print(f"\n  → {out_path}")
print(f"  Runtime: {elapsed:.0f}s")
print(f"\n  KEY: Look for PF > 1.0 rows — that's the profitable hold/TP combination.")
print(f"  Legacy optimal: 10 bars (10 min on 1m klines) at 95bps TP.")