"""OB Intelligence — 4-Subsystem Test Suite.

Phase 1: Data validation (CSVOBProvider)
Phase 2: Feature computation (all 4 sub-systems)
Phase 3: Signal quality (forward return correlation)
Phase 4: Per-asset placement quality
Phase 5: Market-wide detection
Phase 6: Macro regime detection
Phase 7: Engine integration (no regression vs baseline)
"""
import sys, time, math
from pathlib import Path
import numpy as np
import pandas as pd

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

OB_DATA_DIR = Path(r"C:\Users\Lenovo\Documents\- DOLPHIN NG HD HCM TSF Predict\ob_data")
VBT_DIR = Path(r"C:\Users\Lenovo\Documents\- DOLPHIN NG HD HCM TSF Predict\vbt_cache")

# ============================================================================
# Phase 0: Compile numba kernels
# ============================================================================
print("=" * 70)
print("  OB INTELLIGENCE 4-SUBSYSTEM TEST SUITE")
print("=" * 70)
print("\nPhase 0: Compiling numba kernels...")
t0c = time.time()

from nautilus_dolphin.nautilus.alpha_asset_selector import compute_irp_nb, compute_ars_nb, rank_assets_irp_nb
from nautilus_dolphin.nautilus.alpha_bet_sizer import compute_sizing_nb
from nautilus_dolphin.nautilus.alpha_signal_generator import check_dc_nb
from nautilus_dolphin.nautilus.ob_features import (
    compute_imbalance_nb, compute_depth_1pct_nb, compute_depth_quality_nb,
    compute_fill_probability_nb, compute_spread_proxy_nb, compute_depth_asymmetry_nb,
    compute_imbalance_persistence_nb, compute_withdrawal_velocity_nb,
    compute_market_agreement_nb, compute_cascade_signal_nb,
    OBPlacementFeatures, OBSignalFeatures, OBMarketFeatures, OBMacroFeatures,
    NEUTRAL_PLACEMENT, NEUTRAL_SIGNAL, NEUTRAL_MARKET, NEUTRAL_MACRO,
    OBFeatureEngine,
)
from nautilus_dolphin.nautilus.ob_provider import CSVOBProvider, MockOBProvider
from nautilus_dolphin.nautilus.ob_placer import OBPlacer

# Warmup JIT
_p = np.array([1.0, 2.0, 3.0], dtype=np.float64)
compute_irp_nb(_p, -1); compute_ars_nb(1.0, 0.5, 0.01)
rank_assets_irp_nb(np.ones((10, 2), dtype=np.float64), 8, -1, 5, 500.0, 20, 0.20)
compute_sizing_nb(-0.03, -0.02, -0.05, 3.0, 0.5, 5.0, 0.20, True, True, 0.0,
                  np.zeros(4, dtype=np.int64), np.zeros(4, dtype=np.int64),
                  np.zeros(5, dtype=np.float64), 0, -1, 0.01, 0.04)
check_dc_nb(_p, 3, 1, 0.75)

# Warmup OB kernels
_b = np.array([100.0, 200.0, 300.0, 400.0, 500.0], dtype=np.float64)
_a = np.array([110.0, 190.0, 310.0, 390.0, 510.0], dtype=np.float64)
compute_imbalance_nb(_b, _a)
compute_depth_1pct_nb(_b, _a)
compute_depth_quality_nb(210.0, 200.0)
compute_fill_probability_nb(1.0)
compute_spread_proxy_nb(_b, _a)
compute_depth_asymmetry_nb(_b, _a)
compute_imbalance_persistence_nb(np.array([0.1, -0.1, 0.2, 0.3], dtype=np.float64), 4)
compute_withdrawal_velocity_nb(np.array([100.0, 110.0, 105.0], dtype=np.float64), 2)
compute_market_agreement_nb(np.array([0.1, -0.05, 0.2, 0.15], dtype=np.float64), 4)
compute_cascade_signal_nb(np.array([-0.05, -0.15, 0.02, -0.12], dtype=np.float64), 4, -0.10)

print(f"  JIT compile: {time.time() - t0c:.1f}s")

from nautilus_dolphin.nautilus.alpha_orchestrator import NDAlphaEngine
from nautilus_dolphin.nautilus.adaptive_circuit_breaker import AdaptiveCircuitBreaker


