"""
Exp 2 — proxy_B as premature exit signal, with shadow trades.

Post-hoc "what-if" analysis on the baseline trade set.
  1. Run baseline engine; log per-day proxy_B and per-asset prices keyed by
     (date_str, bar_idx) — the composite key that matches trade.entry_bar.
  2. For each trade: find which day it was on (tracked by engine override),
     then check if proxy_B dropped below threshold during the hold.
  3. Compute early-exit PnL at the trigger bar using the CORRECT asset price.
  4. Compare vs actual PnL.

Shadow insight: avg_pnl_delta = early_exit_pnl - actual_pnl
  Positive → early exit would have been better
  Negative → holding to natural exit was better (proxy_B is NOT a useful exit signal)

Thresholds tested (rolling percentile of proxy_B, window=500):
  T1: exit if proxy_B < p10  (rare trigger)
  T2: exit if proxy_B < p25  (moderate)
  T3: exit if proxy_B < p50  (aggressive)

Logged to exp2_proxy_exit_results.json.
"""
import sys, time, json
sys.stdout.reconfigure(encoding='utf-8', errors='replace')
from pathlib import Path
import numpy as np

_HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(_HERE.parent))

from exp_shared import (
    ensure_jit, ENGINE_KWARGS, GOLD, load_data, load_forewarner, log_results
)
from nautilus_dolphin.nautilus.esf_alpha_orchestrator import NDAlphaEngine
from nautilus_dolphin.nautilus.adaptive_circuit_breaker import AdaptiveCircuitBreaker


# ── Engine that logs per-day proxy_B + asset prices + trade dates ─────────────

class ShadowLoggingEngine(NDAlphaEngine):
    """
    NDAlphaEngine that captures:
      - day_proxy[date][ri] = proxy_b value
      - day_prices[date][ri][asset] = price
      - trade_dates[trade_idx] = date_str of entry
    """
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.day_proxy  = {}   # date_str → {ri: proxy_b}
        self.day_prices = {}   # date_str → {ri: {asset: price}}
        self._cur_date  = None
        self._n_trades_before = 0
        self.trade_dates = []  # parallel list to trade_history, entry date per trade

    def process_day(self, date_str, df, asset_columns,
                    vol_regime_ok=None, direction=None, posture='APEX'):
        self._cur_date = date_str
        self.day_proxy[date_str]  = {}
        self.day_prices[date_str] = {}
        self._n_trades_before = len(self.trade_history)

        self.begin_day(date_str, posture=posture, direction=direction)
        bid = 0
        for ri in range(len(df)):
            row = df.iloc[ri]
            vd = row.get('vel_div')
            if vd is None or not np.isfinite(float(vd)):
                self._global_bar_idx += 1; bid += 1; continue

            def gf(col):
                v = row.get(col)
                if v is None: return 0.0
                try: f = float(v); return f if np.isfinite(f) else 0.0
                except: return 0.0

            v50  = gf('v50_lambda_max_velocity')
            v750 = gf('v750_lambda_max_velocity')
            inst = gf('instability_50')
            pb   = inst - v750
            self.day_proxy[date_str][ri] = pb

            prices = {}
            for ac in asset_columns:
                p = row.get(ac)
                if p is not None and p > 0 and np.isfinite(p):
                    prices[ac] = float(p)
            self.day_prices[date_str][ri] = dict(prices)

            if not prices:
                self._global_bar_idx += 1; bid += 1; continue

            vrok = bool(vol_regime_ok[ri]) if vol_regime_ok is not None else (bid >= 100)
            self.step_bar(bar_idx=ri, vel_div=float(vd), prices=prices,
                          vol_regime_ok=vrok, v50_vel=v50, v750_vel=v750)
            bid += 1

        result = self.end_day()

        # Tag new trades with this date
        new_trades = self.trade_history[self._n_trades_before:]
        for _ in new_trades:
            self.trade_dates.append(date_str)

        return result


# ── Shadow analysis ───────────────────────────────────────────────────────────

