!pip install numpy pandas matplotlib seaborn --quiet

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from dataclasses import dataclass
from typing import Dict, Tuple
import warnings

warnings.filterwarnings('ignore')
%matplotlib inline
plt.rcParams['figure.figsize'] = (13, 5)
plt.rcParams['axes.spines.top']   = False
plt.rcParams['axes.spines.right'] = False
sns.set_palette('deep')
print('Imports ready.')

@dataclass
class MMParams:
    """
    Complete parameter set for a market making regime.

    Attributes
    ----------
    regime_name : str
        Human-readable name for the regime.
    spread_bps : float
        Target bid-ask spread in basis points.
    base_size : float
        Base quote size in BTC per level.
    skew_factor : float
        Inventory skew strength (higher = more aggressive rebalancing).
    max_inventory : float
        Hard inventory limit in BTC.
    n_levels : int
        Number of quote levels per side.
    fill_prob_boost : float
        Multiplier on base fill probability (>1 = more aggressive fills).
    """
    regime_name:     str
    spread_bps:      float
    base_size:       float
    skew_factor:     float
    max_inventory:   float
    n_levels:        int
    fill_prob_boost: float


# Regime-specific parameter sets
REGIME_PARAMS: Dict[str, MMParams] = {
    'calm': MMParams(
        regime_name     = 'Calm / Range-Bound',
        spread_bps      = 6.0,
        base_size       = 0.15,
        skew_factor     = 0.30,
        max_inventory   = 1.50,
        n_levels        = 4,
        fill_prob_boost = 1.20,   # quote tighter → get more fills
    ),
    'trending': MMParams(
        regime_name     = 'Trending',
        spread_bps      = 15.0,
        base_size       = 0.06,
        skew_factor     = 0.80,   # strong skew to fight the trend
        max_inventory   = 0.80,
        n_levels        = 2,
        fill_prob_boost = 0.70,
    ),
    'high_vol': MMParams(
        regime_name     = 'High Volatility',
        spread_bps      = 30.0,
        base_size       = 0.03,
        skew_factor     = 0.60,
        max_inventory   = 0.50,
        n_levels        = 2,
        fill_prob_boost = 0.50,
    ),
    'illiquid': MMParams(
        regime_name     = 'Illiquid / Low Volume',
        spread_bps      = 40.0,
        base_size       = 0.20,   # large size to capture wide natural spread
        skew_factor     = 0.40,
        max_inventory   = 2.00,
        n_levels        = 1,
        fill_prob_boost = 0.40,
    ),
}

# Static baseline for comparison
STATIC_PARAMS = MMParams(
    regime_name     = 'Static Baseline',
    spread_bps      = 12.0,
    base_size       = 0.08,
    skew_factor     = 0.40,
    max_inventory   = 1.00,
    n_levels        = 2,
    fill_prob_boost = 1.00,
)

print('Regime parameters defined:')
for r, p in REGIME_PARAMS.items():
    print(f'  {r:12s}: spread={p.spread_bps}bps, size={p.base_size}BTC, skew={p.skew_factor}')

def detect_market_regime(
    mid_prices: list,
    vol_window: int = 20,
    momentum_window: int = 10,
    vol_calm_thresh: float = 0.010,
    vol_high_thresh: float = 0.025,
    momentum_trend_thresh: float = 0.008,
    volume_low_thresh: float = 0.3
) -> Tuple[str, dict]:
    """
    Detect the current market regime from recent mid-price history.

    Parameters
    ----------
    mid_prices : list
        Recent mid-prices, most recent last.
    vol_window : int
        Rolling window for volatility estimation.
    momentum_window : int
        Rolling window for momentum (price direction) estimation.
    vol_calm_thresh : float
        Realized vol below this = 'calm' regime candidate.
    vol_high_thresh : float
        Realized vol above this = 'high_vol' regime candidate.
    momentum_trend_thresh : float
        Absolute price change over momentum_window above this = 'trending'.
    volume_low_thresh : float
        If recent volume is below this fraction of the mean = 'illiquid'.

    Returns
    -------
    Tuple[str, dict]
        (regime_name, signal_values).
        regime_name: one of 'calm', 'trending', 'high_vol', 'illiquid'.
        signal_values: dict of the underlying signal values used.

    Notes
    -----
    Priority order when multiple conditions are met:
    1. high_vol (most dangerous — override everything)
    2. trending (also dangerous for MMs)
    3. illiquid (unusual conditions)
    4. calm (default favorable state)
    """
    if len(mid_prices) < max(vol_window, momentum_window) + 1:
        return 'calm', {}

    arr    = np.array(mid_prices[-vol_window - 1:])
    rets   = np.diff(np.log(arr))
    realized_vol = np.std(rets) * np.sqrt(288)  # annualize to daily

    recent_prices = np.array(mid_prices[-momentum_window:])
    momentum      = abs(recent_prices[-1] / recent_prices[0] - 1)

    signals = {
        'realized_vol': round(realized_vol, 5),
        'momentum':     round(momentum, 5),
    }

    if realized_vol > vol_high_thresh:
        return 'high_vol', signals
    elif momentum > momentum_trend_thresh:
        return 'trending', signals
    elif realized_vol < vol_calm_thresh:
        return 'calm', signals
    else:
        return 'calm', signals


