"""Hour-Gated LONG Crossover — 5y Klines
========================================
Option 1: Full hour-gated LONG test.

Signal:  vel_div <= -ENTRY_T  →  LONG
Exit:    vel_div >= +ENTRY_T  (mean-reversion complete)  OR
         MAX_HOLD bars reached  (safety cap, 20 bars)

Gate variants tested:
  - UNGATED         (all 24 hours)
  - BEST3           (hours 9, 12, 18 UTC — London afternoon + US open)
  - BEST5           (hours 8, 9, 12, 13, 18 UTC)
  - WORST5          (complement — worst 5 hours for reference)
  - Each individual hour 0..23

Per-year PF breakdown to confirm consistency.

Output:
  run_logs/hour_gated_long_YYYYMMDD_HHMMSS.csv
  run_logs/hour_gated_long_top_YYYYMMDD_HHMMSS.txt
Runtime: ~15s
"""
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

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")

ENTRY_T  = 0.020   # vel_div <= -ENTRY_T → LONG; exit vel_div >= +ENTRY_T
MAX_HOLD = 20      # safety cap in bars (20 bars = 20 min on 1m klines)

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

# Gate definitions: name → set of allowed UTC hours (None = all hours)
GATES = {
    'UNGATED':   None,
    'BEST3':     {9, 12, 18},
    'BEST5':     {8, 9, 12, 13, 18},
    'WORST5':    {1, 2, 3, 4, 5},
    'US_SESS':   {13, 14, 15, 16, 17, 18, 19, 20, 21},
    'EU_SESS':   {7, 8, 9, 10, 11, 12},
    'ASIA_SESS': {0, 1, 2, 3, 4, 5, 6, 7},
}
# Add individual hours
for h in range(24):
    GATES[f'H{h:02d}'] = {h}

# stats[(gate, year)] = {wins, losses, gw, gl, n_trades, total_hold}
stats = defaultdict(lambda: {'wins': 0, 'losses': 0, 'gw': 0.0, 'gl': 0.0, 'n': 0, 'total_hold': 0})

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"Entry T: vel_div <= -{ENTRY_T}  Exit: vel_div >= +{ENTRY_T}")
print(f"MaxHold: {MAX_HOLD} bars")
print(f"Gates:   {len(GATES)}")
print()