def shadow_analysis(eng, threshold_pct, window=500):
    """
    For each trade, check if proxy_B dropped below rolling threshold
    during hold period (same-day bars between entry_bar and exit_bar).
    Uses the correct asset price for PnL computation.
    """
    tr    = eng.trade_history
    dates = eng.trade_dates

    if len(dates) < len(tr):
        # Pad if any trades weren't tagged (shouldn't happen)
        dates = dates + [None] * (len(tr) - len(dates))

    # Build rolling proxy_B history across all days (chronological)
    # We need a global chronological sequence for percentile computation
    all_proxy_seq = []
    for pf_stem in sorted(eng.day_proxy.keys()):
        day_d = eng.day_proxy[pf_stem]
        for ri in sorted(day_d.keys()):
            all_proxy_seq.append((pf_stem, ri, day_d[ri]))

    results = []
    proxy_hist = []  # rolling window of ALL bars seen so far

    # Build per-day sorted bar sequences for efficient lookup
    day_bars = {d: sorted(eng.day_proxy[d].keys()) for d in eng.day_proxy}

    # Build lookup: (date, ri) → index in all_proxy_seq (for rolling history)
    seq_idx = {(s, r): i for i, (s, r, _) in enumerate(all_proxy_seq)}

    for t, date in zip(tr, dates):
        if date is None:
            results.append(dict(triggered=False, actual_pnl=t.pnl_pct))
            continue

        entry_bar = int(t.entry_bar) if hasattr(t, 'entry_bar') else 0
        exit_bar  = int(t.exit_bar)  if hasattr(t, 'exit_bar')  else entry_bar
        actual_pnl = float(t.pnl_pct) if hasattr(t, 'pnl_pct') else 0.0
        entry_price = float(t.entry_price) if hasattr(t, 'entry_price') and t.entry_price else 0.0
        direction   = int(t.direction)   if hasattr(t, 'direction')   else -1
        asset       = t.asset            if hasattr(t, 'asset')        else 'BTCUSDT'

        # Rolling threshold: use all bars BEFORE entry on this day
        eidx = seq_idx.get((date, entry_bar), 0)
        hist_window = [pb for (_, _, pb) in all_proxy_seq[max(0, eidx-window):eidx]]
        if len(hist_window) < 20:
            results.append(dict(triggered=False, actual_pnl=actual_pnl)); continue
        threshold = float(np.percentile(hist_window, threshold_pct * 100))

        # Find hold bars on the same day
        if date not in day_bars:
            results.append(dict(triggered=False, actual_pnl=actual_pnl)); continue
        hold_bars = [ri for ri in day_bars[date]
                     if entry_bar < ri <= exit_bar]

        triggered_bar = None
        for ri in hold_bars:
            if eng.day_proxy[date].get(ri, 999) < threshold:
                triggered_bar = ri
                break

        if triggered_bar is None:
            results.append(dict(triggered=False, actual_pnl=actual_pnl)); continue

        # Correct early-exit price: same asset, triggered bar on same day
        early_price = eng.day_prices[date].get(triggered_bar, {}).get(asset, 0.0)
        if entry_price > 0 and early_price > 0:
            early_pnl = direction * (early_price - entry_price) / entry_price
        else:
            results.append(dict(triggered=False, actual_pnl=actual_pnl)); continue

        bars_saved = exit_bar - triggered_bar
        results.append(dict(
            triggered=True,
            date=date, entry_bar=entry_bar, exit_bar=exit_bar,
            triggered_bar=triggered_bar, bars_saved=bars_saved,
            asset=asset, direction=direction,
            entry_price=entry_price, early_price=early_price,
            actual_pnl=actual_pnl,
            early_exit_pnl=early_pnl,
            pnl_delta=early_pnl - actual_pnl,
        ))

    triggered = [r for r in results if r['triggered']]
    if not triggered:
        return dict(n_triggered=0, n_total=len(results), pct_triggered=0,
                    avg_actual_pnl_pct=0, avg_early_pnl_pct=0, avg_delta_pct=0,
                    early_better_rate=0, roi_impact_pp=0)

    avg_actual = float(np.mean([r['actual_pnl']   for r in triggered]))
    avg_early  = float(np.mean([r['early_exit_pnl'] for r in triggered]))
    avg_delta  = float(np.mean([r['pnl_delta']    for r in triggered]))
    early_better = float(np.mean([r['pnl_delta'] > 0 for r in triggered]))
    avg_bars_saved = float(np.mean([r['bars_saved'] for r in triggered]))

    # Estimated ROI impact (sum of pnl deltas × fraction × 100)
    roi_impact = float(sum(r['pnl_delta'] for r in triggered) * 0.20 * 100)

    # Per-exit-reason breakdown if available
    return dict(
        n_triggered=len(triggered),
        n_total=len(results),
        pct_triggered=len(triggered) / max(1, len(results)) * 100,
        avg_actual_pnl_pct=avg_actual * 100,
        avg_early_exit_pnl_pct=avg_early * 100,
        avg_pnl_delta_pct=avg_delta * 100,
        early_better_rate=early_better * 100,
        avg_bars_saved=avg_bars_saved,
        roi_impact_estimate_pp=roi_impact,
    )