print('Regime detector defined. Test:')
test_prices = list(50000 + np.random.randn(50) * 50)
regime, sigs = detect_market_regime(test_prices)
print(f'  Detected regime: {regime}, signals: {sigs}')

def simulate_regime_switching_mm(
    n_steps: int,
    start_price: float,
    use_regime_switching: bool = True
) -> pd.DataFrame:
    """
    Simulate a market maker with regime switching vs a static parameter baseline.

    Embeds three market regime changes: a trending period, a high-vol spike, and
    an illiquid window. The adaptive MM should detect and respond to each.

    Parameters
    ----------
    n_steps : int
        Simulation length in ticks.
    start_price : float
        Initial mid-price.
    use_regime_switching : bool
        True = adaptive MM, False = static baseline.

    Returns
    -------
    pd.DataFrame
        Tick-by-tick state including regime, spread, PnL.
    """
    np.random.seed(7)
    base_tick_vol = 0.02 / np.sqrt(288)

    # Embedded regime events
    regime_events = [
        (1000, 1500, 'trending',  base_tick_vol * 1.0, 0.0005),  # gradual uptrend
        (2500, 2800, 'high_vol',  base_tick_vol * 4.0, 0.0),     # vol spike
        (4000, 4500, 'illiquid',  base_tick_vol * 0.5, 0.0),     # quiet period
    ]

    mid          = start_price
    inventory    = 0.0
    cash         = 0.0
    price_history = [mid]
    records      = []

    for t in range(n_steps):
        # Determine tick vol (with embedded events)
        tick_vol = base_tick_vol
        drift    = 0.0
        true_regime = 'calm'
        for ev_start, ev_end, ev_type, ev_vol, ev_drift in regime_events:
            if ev_start <= t < ev_end:
                tick_vol = ev_vol
                drift    = ev_drift
                true_regime = ev_type
                break

        mid += mid * (np.random.normal(drift, tick_vol))
        mid  = max(mid, 1.0)
        price_history.append(mid)

        # Detect regime
        if use_regime_switching:
            detected_regime, _ = detect_market_regime(price_history[-50:])
            params = REGIME_PARAMS[detected_regime]
        else:
            detected_regime = 'static'
            params = STATIC_PARAMS

        spread_dec = params.spread_bps / 10_000
        half_spread = mid * spread_dec / 2
        bid_price   = mid - half_spread
        ask_price   = mid + half_spread
        size        = params.base_size

        # Inventory skew
        inv_norm = inventory / params.max_inventory
        bid_size = size * max(0.0, 1 - params.skew_factor * max(0, inv_norm))
        ask_size = size * max(0.0, 1 - params.skew_factor * max(0, -inv_norm))

        fill_prob = 0.12 * params.fill_prob_boost
        if np.random.rand() < fill_prob and bid_size > 0.001:
            inventory += bid_size
            cash      -= bid_size * bid_price
        if np.random.rand() < fill_prob and ask_size > 0.001:
            inventory -= ask_size
            cash      += ask_size * ask_price

        mtm_pnl = cash + inventory * mid

        records.append({
            'tick':            t,
            'mid':             mid,
            'inventory':       inventory,
            'mtm_pnl':         mtm_pnl,
            'detected_regime': detected_regime,
            'true_regime':     true_regime,
            'spread_bps':      params.spread_bps,
        })

    return pd.DataFrame(records)


SIMULATION_STEPS = 6_000
START_PRICE = 50_000
sim_adaptive = simulate_regime_switching_mm(SIMULATION_STEPS, START_PRICE, use_regime_switching=True)
sim_static   = simulate_regime_switching_mm(SIMULATION_STEPS, START_PRICE, use_regime_switching=False)