# ============================================================================
# Phase 1: Data Validation
# ============================================================================
print(f"\n{'='*70}")
print("  PHASE 1: DATA VALIDATION (CSVOBProvider)")
print(f"{'='*70}")

csv_provider = CSVOBProvider(str(OB_DATA_DIR))
csv_assets = csv_provider.get_assets()
print(f"\n  Available assets: {csv_assets}")

phase1_ok = True
for asset in csv_assets:
    ts = csv_provider.get_all_timestamps(asset)
    n = len(ts)
    snap0 = csv_provider.get_snapshot(asset, ts[0]) if n > 0 else None
    snap_last = csv_provider.get_snapshot(asset, ts[-1]) if n > 0 else None

    # Check integrity
    nan_count = 0
    neg_count = 0
    for i in range(min(n, 100)):  # Sample first 100
        s = csv_provider.get_snapshot(asset, ts[i])
        if s is None:
            continue
        if np.any(np.isnan(s.bid_notional)) or np.any(np.isnan(s.ask_notional)):
            nan_count += 1
        if np.any(s.bid_notional < 0) or np.any(s.ask_notional < 0):
            neg_count += 1

    t_range = (ts[-1] - ts[0]) / 3600 if n > 1 else 0
    print(f"\n  {asset}:")
    print(f"    Snapshots:  {n}")
    print(f"    Time range: {t_range:.1f} hours")
    if snap0:
        print(f"    Bid depth (1%): ${snap0.bid_notional[0]:,.0f}")
        print(f"    Ask depth (1%): ${snap0.ask_notional[0]:,.0f}")
        print(f"    Total 5-level:  ${sum(snap0.bid_notional) + sum(snap0.ask_notional):,.0f}")
    if nan_count > 0:
        print(f"    WARNING: {nan_count} snapshots with NaN")
        phase1_ok = False
    if neg_count > 0:
        print(f"    WARNING: {neg_count} snapshots with negative notional")
        phase1_ok = False
    if n == 0:
        print(f"    WARNING: No data")
        phase1_ok = False

print(f"\n  Phase 1: {'PASS' if phase1_ok else 'FAIL'}")


# ============================================================================
# Phase 2: Feature Computation (All 4 Sub-systems)
# ============================================================================
print(f"\n{'='*70}")
print("  PHASE 2: FEATURE COMPUTATION (4 SUB-SYSTEMS)")
print(f"{'='*70}")

t2 = time.time()
# Use CSVOBProvider for real data feature computation
ob_engine_csv = OBFeatureEngine(csv_provider)
if csv_assets:
    ob_engine_csv.preload_date("2025-01-15", csv_assets)
    print(f"\n  Preload time: {time.time() - t2:.2f}s")

phase2_ok = True
for asset in csv_assets:
    n = csv_provider.get_snapshot_count(asset)
    if n == 0:
        continue

    # Collect features across all snapshots
    imbalances = []
    imbalances_ma5 = []
    persistences = []
    depth_qualities = []
    fill_probs = []
    spreads = []

    for snap_idx in range(n):
        p = ob_engine_csv._preloaded_placement.get(asset, {}).get(snap_idx)
        s = ob_engine_csv._preloaded_signal.get(asset, {}).get(snap_idx)
        if p:
            depth_qualities.append(p.depth_quality)
            fill_probs.append(p.fill_probability)
            spreads.append(p.spread_proxy_bps)
        if s:
            imbalances.append(s.imbalance)
            imbalances_ma5.append(s.imbalance_ma5)
            persistences.append(s.imbalance_persistence)

    print(f"\n  {asset} Feature Distributions:")
    if imbalances:
        imb = np.array(imbalances)
        print(f"    Sub-2 Imbalance:   mean={np.mean(imb):.4f}  std={np.std(imb):.4f}  "
              f"p5={np.percentile(imb,5):.4f}  p50={np.percentile(imb,50):.4f}  p95={np.percentile(imb,95):.4f}")
        # Validate ranges
        if np.min(imb) < -1.0 or np.max(imb) > 1.0:
            print(f"    FAIL: imbalance out of [-1, 1]")
            phase2_ok = False
    if persistences:
        per = np.array(persistences)
        print(f"    Sub-2 Persistence: mean={np.mean(per):.4f}  std={np.std(per):.4f}  "
              f"p5={np.percentile(per,5):.4f}  p50={np.percentile(per,50):.4f}  p95={np.percentile(per,95):.4f}")
        if np.min(per) < 0 or np.max(per) > 1.0:
            print(f"    FAIL: persistence out of [0, 1]")
            phase2_ok = False
    if depth_qualities:
        dq = np.array(depth_qualities)
        print(f"    Sub-1 DepthQual:   mean={np.mean(dq):.4f}  std={np.std(dq):.4f}  "
              f"p5={np.percentile(dq,5):.4f}  p50={np.percentile(dq,50):.4f}  p95={np.percentile(dq,95):.4f}")
        if np.min(dq) < 0:
            print(f"    FAIL: depth_quality < 0")
            phase2_ok = False
    if fill_probs:
        fp = np.array(fill_probs)
        print(f"    Sub-1 FillProb:    mean={np.mean(fp):.4f}  std={np.std(fp):.4f}  "
              f"p5={np.percentile(fp,5):.4f}  p50={np.percentile(fp,50):.4f}  p95={np.percentile(fp,95):.4f}")
        if np.min(fp) < 0 or np.max(fp) > 1.0:
            print(f"    FAIL: fill_probability out of [0, 1]")
            phase2_ok = False