TP_PCT  = 0.0095   # 95 bps TP (directional cap for crossover)
# Note: crossover exits by signal return; TP here acts as hard cap to avoid runaway losers
# Set TP_PCT = None to disable hard TP

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 or 'timestamp' not in df.columns:
        continue

    vd   = df['vel_div'].values.astype(np.float64)
    btc  = df['BTCUSDT'].values.astype(np.float64)
    hrs  = df['timestamp'].dt.hour.values.astype(np.int8)

    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 + 5:
        del vd, btc, hrs
        continue

    # Build trades: iterate entry bars
    # Entry: vel_div[t] <= -ENTRY_T
    # Exit:  first bar t+1..t+MAX_HOLD where vel_div >= +ENTRY_T, else t+MAX_HOLD
    entry_mask = (vd <= -ENTRY_T) & np.isfinite(btc)

    # Precompute exit bars vectorised
    # For each entry bar i, scan forward up to MAX_HOLD bars for crossover
    # Use a vectorised approach: build a boolean array of "crossover" events
    cross_back = (vd >= ENTRY_T)  # True where vel_div has returned to +ENTRY_T

    # We'll build trade outcomes as lists per gate
    # trade: (hour_of_entry, year, ret, hold_bars)
    trades = []   # list of (entry_hour, ret, hold_bars)

    for t in range(n - MAX_HOLD):
        if not entry_mask[t]:
            continue
        ep = btc[t]
        if not np.isfinite(ep) or ep <= 0:
            continue
        h = int(hrs[t])

        # Find exit bar
        exit_bar = MAX_HOLD  # default: max hold
        for k in range(1, MAX_HOLD + 1):
            tb = t + k
            if tb >= n:
                exit_bar = k
                break
            # Crossover exit
            if cross_back[tb]:
                exit_bar = k
                break

        xp = btc[t + exit_bar] if (t + exit_bar) < n else np.nan
        if not np.isfinite(xp) or xp <= 0:
            continue

        ret = (xp - ep) / ep   # LONG return
        trades.append((h, ret, exit_bar))

    if not trades:
        del vd, btc, hrs, cross_back, entry_mask
        continue

    hours_arr = np.array([tr[0] for tr in trades], dtype=np.int8)
    rets_arr  = np.array([tr[1] for tr in trades], dtype=np.float64)
    holds_arr = np.array([tr[2] for tr in trades], dtype=np.int16)

    for gate_name, hour_set in GATES.items():
        if hour_set is None:
            mask = np.ones(len(trades), dtype=bool)
        else:
            mask = np.isin(hours_arr, list(hour_set))

        if not np.any(mask):
            continue

        r = rets_arr[mask]
        h_bars = holds_arr[mask]

        # TP cap: if ret > TP_PCT, cap to TP_PCT (trade hit TP before crossover)
        # This is directional cap — in crossover mode usually not hit
        if TP_PCT is not None:
            r = np.clip(r, -np.inf, TP_PCT)

        wins_mask  = r >= 0
        losses_mask = r < 0

        w  = int(np.sum(wins_mask))
        l  = int(np.sum(losses_mask))
        gw = float(np.sum(r[wins_mask]))
        gl = float(np.sum(np.abs(r[losses_mask])))

        s = stats[(gate_name, year)]
        s['wins']       += w
        s['losses']     += l
        s['gw']         += gw
        s['gl']         += gl
        s['n']          += w + l
        s['total_hold'] += int(np.sum(h_bars))

    del vd, btc, hrs, cross_back, entry_mask, trades
    del hours_arr, rets_arr, holds_arr

    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")

# ─── Build results table ───────────────────────────────────────────────────────
rows = []
for gate_name, hour_set in GATES.items():
    yr_pfs = {}
    tot_w = tot_l = 0; tot_gw = tot_gl = 0; tot_n = 0; tot_hold = 0
    for yr in YEARS:
        s = stats.get((gate_name, yr), {'wins': 0, 'losses': 0, 'gw': 0.0, 'gl': 0.0, 'n': 0, 'total_hold': 0})
        yr_pfs[yr] = s
        tot_w    += s['wins'];   tot_l    += s['losses']
        tot_gw   += s['gw'];     tot_gl   += s['gl']
        tot_n    += s['n'];      tot_hold += s['total_hold']

    if tot_n == 0:
        continue

    pf       = tot_gw / tot_gl if tot_gl > 0 else (999.0 if tot_gw > 0 else float('nan'))
    wr       = tot_w / tot_n * 100 if tot_n > 0 else 0.0
    avg_hold = tot_hold / tot_n if tot_n > 0 else 0.0
    n_hrs    = len(hour_set) if hour_set else 24

    row = {
        'gate': gate_name,
        'n_hours': n_hrs,
        'n_trades': tot_n,
        'pf': round(pf, 4),
        'wr': round(wr, 3),
        'avg_hold_bars': round(avg_hold, 2),
        'gross_win': round(tot_gw, 4),
        'gross_loss': round(tot_gl, 4),
    }
    for yr in YEARS:
        s = yr_pfs[yr]
        yn = s['wins'] + s['losses']
        ypf = s['gw'] / s['gl'] if s['gl'] > 0 else (999.0 if s['gw'] > 0 else float('nan'))
        row[f'pf_{yr}'] = round(ypf, 4) if yn > 0 else float('nan')
        row[f'n_{yr}']  = yn
    rows.append(row)