print(f'Adaptive MM: Final MtM PnL = ${sim_adaptive["mtm_pnl"].iloc[-1]:.2f}')
print(f'Static MM:   Final MtM PnL = ${sim_static["mtm_pnl"].iloc[-1]:.2f}')
print('\nDetected regime distribution:')
print(sim_adaptive['detected_regime'].value_counts().to_string())

def plot_regime_switching_dashboard(
    sim_adaptive: pd.DataFrame,
    sim_static: pd.DataFrame
) -> None:
    """
    Four-panel dashboard: price, regimes, spread, and PnL comparison.

    Parameters
    ----------
    sim_adaptive : pd.DataFrame
        Adaptive MM simulation.
    sim_static : pd.DataFrame
        Static MM simulation.
    """
    fig, axes = plt.subplots(4, 1, figsize=(15, 16), sharex=True)

    regime_colors = {'calm': 'green', 'trending': 'orange', 'high_vol': 'red', 'illiquid': 'purple'}

    # Panel 1: Price
    axes[0].plot(sim_adaptive['tick'], sim_adaptive['mid'], color='steelblue', linewidth=0.8)

    # Shade true regime periods
    for regime_name, color in regime_colors.items():
        mask = sim_adaptive['true_regime'] == regime_name
        if mask.any():
            axes[0].fill_between(sim_adaptive['tick'],
                                  sim_adaptive['mid'].min(),
                                  sim_adaptive['mid'].max(),
                                  where=mask, alpha=0.15, color=color)
    axes[0].set_ylabel('Mid Price')
    axes[0].set_title('Price with True Regime Shading — Green=Calm, Orange=Trending, Red=High-Vol')

    # Panel 2: Detected vs true regime
    regime_num = {'calm': 0, 'trending': 1, 'high_vol': 2, 'illiquid': 3}
    detected_num = sim_adaptive['detected_regime'].map(regime_num)
    true_num     = sim_adaptive['true_regime'].map(regime_num)
    axes[1].step(sim_adaptive['tick'], detected_num, label='Detected', color='navy',  linewidth=1.5)
    axes[1].step(sim_adaptive['tick'], true_num,     label='True',     color='red',   linewidth=1.0, linestyle='--', alpha=0.7)
    axes[1].set_yticks([0, 1, 2, 3])
    axes[1].set_yticklabels(['calm', 'trending', 'high_vol', 'illiquid'])
    axes[1].set_ylabel('Regime')
    axes[1].set_title('Detected vs True Market Regime')
    axes[1].legend()

    # Panel 3: Spread comparison
    axes[2].plot(sim_adaptive['tick'], sim_adaptive['spread_bps'], color='steelblue', linewidth=1.0, label='Adaptive')
    axes[2].axhline(sim_static['spread_bps'].iloc[0], color='grey', linewidth=0.8, linestyle='--', label='Static')
    axes[2].set_ylabel('Spread (bps)')
    axes[2].set_title('Quoted Spread')
    axes[2].legend()

    # Panel 4: PnL comparison
    axes[3].plot(sim_adaptive['tick'], sim_adaptive['mtm_pnl'], label='Adaptive MM', color='green', linewidth=1.5)
    axes[3].plot(sim_static['tick'],   sim_static['mtm_pnl'],   label='Static MM',   color='red',   linewidth=1.5, alpha=0.7)
    axes[3].axhline(0, color='black', linewidth=0.5, linestyle='--')
    axes[3].set_ylabel('MtM PnL (USD)')
    axes[3].set_title('Regime-Adaptive vs Static MM Performance')
    axes[3].set_xlabel('Tick')
    axes[3].legend()

    plt.tight_layout()
    plt.show()


plot_regime_switching_dashboard(sim_adaptive, sim_static)

def export_regime_switching(
    sim_adaptive: pd.DataFrame,
    sim_static: pd.DataFrame
) -> None:
    """
    Export regime-switching and static simulation results.

    Parameters
    ----------
    sim_adaptive : pd.DataFrame
        Adaptive MM simulation.
    sim_static : pd.DataFrame
        Static MM simulation.
    """
    sim_adaptive.to_csv('mm_regime_adaptive.csv', index=False)
    sim_static.to_csv('mm_regime_static.csv', index=False)
    print('Exported: mm_regime_adaptive.csv')
    print('Exported: mm_regime_static.csv')


export_regime_switching(sim_adaptive, sim_static)