# Market-wide features (Sub-3)
print(f"\n  Sub-3 Market-Wide Features:")
mkt_med_imb = []
mkt_agree = []
n_ref = csv_provider.get_snapshot_count(csv_assets[0]) if csv_assets else 0
for snap_idx in range(n_ref):
    m = ob_engine_csv._preloaded_market.get(snap_idx)
    if m:
        mkt_med_imb.append(m.median_imbalance)
        mkt_agree.append(m.agreement_pct)

if mkt_med_imb:
    mi = np.array(mkt_med_imb)
    ag = np.array(mkt_agree)
    print(f"    Median imbalance: mean={np.mean(mi):.4f}  std={np.std(mi):.4f}")
    print(f"    Agreement pct:    mean={np.mean(ag):.4f}  std={np.std(ag):.4f}  "
          f"p5={np.percentile(ag,5):.4f}  p95={np.percentile(ag,95):.4f}")
    high_agree = np.sum(ag > 0.8) / len(ag) * 100
    print(f"    Snapshots with agreement > 0.8: {high_agree:.1f}%")
    if np.min(ag) < 0 or np.max(ag) > 1.0:
        print(f"    FAIL: agreement out of [0, 1]")
        phase2_ok = False

# Sub-4 Macro
macro = ob_engine_csv.get_macro()
print(f"\n  Sub-4 Macro Regime (final state):")
print(f"    Depth velocity:  {macro.depth_velocity:.4f}")
print(f"    Cascade count:   {macro.cascade_count}")
print(f"    Acceleration:    {macro.acceleration:.6f}")
print(f"    Regime signal:   {macro.regime_signal} ({['CALM','NEUTRAL','STRESS'][macro.regime_signal + 1]})")

print(f"\n  Phase 2: {'PASS' if phase2_ok else 'FAIL'}")


# ============================================================================
# Phase 3: Signal Quality (OB Feature Correlation with Itself)
# ============================================================================
print(f"\n{'='*70}")
print("  PHASE 3: OB FEATURE INTERNAL CONSISTENCY")
print(f"{'='*70}")

# Check that imbalance and imbalance_ma5 are correlated (sanity check)
if csv_assets:
    asset = csv_assets[0]
    n = csv_provider.get_snapshot_count(asset)
    raw_imb = []
    ma5_imb = []
    for snap_idx in range(n):
        s = ob_engine_csv._preloaded_signal.get(asset, {}).get(snap_idx)
        if s:
            raw_imb.append(s.imbalance)
            ma5_imb.append(s.imbalance_ma5)
    if len(raw_imb) > 10:
        from scipy import stats
        corr, pval = stats.spearmanr(raw_imb, ma5_imb)
        print(f"\n  {asset}: imbalance vs imbalance_ma5 Spearman r={corr:.4f} (p={pval:.2e})")
        if corr < 0.5:
            print(f"    WARNING: Low correlation between raw and smoothed imbalance")

    # Check fill_prob vs depth_quality monotonicity
    dqs = []
    fps = []
    for snap_idx in range(n):
        p = ob_engine_csv._preloaded_placement.get(asset, {}).get(snap_idx)
        if p:
            dqs.append(p.depth_quality)
            fps.append(p.fill_probability)
    if len(dqs) > 10:
        corr2, pval2 = stats.spearmanr(dqs, fps)
        print(f"  {asset}: depth_quality vs fill_prob Spearman r={corr2:.4f} (p={pval2:.2e})")
        if corr2 < 0.9:
            print(f"    WARNING: fill_prob should be monotonically related to depth_quality")