# Sort by PF descending
rows.sort(key=lambda r: r['pf'], reverse=True)

# ─── Console output ────────────────────────────────────────────────────────────
NAMED_GATES = ['UNGATED', 'BEST3', 'BEST5', 'WORST5', 'US_SESS', 'EU_SESS', 'ASIA_SESS']

print(f"{'Gate':<14}  {'Hrs':>3}  {'N':>10}  {'PF':>7}  {'WR%':>6}  {'AvgH':>5}  "
      + "  ".join(yr for yr in YEARS))
print("-" * 100)

for row in rows:
    if row['gate'] not in NAMED_GATES and not row['gate'].startswith('H'):
        continue
    yr_str = "  ".join(f"{row.get(f'pf_{yr}', float('nan')):>7.3f}" for yr in YEARS)
    print(f"{row['gate']:<14}  {row['n_hours']:>3}  {row['n_trades']:>10,}  "
          f"{row['pf']:>7.4f}  {row['wr']:>6.2f}%  {row['avg_hold_bars']:>5.2f}  {yr_str}")

print()
print("─── Individual hours (sorted by PF) ───")
h_rows = [r for r in rows if r['gate'].startswith('H')]
h_rows.sort(key=lambda r: r['pf'], reverse=True)
print(f"{'Hour':>5}  {'N':>8}  {'PF':>7}  {'WR%':>6}  {'AvgH':>5}  "
      + "  ".join(yr for yr in YEARS))
print("-" * 95)
for row in h_rows:
    yr_str = "  ".join(f"{row.get(f'pf_{yr}', float('nan')):>7.3f}" for yr in YEARS)
    h_num = int(row['gate'][1:])
    print(f"  {h_num:>3}h  {row['n_trades']:>8,}  {row['pf']:>7.4f}  {row['wr']:>6.2f}%  "
          f"{row['avg_hold_bars']:>5.2f}  {yr_str}")

# ─── Save CSV ──────────────────────────────────────────────────────────────────
LOG_DIR.mkdir(exist_ok=True)
ts_str = datetime.now().strftime("%Y%m%d_%H%M%S")

out_csv = LOG_DIR / f"hour_gated_long_{ts_str}.csv"
if rows:
    with open(out_csv, 'w', newline='') as f:
        w = csv.DictWriter(f, fieldnames=rows[0].keys())
        w.writeheader(); w.writerows(rows)
    print(f"\n  → {out_csv}")

# Top summary txt
out_txt = LOG_DIR / f"hour_gated_long_top_{ts_str}.txt"
with open(out_txt, 'w', encoding='utf-8') as f:
    f.write(f"Hour-Gated LONG Crossover — 5y Klines\n")
    f.write(f"Entry: vel_div <= -{ENTRY_T}  Exit: vel_div >= +{ENTRY_T}  MaxHold: {MAX_HOLD}b\n")
    f.write(f"Runtime: {elapsed:.0f}s\n\n")
    f.write(f"{'Gate':<14}  {'Hrs':>3}  {'N':>10}  {'PF':>7}  {'WR%':>6}  {'AvgH':>5}  "
            + "  ".join(yr for yr in YEARS) + "\n")
    f.write("-" * 100 + "\n")
    for row in rows:
        yr_str = "  ".join(f"{row.get(f'pf_{yr}', float('nan')):>7.3f}" for yr in YEARS)
        f.write(f"{row['gate']:<14}  {row['n_hours']:>3}  {row['n_trades']:>10,}  "
                f"{row['pf']:>7.4f}  {row['wr']:>6.2f}%  {row['avg_hold_bars']:>5.2f}  {yr_str}\n")

print(f"  → {out_txt}")
print(f"\n  Runtime: {elapsed:.0f}s")
print(f"\n  KEY: Look for individual hours + BEST3/BEST5 PF vs UNGATED.")
print(f"       Consistent PF > 1.02 across years = real hour-of-day effect.")