def main():
    ensure_jit()
    print("\nLoading data & forewarner...")
    d  = load_data()
    fw = load_forewarner()

    from exp_shared import ENGINE_KWARGS, MC_BASE_CFG
    import math

    print("\nRunning baseline with shadow logging...")
    t0 = time.time()
    kw  = ENGINE_KWARGS.copy()
    acb = AdaptiveCircuitBreaker()
    acb.preload_w750(d['date_strings'])
    eng = ShadowLoggingEngine(**kw)
    eng.set_ob_engine(d['ob_eng'])
    eng.set_acb(acb)
    if fw: eng.set_mc_forewarner(fw, MC_BASE_CFG)
    eng.set_esoteric_hazard_multiplier(0.0)

    daily_caps, daily_pnls = [], []
    for pf in d['parquet_files']:
        ds = pf.stem
        df, acols, dvol = d['pq_data'][ds]
        cap_before = eng.capital
        vol_ok = np.where(np.isfinite(dvol), dvol > d['vol_p60'], False)
        eng.process_day(ds, df, acols, vol_regime_ok=vol_ok)
        daily_caps.append(eng.capital)
        daily_pnls.append(eng.capital - cap_before)

    tr = eng.trade_history
    print(f"  Done in {time.time()-t0:.0f}s  Trades={len(tr)}  "
          f"Tagged={len(eng.trade_dates)}")

    # Confirm baseline metrics match gold
    def _abs(t): return t.pnl_absolute if hasattr(t,'pnl_absolute') else t.pnl_pct*250.
    wins = [t for t in tr if _abs(t) > 0]
    pf   = sum(_abs(t) for t in wins) / max(abs(sum(_abs(t) for t in [x for x in tr if _abs(x)<=0])),1e-9)
    roi  = (eng.capital - 25000) / 25000 * 100
    print(f"  Baseline: ROI={roi:.2f}%  PF={pf:.4f}  (gold: 88.55% / 1.215)")

    THRESHOLDS = [
        ('T1: exit if proxy_B < p10', 0.10),
        ('T2: exit if proxy_B < p25', 0.25),
        ('T3: exit if proxy_B < p50', 0.50),
    ]

    all_results = []
    for tname, tpct in THRESHOLDS:
        print(f"\n{tname}")
        res = shadow_analysis(eng, threshold_pct=tpct, window=500)
        res['name'] = tname
        all_results.append(res)
        print(f"  Triggered: {res['n_triggered']}/{res['n_total']} "
              f"({res['pct_triggered']:.1f}%)")
        if res['n_triggered'] > 0:
            print(f"  Avg actual PnL:     {res['avg_actual_pnl_pct']:+.4f}%")
            print(f"  Avg early-exit PnL: {res['avg_early_exit_pnl_pct']:+.4f}%")
            print(f"  Avg delta:          {res['avg_pnl_delta_pct']:+.4f}%  "
                  f"(+ = early exit BETTER)")
            print(f"  Early exit better:  {res['early_better_rate']:.1f}% of triggered")
            print(f"  Avg bars saved:     {res['avg_bars_saved']:.1f}")
            print(f"  Est. ROI impact:    {res['roi_impact_estimate_pp']:+.2f}pp")

    print("\n" + "="*75)
    print("EXP 2 — SHADOW EXIT SUMMARY")
    print("="*75)
    print(f"{'Threshold':<35} {'Trig%':>6} {'AvgDelta%':>11} "
          f"{'EarlyBetter%':>13} {'ROI_pp':>8}")
    print('-'*75)
    for r in all_results:
        if r['n_triggered'] > 0:
            print(f"  {r['name']:<33} {r['pct_triggered']:>6.1f}% "
                  f"{r['avg_pnl_delta_pct']:>10.4f}% "
                  f"{r['early_better_rate']:>12.1f}% "
                  f"{r['roi_impact_estimate_pp']:>8.2f}pp")
        else:
            print(f"  {r['name']:<33}  (no triggers)")

    verdict = all_results[0] if all_results else {}
    if verdict.get('avg_pnl_delta_pct', -1) > 0:
        print("\n  → VERDICT: Early exit is BENEFICIAL (delta > 0)")
    else:
        print("\n  → VERDICT: Holding to natural exit is BETTER (early exit hurts)")

    log_results(all_results, _HERE / 'exp2_proxy_exit_results.json',
                meta={'experiment': 'proxy_B exit shadow (corrected)',
                      'proxy': 'instability_50 - v750_lambda_max_velocity',
                      'n_trades': len(tr),
                      'baseline_roi': roi, 'baseline_pf': pf})


if __name__ == '__main__':
    main()