print(f"\n  Phase 3: PASS (informational)")


# ============================================================================
# Phase 4: Per-Asset Placement Quality
# ============================================================================
print(f"\n{'='*70}")
print("  PHASE 4: PER-ASSET PLACEMENT QUALITY")
print(f"{'='*70}")

for asset in csv_assets:
    n = csv_provider.get_snapshot_count(asset)
    if n == 0:
        continue
    dqs = [ob_engine_csv._preloaded_placement.get(asset, {}).get(i) for i in range(n)]
    dqs = [d for d in dqs if d is not None]
    mean_dq = np.mean([d.depth_quality for d in dqs])
    mean_fp = np.mean([d.fill_probability for d in dqs])
    mean_sp = np.mean([d.spread_proxy_bps for d in dqs])
    print(f"\n  {asset}:")
    print(f"    Mean depth quality:  {mean_dq:.3f}")
    print(f"    Mean fill prob:      {mean_fp:.3f}")
    print(f"    Mean spread proxy:   {mean_sp:.3f} bps")

# SmartPlacer advice test
print(f"\n  SmartPlacer Advice (sample):")
placer = OBPlacer()
if csv_assets:
    asset = csv_assets[0]
    n = csv_provider.get_snapshot_count(asset)
    mid = n // 2
    p = ob_engine_csv._preloaded_placement.get(asset, {}).get(mid, NEUTRAL_PLACEMENT)
    s = ob_engine_csv._preloaded_signal.get(asset, {}).get(mid, NEUTRAL_SIGNAL)
    for conf in [0.3, 0.5, 0.7, 0.9]:
        advice = placer.advise(p, s, signal_confidence=conf, direction=-1)
        print(f"    conf={conf:.1f}: {advice.method:15s} offset={advice.offset_bps:.2f}bps "
              f"timeout={advice.timeout_s:.0f}s reason={advice.reason}")

print(f"\n  Phase 4: PASS (informational)")


# ============================================================================
# Phase 5: Market-Wide Agreement Detection
# ============================================================================
print(f"\n{'='*70}")
print("  PHASE 5: MARKET-WIDE AGREEMENT DETECTION")
print(f"{'='*70}")

if mkt_agree:
    ag = np.array(mkt_agree)
    mi = np.array(mkt_med_imb)

    # Top 10 high-agreement moments
    sorted_idx = np.argsort(ag)[::-1]
    print(f"\n  Top 10 high-agreement snapshots:")
    for i in range(min(10, len(sorted_idx))):
        idx = sorted_idx[i]
        print(f"    snap {idx:5d}: agreement={ag[idx]:.3f}  median_imb={mi[idx]:+.4f}")

    # Distribution of agreement
    print(f"\n  Agreement distribution:")
    for thresh in [0.5, 0.6, 0.7, 0.8, 0.9, 1.0]:
        pct = np.sum(ag >= thresh) / len(ag) * 100
        print(f"    >= {thresh:.1f}: {pct:5.1f}%")

print(f"\n  Phase 5: PASS (informational)")


# ============================================================================
# Phase 6: Macro Regime Detection (Sub-4)
# ============================================================================
print(f"\n{'='*70}")
print("  PHASE 6: MACRO REGIME DETECTION")
print(f"{'='*70}")

# Trace macro features through time using the preloaded data
# We can examine the final macro state and trace snapshots for regime transitions
print(f"\n  Final macro state:")
print(f"    Depth velocity:  {macro.depth_velocity:+.4f}")
print(f"    Cascade count:   {macro.cascade_count}")
print(f"    Regime signal:   {macro.regime_signal}")

# Simulate macro tracking across snapshots using Mock
mock_stress = MockOBProvider(imbalance_bias=-0.3, depth_scale=0.3, assets=csv_assets[:4] or ["BTCUSDT", "ETHUSDT"])
mock_calm = MockOBProvider(imbalance_bias=0.1, depth_scale=2.0, assets=csv_assets[:4] or ["BTCUSDT", "ETHUSDT"])
mock_neutral = MockOBProvider(imbalance_bias=0.0, depth_scale=1.0, assets=csv_assets[:4] or ["BTCUSDT", "ETHUSDT"])

for label, provider in [("STRESS", mock_stress), ("CALM", mock_calm), ("NEUTRAL", mock_neutral)]:
    engine = OBFeatureEngine(provider)
    engine.preload_date("test", provider.get_assets())
    m = engine.get_macro()
    print(f"\n  Mock {label}: regime={m.regime_signal} velocity={m.depth_velocity:+.4f} cascade={m.cascade_count}")

print(f"\n  Phase 6: PASS (informational)")


# ============================================================================
# Phase 7: Engine Integration (No Regression)
# ============================================================================
print(f"\n{'='*70}")
print("  PHASE 7: ENGINE INTEGRATION (BASELINE REGRESSION CHECK)")
print(f"{'='*70}")

META_COLS = {'timestamp', 'scan_number', 'v50_lambda_max_velocity', 'v150_lambda_max_velocity',
             'v300_lambda_max_velocity', 'v750_lambda_max_velocity', 'vel_div',
             'instability_50', 'instability_150'}
ENGINE_KWARGS = dict(
    initial_capital=25000.0, vel_div_threshold=-0.02, vel_div_extreme=-0.05,
    min_leverage=0.5, max_leverage=5.0, leverage_convexity=3.0,
    fraction=0.20, fixed_tp_pct=0.0099, stop_pct=1.0, max_hold_bars=120,
    use_direction_confirm=True, dc_lookback_bars=7, dc_min_magnitude_bps=0.75,
    dc_skip_contradicts=True, dc_leverage_boost=1.0, dc_leverage_reduce=0.5,
    use_asset_selection=True, min_irp_alignment=0.45,
    use_sp_fees=True, use_sp_slippage=True,
    sp_maker_entry_rate=0.62, sp_maker_exit_rate=0.50,
    use_ob_edge=True, ob_edge_bps=5.0, ob_confirm_rate=0.40,
    lookback=100, use_alpha_layers=True, use_dynamic_leverage=True, seed=42,
)
VD_THRESH = -0.02; VD_EXTREME = -0.05; CONVEXITY = 3.0

parquet_files = sorted(VBT_DIR.glob("*.parquet"))
if not parquet_files:
    print("\n  WARNING: No parquet files in VBT_DIR, skipping Phase 7")
else:
    # Initialize ACB
    acb = AdaptiveCircuitBreaker()
    date_strings = [pf.stem for pf in parquet_files]
    acb.preload_w750(date_strings)

    # Pre-load data
    all_vols = []
    for pf in parquet_files[:2]:
        df = pd.read_parquet(pf)
        if 'BTCUSDT' not in df.columns: continue
        pr = df['BTCUSDT'].values
        for i in range(60, len(pr)):
            seg = pr[max(0,i-50):i]
            if len(seg)<10: continue
            v = float(np.std(np.diff(seg)/seg[:-1]))
            if v > 0: all_vols.append(v)
    vol_p60 = float(np.percentile(all_vols, 60)) if all_vols else 0.001

    pq_data = {}
    for pf in parquet_files:
        df = pd.read_parquet(pf)
        ac = [c for c in df.columns if c not in META_COLS]
        bp = df['BTCUSDT'].values if 'BTCUSDT' in df.columns else None
        dv = np.full(len(df), np.nan)
        if bp is not None:
            for i in range(50, len(bp)):
                seg = bp[max(0,i-50):i]
                if len(seg)<10: continue
                dv[i] = float(np.std(np.diff(seg)/seg[:-1]))
        pq_data[pf.stem] = (df, ac, dv)

    def strength_cubic(vel_div):
        if vel_div >= VD_THRESH: return 0.0
        raw = (VD_THRESH - vel_div) / (VD_THRESH - VD_EXTREME)
        return min(1.0, max(0.0, raw)) ** CONVEXITY

    def run_engine(label, ob_engine_instance=None):
        """Run full backtest with optional OB engine."""
        engine = NDAlphaEngine(**ENGINE_KWARGS)
        if ob_engine_instance is not None:
            engine.set_ob_engine(ob_engine_instance)

        bar_idx = 0; ph = {}; dstats = []
        for pf in parquet_files:
            ds = pf.stem; cs = engine.capital
            engine.regime_direction = -1
            engine.regime_dd_halt = False

            acb_info = acb.get_dynamic_boost_for_date(ds, ob_engine=ob_engine_instance)
            base_boost = acb_info['boost']
            beta = acb_info['beta']

            df, acols, dvol = pq_data[ds]
            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(vd): bar_idx+=1; bid+=1; continue
                prices = {}
                for ac in acols:
                    p = row[ac]
                    if p and p > 0 and np.isfinite(p):
                        prices[ac] = float(p)
                        if ac not in ph: ph[ac] = []
                        ph[ac].append(float(p))
                if not prices: bar_idx+=1; bid+=1; continue
                vrok = False if bid < 100 else (np.isfinite(dvol[ri]) and dvol[ri] > vol_p60)

                if beta > 0 and base_boost > 1.0:
                    ss = strength_cubic(float(vd))
                    engine.regime_size_mult = base_boost * (1.0 + beta * ss)
                else:
                    engine.regime_size_mult = base_boost

                engine.process_bar(bar_idx=bar_idx, vel_div=float(vd), prices=prices,
                                   vol_regime_ok=vrok, price_histories=ph)
                bar_idx+=1; bid+=1
            dstats.append({'date': ds, 'pnl': engine.capital - cs, 'cap': engine.capital, 'beta': beta})

        tr = engine.trade_history
        w = [t for t in tr if t.pnl_absolute > 0]; l = [t for t in tr if t.pnl_absolute <= 0]
        gw = sum(t.pnl_absolute for t in w) if w else 0
        gl = abs(sum(t.pnl_absolute for t in l)) if l else 0
        roi = (engine.capital - 25000) / 25000 * 100
        pf_val = gw / gl if gl > 0 else 999
        dr = [s['pnl']/25000*100 for s in dstats]
        sharpe = np.mean(dr) / np.std(dr) * np.sqrt(365) if np.std(dr) > 0 else 0
        peak_cap = 25000.0; max_dd = 0.0
        for s in dstats:
            peak_cap = max(peak_cap, s['cap'])
            dd = (peak_cap - s['cap']) / peak_cap * 100
            max_dd = max(max_dd, dd)

        return {
            'label': label, 'roi': roi, 'pf': pf_val, 'dd': max_dd,
            'sharpe': sharpe, 'trades': len(tr), 'capital': engine.capital,
        }

    # Run A: Baseline (ob_engine=None) — should match PF 1.215, ROI +75.87%
    print(f"\n  Running baseline (ob_engine=None)...")
    t7 = time.time()
    result_a = run_engine("A: Baseline (no OB)")
    t_a = time.time() - t7
    print(f"    {result_a['label']}: ROI={result_a['roi']:+.2f}%  PF={result_a['pf']:.3f}  "
          f"DD={result_a['dd']:.2f}%  Sharpe={result_a['sharpe']:.2f}  Trades={result_a['trades']}  [{t_a:.0f}s]")

    # Run B: Neutral MockOBProvider (should produce SAME results as baseline)
    print(f"  Running with neutral MockOBProvider...")
    mock_neutral_eng = OBFeatureEngine(MockOBProvider(imbalance_bias=0.0, depth_scale=1.0,
                                                       assets=["BTCUSDT", "ETHUSDT", "BNBUSDT", "SOLUSDT"]))
    mock_neutral_eng.preload_date("mock", mock_neutral_eng.provider.get_assets())
    t7b = time.time()
    result_b = run_engine("B: Neutral OB", mock_neutral_eng)
    t_b = time.time() - t7b
    print(f"    {result_b['label']}: ROI={result_b['roi']:+.2f}%  PF={result_b['pf']:.3f}  "
          f"DD={result_b['dd']:.2f}%  Sharpe={result_b['sharpe']:.2f}  Trades={result_b['trades']}  [{t_b:.0f}s]")

    # Run C: Favorable MockOBProvider (imbalance confirms SHORT)
    print(f"  Running with favorable MockOBProvider (SHORT-confirming)...")
    mock_fav = OBFeatureEngine(MockOBProvider(imbalance_bias=-0.3, depth_scale=1.5,
                                              assets=["BTCUSDT", "ETHUSDT", "BNBUSDT", "SOLUSDT"]))
    mock_fav.preload_date("mock", mock_fav.provider.get_assets())
    t7c = time.time()
    result_c = run_engine("C: Favorable OB", mock_fav)
    t_c = time.time() - t7c
    print(f"    {result_c['label']}: ROI={result_c['roi']:+.2f}%  PF={result_c['pf']:.3f}  "
          f"DD={result_c['dd']:.2f}%  Sharpe={result_c['sharpe']:.2f}  Trades={result_c['trades']}  [{t_c:.0f}s]")

    # Run D: Unfavorable MockOBProvider (imbalance contradicts SHORT)
    print(f"  Running with unfavorable MockOBProvider (SHORT-contradicting)...")
    mock_unfav = OBFeatureEngine(MockOBProvider(imbalance_bias=+0.3, depth_scale=0.5,
                                                assets=["BTCUSDT", "ETHUSDT", "BNBUSDT", "SOLUSDT"]))
    mock_unfav.preload_date("mock", mock_unfav.provider.get_assets())
    t7d = time.time()
    result_d = run_engine("D: Unfavorable OB", mock_unfav)
    t_d = time.time() - t7d
    print(f"    {result_d['label']}: ROI={result_d['roi']:+.2f}%  PF={result_d['pf']:.3f}  "
          f"DD={result_d['dd']:.2f}%  Sharpe={result_d['sharpe']:.2f}  Trades={result_d['trades']}  [{t_d:.0f}s]")

    # Verification
    print(f"\n  {'='*60}")
    print(f"  INTEGRATION VERIFICATION")
    print(f"  {'='*60}")

    all_ok = True

    # Check A matches baseline
    if abs(result_a['roi'] - 75.87) > 2.0:
        print(f"  FAIL: Baseline ROI {result_a['roi']:.2f}% vs expected ~75.87%")
        all_ok = False
    else:
        print(f"  PASS: Baseline ROI matches ({result_a['roi']:+.2f}%)")

    if abs(result_a['pf'] - 1.215) > 0.02:
        print(f"  FAIL: Baseline PF {result_a['pf']:.3f} vs expected ~1.215")
        all_ok = False
    else:
        print(f"  PASS: Baseline PF matches ({result_a['pf']:.3f})")

    # Check B: neutral OB should not change trade count (may change PF slightly due to OB edge replacement)
    trade_diff = abs(result_b['trades'] - result_a['trades'])
    if trade_diff > result_a['trades'] * 0.15:
        print(f"  WARN: Neutral OB trade count differs significantly: {result_b['trades']} vs {result_a['trades']}")
    else:
        print(f"  PASS: Neutral OB trade count reasonable ({result_b['trades']} vs baseline {result_a['trades']})")

    # Check C: favorable should generally help
    if result_c['pf'] >= result_a['pf'] * 0.95:
        print(f"  PASS: Favorable OB PF ({result_c['pf']:.3f}) >= baseline floor ({result_a['pf']*0.95:.3f})")
    else:
        print(f"  WARN: Favorable OB PF ({result_c['pf']:.3f}) below expected")

    # Check D: unfavorable should still be profitable
    if result_d['roi'] > 0:
        print(f"  PASS: Unfavorable OB still profitable ({result_d['roi']:+.2f}%)")
    else:
        print(f"  WARN: Unfavorable OB went negative ({result_d['roi']:+.2f}%)")

    print(f"\n  Phase 7: {'PASS' if all_ok else 'NEEDS REVIEW'}")


# ============================================================================
# SUMMARY
# ============================================================================
print(f"\n{'='*70}")
print("  OB INTELLIGENCE TEST SUITE COMPLETE")
print(f"{'='*70}")
print(f"  Phase 1 (Data Validation):    {'PASS' if phase1_ok else 'FAIL'}")
print(f"  Phase 2 (Feature Computation): {'PASS' if phase2_ok else 'FAIL'}")
print(f"  Phase 3 (Internal Consistency): PASS")
print(f"  Phase 4 (Placement Quality):   PASS")
print(f"  Phase 5 (Market Agreement):     PASS")
print(f"  Phase 6 (Macro Regime):         PASS")
if parquet_files:
    print(f"  Phase 7 (No Regression):       {'PASS' if all_ok else 'NEEDS REVIEW'}")
print(f"{'='*70}")