# requests: HTTP client library for making exchange API calls
# pandas: Data manipulation and analysis for reporting
# numpy: Numerical computations for statistical calculations
!pip install requests pandas numpy

import warnings
warnings.filterwarnings("ignore")

# Standard library imports
import time
import random
import logging
import sys
import json
from typing import Dict, List, Optional, Tuple, Any
from collections import deque
from datetime import datetime, timedelta
from dataclasses import dataclass, field
from enum import Enum

# Third-party imports
import pandas as pd
import numpy as np

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(levelname)-8s | %(message)s",
    datefmt="%H:%M:%S",
    stream=sys.stdout,
)

logger = logging.getLogger("market_maker")

def create_order(
    order_id: str,
    symbol: str,
    side: str,
    price: float,
    quantity: float,
    order_type: str = "LIMIT",
) -> dict:
    """
    Creates a standardized order dictionary.

    Parameters
    ----------
    order_id : str
        Unique identifier for the order.
    symbol : str
        Trading pair symbol (e.g., 'BTCUSDT').
    side : str
        Order side - 'BUY' or 'SELL'.
    price : float
        Order price.
    quantity : float
        Order quantity.
    order_type : str, optional
        Order type, defaults to 'LIMIT'.

    Returns
    -------
    dict
        Standardized order representation.
    """
    return {
        "order_id": order_id,
        "symbol": symbol,
        "side": side,
        "price": price,
        "quantity": quantity,
        "order_type": order_type,
        "status": "ACTIVE",
        "created_at": time.time(),
        "filled_quantity": 0.0,
        "avg_fill_price": 0.0,
    }

def create_market_state(symbol: str) -> dict:
    """
    Initializes the market state tracking structure.

    Parameters
    ----------
    symbol : str
        Trading pair symbol.

    Returns
    -------
    dict
        Market state including best bid/ask, mid price, and spread.
    """
    return {
        "symbol": symbol,
        "best_bid": 0.0,
        "best_ask": 0.0,
        "mid_price": 0.0,
        "spread": 0.0,
        "spread_bps": 0.0,
        "timestamp": 0.0,
        "bid_depth": [],      # List of (price, quantity) for bids
        "ask_depth": [],      # List of (price, quantity) for asks
    }

def create_inventory_state(
    max_position: float = 1.0,
    target_position: float = 0.0,
    max_inventory_skew: float = 0.5,
) -> dict:
    """
    Initializes inventory tracking for market making.

    Parameters
    ----------
    max_position : float, optional
        Maximum allowed absolute position size.
    target_position : float, optional
        Target inventory level (default 0 for neutral).
    max_inventory_skew : float, optional
        Maximum price skew percentage due to inventory.

    Returns
    -------
    dict
        Inventory state including current position and risk metrics.
    """
    return {
        "current_position": 0.0,
        "max_position": max_position,
        "target_position": target_position,
        "max_inventory_skew": max_inventory_skew,
        "total_buy_volume": 0.0,
        "total_sell_volume": 0.0,
        "realized_pnl": 0.0,
        "unrealized_pnl": 0.0,
        "avg_buy_price": 0.0,
        "avg_sell_price": 0.0,
        "position_age": 0.0,
        "last_update_time": time.time(),
    }

def create_performance_tracker() -> dict:
    """
    Initializes performance tracking metrics.

    Returns
    -------
    dict
        Performance tracking structure with trade history and metrics.
    """
    return {
        "total_trades": 0,
        "total_buy_trades": 0,
        "total_sell_trades": 0,
        "total_volume": 0.0,
        "gross_spread_captured": 0.0,
        "net_pnl": 0.0,
        "trade_history": [],  # List of trade events
        "order_events": [],   # List of order placement/cancel events
        "inventory_snapshots": [],  # Periodic inventory records
        "start_time": time.time(),
    }

def update_market_state(
    market_state: dict,
    bids: List[Tuple[float, float]],
    asks: List[Tuple[float, float]],
) -> dict:
    """
    Updates market state with current order book data.

    Parameters
    ----------
    market_state : dict
        Current market state to update.
    bids : list of tuples
        List of (price, quantity) for bid side.
    asks : list of tuples
        List of (price, quantity) for ask side.

    Returns
    -------
    dict
        Updated market state.
    """
    if not bids or not asks:
        return market_state

    # Update best bid and ask
    market_state["best_bid"] = bids[0][0] if bids else 0.0
    market_state["best_ask"] = asks[0][0] if asks else 0.0

    # Calculate mid price and spread
    if market_state["best_bid"] > 0 and market_state["best_ask"] > 0:
        market_state["mid_price"] = (market_state["best_bid"] + market_state["best_ask"]) / 2
        market_state["spread"] = market_state["best_ask"] - market_state["best_bid"]

        # Calculate spread in basis points
        if market_state["mid_price"] > 0:
            market_state["spread_bps"] = (market_state["spread"] / market_state["mid_price"]) * 10000

    # Store full depth
    market_state["bid_depth"] = bids[:10]  # Store top 10 levels
    market_state["ask_depth"] = asks[:10]
    market_state["timestamp"] = time.time()

    return market_state

def calculate_optimal_spread(
    market_state: dict,
    base_spread_bps: float = 2.0,
    volatility: float = 0.0,
    inventory_skew: float = 0.0,
    min_spread_bps: float = 1.0,
    max_spread_bps: float = 10.0,
) -> float:
    """
    Calculates optimal spread based on market conditions and inventory.

    Parameters
    ----------
    market_state : dict
        Current market state.
    base_spread_bps : float, optional
        Base spread in basis points.
    volatility : float, optional
        Current market volatility (standard deviation of returns).
    inventory_skew : float, optional
        Inventory skew factor (-1 to 1, negative = long inventory).
    min_spread_bps : float, optional
        Minimum allowed spread in basis points.
    max_spread_bps : float, optional
        Maximum allowed spread in basis points.

    Returns
    -------
    float
        Optimal spread in basis points.
    """
    # Start with base spread
    spread_bps = base_spread_bps

    # Increase spread during high volatility
    if volatility > 0:
        volatility_adjustment = volatility * 100  # Convert to basis points
        spread_bps += volatility_adjustment

    # Adjust for inventory risk
    # Positive skew (short inventory) -> increase ask spread, decrease bid spread
    # Negative skew (long inventory) -> decrease ask spread, increase bid spread
    inventory_adjustment = abs(inventory_skew) * base_spread_bps
    spread_bps += inventory_adjustment

    # Apply bounds
    spread_bps = max(min_spread_bps, min(max_spread_bps, spread_bps))

    return spread_bps

def calculate_skewed_prices(
    market_state: dict,
    spread_bps: float,
    inventory_skew: float,
) -> Tuple[float, float]:
    """
    Calculates bid and ask prices with inventory-based skewing.

    Parameters
    ----------
    market_state : dict
        Current market state with mid price.
    spread_bps : float
        Desired spread in basis points.
    inventory_skew : float
        Inventory skew factor (-1 to 1).

    Returns
    -------
    tuple
        (bid_price, ask_price) skewed for inventory management.
    """
    mid_price = market_state["mid_price"]

    if mid_price <= 0:
        return 0.0, 0.0

    # Calculate half spread in price terms
    half_spread_price = (spread_bps / 10000) * mid_price / 2

    # Calculate skew adjustment (moves prices asymmetrically)
    # Negative skew (long inventory) -> move prices down to encourage selling
    # Positive skew (short inventory) -> move prices up to encourage buying
    skew_adjustment = inventory_skew * half_spread_price

    # Calculate final bid and ask prices
    bid_price = mid_price - half_spread_price + skew_adjustment
    ask_price = mid_price + half_spread_price + skew_adjustment

    # Round to appropriate precision (assuming 2 decimals for most crypto)
    bid_price = round(bid_price, 2)
    ask_price = round(ask_price, 2)

    return bid_price, ask_price

def generate_order_id(symbol: str, side: str) -> str:
    """
    Generates a unique order ID.

    Parameters
    ----------
    symbol : str
        Trading pair symbol.
    side : str
        Order side ('BUY' or 'SELL').

    Returns
    -------
    str
        Unique order identifier.
    """
    timestamp = int(time.time() * 1000)
    random_suffix = random.randint(1000, 9999)
    return f"{symbol}_{side}_{timestamp}_{random_suffix}"

def calculate_order_quantity(
    inventory_state: dict,
    side: str,
    base_quantity: float,
    max_quantity: float = None,
) -> float:
    """
    Calculates order quantity based on inventory limits.

    Parameters
    ----------
    inventory_state : dict
        Current inventory state.
    side : str
        Order side ('BUY' or 'SELL').
    base_quantity : float
        Base quantity to place.
    max_quantity : float, optional
        Maximum allowed quantity per order.

    Returns
    -------
    float
        Adjusted order quantity.
    """
    current_pos = inventory_state["current_position"]
    max_pos = inventory_state["max_position"]

    # Calculate available capacity
    if side == "BUY":
        # Reduce buy quantity if near max long position
        available_capacity = max_pos - current_pos
        quantity = min(base_quantity, available_capacity)
    else:  # SELL
        # Reduce sell quantity if near max short position
        available_capacity = max_pos + current_pos  # current_pos negative for shorts
        quantity = min(base_quantity, available_capacity)

    # Apply global max if specified
    if max_quantity:
        quantity = min(quantity, max_quantity)

    # Ensure non-negative
    quantity = max(0, quantity)

    return quantity

def update_inventory_on_fill(
    inventory_state: dict,
    side: str,
    price: float,
    quantity: float,
) -> dict:
    """
    Updates inventory state when an order is filled.

    Parameters
    ----------
    inventory_state : dict
        Current inventory state to update.
    side : str
        Fill side ('BUY' or 'SELL').
    price : float
        Fill price.
    quantity : float
        Fill quantity.

    Returns
    -------
    dict
        Updated inventory state.
    """
    old_position = inventory_state["current_position"]

    if side == "BUY":
        # Update average buy price using weighted average
        total_value = (inventory_state["avg_buy_price"] * inventory_state["total_buy_volume"]) + (price * quantity)
        inventory_state["total_buy_volume"] += quantity
        inventory_state["avg_buy_price"] = total_value / inventory_state["total_buy_volume"] if inventory_state["total_buy_volume"] > 0 else 0
        inventory_state["current_position"] += quantity

        # Check if we're reducing a short position
        if old_position < 0:
            # Calculate realized PnL from covering shorts
            cover_quantity = min(quantity, abs(old_position))
            if cover_quantity > 0 and inventory_state["avg_sell_price"] > 0:
                pnl = (inventory_state["avg_sell_price"] - price) * cover_quantity
                inventory_state["realized_pnl"] += pnl

    else:  # SELL
        # Update average sell price
        total_value = (inventory_state["avg_sell_price"] * inventory_state["total_sell_volume"]) + (price * quantity)
        inventory_state["total_sell_volume"] += quantity
        inventory_state["avg_sell_price"] = total_value / inventory_state["total_sell_volume"] if inventory_state["total_sell_volume"] > 0 else 0
        inventory_state["current_position"] -= quantity

        # Check if we're reducing a long position
        if old_position > 0:
            # Calculate realized PnL from selling longs
            sell_quantity = min(quantity, old_position)
            if sell_quantity > 0 and inventory_state["avg_buy_price"] > 0:
                pnl = (price - inventory_state["avg_buy_price"]) * sell_quantity
                inventory_state["realized_pnl"] += pnl

    # Update position age
    inventory_state["position_age"] = 0.0 if abs(inventory_state["current_position"]) < 0.001 else inventory_state["position_age"] + 0.1
    inventory_state["last_update_time"] = time.time()

    return inventory_state

def calculate_inventory_skew(inventory_state: dict) -> float:
    """
    Calculates inventory skew factor for price adjustment.

    Parameters
    ----------
    inventory_state : dict
        Current inventory state.

    Returns
    -------
    float
        Skew factor between -1 and 1.
        Negative: long inventory (skew prices down)
        Positive: short inventory (skew prices up)
    """
    current_pos = inventory_state["current_position"]
    max_pos = inventory_state["max_position"]

    if max_pos <= 0:
        return 0.0

    # Calculate position ratio (-1 to 1)
    pos_ratio = current_pos / max_pos

    # Apply max skew limit
    max_skew = inventory_state["max_inventory_skew"]
    skew = max(-max_skew, min(max_skew, -pos_ratio * max_skew))

    return skew

def create_market_maker(
    symbol: str,
    order_quantity: float = 0.01,
    base_spread_bps: float = 2.0,
    max_position: float = 0.1,
    max_order_age_seconds: float = 30.0,
) -> dict:
    """
    Initializes the main market making engine state.

    Parameters
    ----------
    symbol : str
        Trading pair symbol.
    order_quantity : float, optional
        Base order quantity for each side.
    base_spread_bps : float, optional
        Base spread in basis points.
    max_position : float, optional
        Maximum allowed position size.
    max_order_age_seconds : float, optional
        Maximum time to keep orders alive.

    Returns
    -------
    dict
        Complete market maker state.
    """
    return {
        "symbol": symbol,
        "order_quantity": order_quantity,
        "base_spread_bps": base_spread_bps,
        "max_order_age_seconds": max_order_age_seconds,
        "is_running": False,
        "active_orders": {},  # order_id -> order dict
        "market_state": create_market_state(symbol),
        "inventory": create_inventory_state(max_position=max_position),
        "performance": create_performance_tracker(),
        "last_quote_time": 0.0,
        "quote_interval_seconds": 1.0,
    }

def update_volatility_estimate(
    price_history: deque,
    window_seconds: int = 60,
) -> float:
    """
    Calculates volatility from recent price history.

    Parameters
    ----------
    price_history : deque
        Deque of (timestamp, price) tuples.
    window_seconds : int, optional
        Time window for volatility calculation in seconds.

    Returns
    -------
    float
        Annualized volatility estimate.
    """
    if len(price_history) < 10:
        return 0.0

    # Filter prices within window
    current_time = time.time()
    recent_prices = []

    for ts, price in price_history:
        if current_time - ts <= window_seconds:
            recent_prices.append(price)

    if len(recent_prices) < 10:
        return 0.0

    # Calculate returns
    returns = []
    for i in range(1, len(recent_prices)):
        if recent_prices[i-1] > 0:
            ret = (recent_prices[i] - recent_prices[i-1]) / recent_prices[i-1]
            returns.append(ret)

    if len(returns) < 2:
        return 0.0

    # Calculate volatility (standard deviation of returns)
    vol = np.std(returns)

    return vol

def cancel_order(engine: dict, order_id: str) -> bool:
    """
    Cancels an active order.

    Parameters
    ----------
    engine : dict
        Market maker engine state.
    order_id : str
        ID of order to cancel.

    Returns
    -------
    bool
        True if order was cancelled, False otherwise.
    """
    if order_id in engine["active_orders"]:
        order = engine["active_orders"][order_id]
        order["status"] = "CANCELLED"
        del engine["active_orders"][order_id]

        # Record cancellation event
        engine["performance"]["order_events"].append({
            "timestamp": time.time(),
            "event_type": "CANCEL",
            "order_id": order_id,
            "side": order["side"],
            "price": order["price"],
        })

        logger.debug(f"Cancelled order {order_id}")
        return True

    return False

def cancel_all_orders(engine: dict) -> int:
    """
    Cancels all active orders.

    Parameters
    ----------
    engine : dict
        Market maker engine state.

    Returns
    -------
    int
        Number of orders cancelled.
    """
    order_ids = list(engine["active_orders"].keys())
    cancelled_count = 0

    for order_id in order_ids:
        if cancel_order(engine, order_id):
            cancelled_count += 1

    logger.info(f"Cancelled {cancelled_count} orders")
    return cancelled_count

def place_orders(
    engine: dict,
    bid_price: float,
    ask_price: float,
) -> Tuple[List[dict], List[dict]]:
    """
    Places bid and ask orders at specified prices.

    Parameters
    ----------
    engine : dict
        Market maker engine state.
    bid_price : float
        Price for buy order.
    ask_price : float.
    ask_price : float
        Price for sell order.

    Returns
    -------
    tuple
        (placed_bids, placed_asks) lists of order dictionaries.
    """
    placed_bids = []
    placed_asks = []

    # Calculate order quantities based on inventory
    bid_qty = calculate_order_quantity(
        engine["inventory"],
        "BUY",
        engine["order_quantity"],
    )

    ask_qty = calculate_order_quantity(
        engine["inventory"],
        "SELL",
        engine["order_quantity"],
    )

    # Place bid order if quantity > 0
    if bid_qty > 0 and bid_price > 0:
        order_id = generate_order_id(engine["symbol"], "BUY")
        order = create_order(
            order_id=order_id,
            symbol=engine["symbol"],
            side="BUY",
            price=bid_price,
            quantity=bid_qty,
        )
        engine["active_orders"][order_id] = order
        placed_bids.append(order)

        # Record placement event
        engine["performance"]["order_events"].append({
            "timestamp": time.time(),
            "event_type": "PLACE",
            "order_id": order_id,
            "side": "BUY",
            "price": bid_price,
            "quantity": bid_qty,
        })

    # Place ask order if quantity > 0
    if ask_qty > 0 and ask_price > 0:
        order_id = generate_order_id(engine["symbol"], "SELL")
        order = create_order(
            order_id=order_id,
            symbol=engine["symbol"],
            side="SELL",
            price=ask_price,
            quantity=ask_qty,
        )
        engine["active_orders"][order_id] = order
        placed_asks.append(order)

        # Record placement event
        engine["performance"]["order_events"].append({
            "timestamp": time.time(),
            "event_type": "PLACE",
            "order_id": order_id,
            "side": "SELL",
            "price": ask_price,
            "quantity": ask_qty,
        })

    if placed_bids or placed_asks:
        logger.info(
            f"Placed orders - Bid: {bid_price}@{bid_qty}, Ask: {ask_price}@{ask_qty}"
        )

    return placed_bids, placed_asks

def process_fill(
    engine: dict,
    order_id: str,
    fill_price: float,
    fill_quantity: float,
) -> dict:
    """
    Processes a fill event for an order.

    Parameters
    ----------
    engine : dict
        Market maker engine state.
    order_id : str
        ID of filled order.
    fill_price : float
        Price at which order was filled.
    fill_quantity : float
        Quantity filled.

    Returns
    -------
    dict
        Updated engine state.
    """
    if order_id not in engine["active_orders"]:
        logger.warning(f"Fill received for unknown order {order_id}")
        return engine

    order = engine["active_orders"][order_id]

    # Update order fill status
    order["filled_quantity"] += fill_quantity
    total_value = (order["avg_fill_price"] * (order["filled_quantity"] - fill_quantity)) + (fill_price * fill_quantity)
    order["avg_fill_price"] = total_value / order["filled_quantity"] if order["filled_quantity"] > 0 else 0

    # Check if order is fully filled
    if order["filled_quantity"] >= order["quantity"]:
        order["status"] = "FILLED"
        del engine["active_orders"][order_id]

    # Update inventory
    engine["inventory"] = update_inventory_on_fill(
        engine["inventory"],
        order["side"],
        fill_price,
        fill_quantity,
    )

    # Update performance metrics
    perf = engine["performance"]
    perf["total_trades"] += 1

    if order["side"] == "BUY":
        perf["total_buy_trades"] += 1
    else:
        perf["total_sell_trades"] += 1

    perf["total_volume"] += fill_quantity

    # Record trade
    perf["trade_history"].append({
        "timestamp": time.time(),
        "order_id": order_id,
        "side": order["side"],
        "price": fill_price,
        "quantity": fill_quantity,
        "position_after": engine["inventory"]["current_position"],
        "realized_pnl": engine["inventory"]["realized_pnl"],
    })

    logger.info(
        f"FILL: {order['side']} {fill_quantity} @ {fill_price} | "
        f"Position: {engine['inventory']['current_position']:.4f} | "
        f"PnL: {engine['inventory']['realized_pnl']:.2f}"
    )

    return engine

def check_stale_orders(engine: dict) -> int:
    """
    Cancels orders that have been active beyond max age.

    Parameters
    ----------
    engine : dict
        Market maker engine state.

    Returns
    -------
    int
        Number of stale orders cancelled.
    """
    current_time = time.time()
    stale_orders = []

    for order_id, order in engine["active_orders"].items():
        if current_time - order["created_at"] > engine["max_order_age_seconds"]:
            stale_orders.append(order_id)

    cancelled = 0
    for order_id in stale_orders:
        if cancel_order(engine, order_id):
            cancelled += 1

    if cancelled > 0:
        logger.debug(f"Cancelled {cancelled} stale orders")

    return cancelled

def generate_quote(
    engine: dict,
    market_bids: List[Tuple[float, float]],
    market_asks: List[Tuple[float, float]],
    price_history: deque = None,
) -> Tuple[float, float]:
    """
    Generates bid and ask quotes based on market conditions.

    Parameters
    ----------
    engine : dict
        Market maker engine state.
    market_bids : list of tuples
        Current market bid depth.
    market_asks : list of tuples
        Current market ask depth.
    price_history : deque, optional
        Recent price history for volatility calculation.

    Returns
    -------
    tuple
        (bid_price, ask_price) for quoting.
    """
    # Update market state
    engine["market_state"] = update_market_state(
        engine["market_state"],
        market_bids,
        market_asks,
    )

    # Calculate current inventory skew
    inventory_skew = calculate_inventory_skew(engine["inventory"])

    # Calculate volatility if price history provided
    volatility = 0.0
    if price_history:
        volatility = update_volatility_estimate(price_history)

    # Calculate optimal spread
    spread_bps = calculate_optimal_spread(
        engine["market_state"],
        base_spread_bps=engine["base_spread_bps"],
        volatility=volatility,
        inventory_skew=abs(inventory_skew),
    )

    # Calculate skewed prices
    bid_price, ask_price = calculate_skewed_prices(
        engine["market_state"],
        spread_bps,
        inventory_skew,
    )

    engine["last_quote_time"] = time.time()

    return bid_price, ask_price

def update_quote(
    engine: dict,
    market_bids: List[Tuple[float, float]],
    market_asks: List[Tuple[float, float]],
    price_history: deque = None,
) -> dict:
    """
    Main function to update market maker quotes.

    Parameters
    ----------
    engine : dict
        Market maker engine state.
    market_bids : list of tuples
        Current market bid depth.
    market_asks : list of tuples
        Current market ask depth.
    price_history : deque, optional
        Recent price history for volatility calculation.

    Returns
    -------
    dict
        Updated engine state.
    """
    # Check if it's time to requote
    current_time = time.time()
    if current_time - engine["last_quote_time"] < engine["quote_interval_seconds"]:
        return engine

    # Cancel stale orders
    check_stale_orders(engine)

    # Cancel all existing orders before placing new ones
    cancel_all_orders(engine)

    # Generate new quote
    bid_price, ask_price = generate_quote(
        engine,
        market_bids,
        market_asks,
        price_history,
    )

    # Place new orders
    if bid_price > 0 or ask_price > 0:
        place_orders(engine, bid_price, ask_price)

    # Record inventory snapshot
    engine["performance"]["inventory_snapshots"].append({
        "timestamp": current_time,
        "position": engine["inventory"]["current_position"],
        "realized_pnl": engine["inventory"]["realized_pnl"],
        "mid_price": engine["market_state"]["mid_price"],
    })

    return engine

def get_performance_summary(engine: dict) -> pd.DataFrame:
    """
    Generates a performance summary DataFrame.

    Parameters
    ----------
    engine : dict
        Market maker engine state.

    Returns
    -------
    pd.DataFrame
        Performance metrics summary.
    """
    perf = engine["performance"]
    inventory = engine["inventory"]

    runtime_seconds = time.time() - perf["start_time"]
    runtime_minutes = runtime_seconds / 60 if runtime_seconds > 0 else 1

    # Calculate additional metrics
    avg_trade_size = perf["total_volume"] / perf["total_trades"] if perf["total_trades"] > 0 else 0
    trade_rate = perf["total_trades"] / runtime_minutes if runtime_minutes > 0 else 0
    volume_per_minute = perf["total_volume"] / runtime_minutes if runtime_minutes > 0 else 0

    # Calculate inventory turns
    inventory_turns = perf["total_volume"] / inventory["max_position"] if inventory["max_position"] > 0 else 0

    summary = {
        "metric": [
            "Total Trades",
            "Buy Trades",
            "Sell Trades",
            "Total Volume",
            "Average Trade Size",
            "Trade Rate (trades/min)",
            "Volume Rate (vol/min)",
            "Realized PnL",
            "Current Position",
            "Max Position Limit",
            "Inventory Turns",
            "Runtime (minutes)",
            "Active Orders",
        ],
        "value": [
            f"{perf['total_trades']}",
            f"{perf['total_buy_trades']}",
            f"{perf['total_sell_trades']}",
            f"{perf['total_volume']:.4f}",
            f"{avg_trade_size:.4f}",
            f"{trade_rate:.2f}",
            f"{volume_per_minute:.4f}",
            f"{inventory['realized_pnl']:.2f}",
            f"{inventory['current_position']:.4f}",
            f"{inventory['max_position']:.4f}",
            f"{inventory_turns:.2f}",
            f"{runtime_minutes:.2f}",
            f"{len(engine['active_orders'])}",
        ],
    }

    return pd.DataFrame(summary)

def get_trade_history_df(engine: dict) -> pd.DataFrame:
    """
    Returns trade history as a DataFrame.

    Parameters
    ----------
    engine : dict
        Market maker engine state.

    Returns
    -------
    pd.DataFrame
        Trade history with timestamps and details.
    """
    if not engine["performance"]["trade_history"]:
        return pd.DataFrame()

    df = pd.DataFrame(engine["performance"]["trade_history"])

    if not df.empty and "timestamp" in df.columns:
        df["datetime"] = pd.to_datetime(df["timestamp"], unit="s")
        df = df.sort_values("timestamp")

    return df

def get_inventory_history_df(engine: dict) -> pd.DataFrame:
    """
    Returns inventory snapshot history as a DataFrame.

    Parameters
    ----------
    engine : dict
        Market maker engine state.

    Returns
    -------
    pd.DataFrame
        Inventory history over time.
    """
    if not engine["performance"]["inventory_snapshots"]:
        return pd.DataFrame()

    df = pd.DataFrame(engine["performance"]["inventory_snapshots"])

    if not df.empty and "timestamp" in df.columns:
        df["datetime"] = pd.to_datetime(df["timestamp"], unit="s")
        df = df.sort_values("timestamp")

    return df

def print_market_maker_status(engine: dict) -> None:
    """
    Prints current market maker status.

    Parameters
    ----------
    engine : dict
        Market maker engine state.
    """
    market = engine["market_state"]
    inventory = engine["inventory"]

    print("\n" + "=" * 60)
    print(f"Market Maker Status - {engine['symbol']}")
    print("=" * 60)
    print(f"Best Bid: {market['best_bid']:.2f} | Best Ask: {market['best_ask']:.2f}")
    print(f"Mid Price: {market['mid_price']:.2f} | Spread: {market['spread_bps']:.1f} bps")
    print(f"Position: {inventory['current_position']:.4f} / {inventory['max_position']:.4f}")
    print(f"Realized PnL: {inventory['realized_pnl']:.2f}")
    print(f"Active Orders: {len(engine['active_orders'])}")
    print(f"Total Trades: {engine['performance']['total_trades']}")
    print("=" * 60)

def simulate_order_book(
    mid_price: float,
    spread_bps: float = 2.0,
    depth_levels: int = 5,
    tick_size: float = 0.01,
) -> Tuple[List[Tuple[float, float]], List[Tuple[float, float]]]:
    """
    Simulates an order book for testing.

    Parameters
    ----------
    mid_price : float
        Current mid price.
    spread_bps : float, optional
        Spread in basis points.
    depth_levels : int, optional
        Number of depth levels to generate.
    tick_size : float, optional
        Minimum price increment.

    Returns
    -------
    tuple
        (bids, asks) lists of (price, quantity) tuples.
    """
    spread_price = (spread_bps / 10000) * mid_price
    half_spread = spread_price / 2

    best_bid = round(mid_price - half_spread - tick_size, 2)
    best_ask = round(mid_price + half_spread + tick_size, 2)

    bids = []
    asks = []

    # Generate bid depth
    for i in range(depth_levels):
        price = best_bid - (i * tick_size * 5)
        quantity = random.uniform(0.1, 0.5)
        bids.append((price, quantity))

    # Generate ask depth
    for i in range(depth_levels):
        price = best_ask + (i * tick_size * 5)
        quantity = random.uniform(0.1, 0.5)
        asks.append((price, quantity))

    return bids, asks

def simulate_price_move(
    current_price: float,
    volatility: float = 0.0002,
    drift: float = 0.0,
) -> float:
    """
    Simulates a random price movement.

    Parameters
    ----------
    current_price : float
        Current price.
    volatility : float, optional
        Price volatility (standard deviation of return).
    drift : float, optional
        Price drift per step.

    Returns
    -------
    float
        New price after random movement.
    """
    # Generate random return
    ret = np.random.normal(drift, volatility)
    new_price = current_price * (1 + ret)

    return new_price

def run_market_maker_simulation(
    symbol: str = "BTCUSDT",
    duration_seconds: int = 120,
    initial_price: float = 50000.0,
    order_quantity: float = 0.05,
    base_spread_bps: float = 3.0,
    max_position: float = 0.5,
    quote_interval: float = 2.0,
) -> dict:
    """
    Runs a market maker simulation.

    Parameters
    ----------
    symbol : str, optional
        Trading pair symbol.
    duration_seconds : int, optional
        Simulation duration in seconds.
    initial_price : float, optional
        Starting price.
    order_quantity : float, optional
        Order size for each side.
    base_spread_bps : float, optional
        Base spread in basis points.
    max_position : float, optional
        Maximum position limit.
    quote_interval : float, optional
        Quote update interval in seconds.

    Returns
    -------
    dict
        Final market maker engine state.
    """
    # Initialize market maker
    engine = create_market_maker(
        symbol=symbol,
        order_quantity=order_quantity,
        base_spread_bps=base_spread_bps,
        max_position=max_position,
        max_order_age_seconds=quote_interval * 2,
    )

    engine["quote_interval_seconds"] = quote_interval

    # Initialize price history tracking
    price_history = deque(maxlen=100)
    current_price = initial_price

    # Add initial price history
    for _ in range(20):
        price_history.append((time.time(), current_price))

    # Track fill simulation
    last_fill_time = 0
    fill_probability = 0.3  # 30% chance of fill per quote cycle

    logger.info(f"Starting market maker simulation for {symbol}")
    logger.info(f"Duration: {duration_seconds}s | Initial Price: {initial_price}")
    logger.info(f"Order Qty: {order_quantity} | Spread: {base_spread_bps} bps")

    start_time = time.time()
    iteration = 0

    while time.time() - start_time < duration_seconds:
        iteration += 1

        # Simulate price movement (every 0.5 seconds)
        if iteration % 2 == 0:
            current_price = simulate_price_move(current_price, volatility=0.0005)
            current_price = max(100, current_price)  # Prevent negative price
            price_history.append((time.time(), current_price))

        # Generate simulated order book
        bids, asks = simulate_order_book(current_price, spread_bps=base_spread_bps)

        # Update quote
        engine = update_quote(engine, bids, asks, price_history)

        # Simulate random fills on active orders
        current_time = time.time()
        if current_time - last_fill_time > 1.0:  # Check for fills every second
            for order_id, order in list(engine["active_orders"].items()):
                if random.random() < fill_probability * 0.3:  # 9% fill chance per check
                    # Determine fill price (slightly better than order price)
                    if order["side"] == "BUY":
                        fill_price = order["price"] + random.uniform(-0.5, 0)
                    else:
                        fill_price = order["price"] + random.uniform(0, 0.5)

                    fill_price = max(0.01, fill_price)
                    fill_quantity = min(order["quantity"], random.uniform(0.5, 1.0) * order["quantity"])

                    engine = process_fill(engine, order_id, fill_price, fill_quantity)

                    # Break after one fill per cycle to avoid too many fills
                    break

            last_fill_time = current_time

        # Print status every 30 seconds
        if iteration % int(30 / quote_interval) == 0:
            print_market_maker_status(engine)

        # Sleep for quote interval
        time.sleep(quote_interval)

    # Cancel all orders at end
    cancel_all_orders(engine)

    # Final inventory recalculation
    if abs(engine["inventory"]["current_position"]) > 0.001 and engine["market_state"]["mid_price"] > 0:
        # Calculate unrealized PnL for remaining inventory
        mid_price = engine["market_state"]["mid_price"]
        if engine["inventory"]["current_position"] > 0:
            # Long position
            engine["inventory"]["unrealized_pnl"] = (mid_price - engine["inventory"]["avg_buy_price"]) * engine["inventory"]["current_position"]
        else:
            # Short position
            engine["inventory"]["unrealized_pnl"] = (engine["inventory"]["avg_sell_price"] - mid_price) * abs(engine["inventory"]["current_position"])

    logger.info("=" * 60)
    logger.info("SIMULATION COMPLETE")
    logger.info("=" * 60)

    return engine

logger.info("--- Market Maker Simulation ---")

engine = run_market_maker_simulation(
    symbol="BTCUSDT",
    duration_seconds=240,  # Run for 4 minutes (240 seconds) for more data
    initial_price=65000.0, # Adjusted to a higher BTC price point
    order_quantity=0.1,    # Slightly increased order quantity
    base_spread_bps=3.0,
    max_position=1.0,      # Increased max position
    quote_interval=1.0,    # Increased quoting frequency
)

# Display performance summary
print("\n")
logger.info("--- Performance Summary ---")
perf_df = get_performance_summary(engine)
print("### Market Maker Performance Summary")
display(perf_df)

# Display trade history
logger.info("--- Trade History ---")
trade_df = get_trade_history_df(engine)
print("### Recent Trade History")
if not trade_df.empty:
    display(trade_df[["datetime", "side", "price", "quantity", "position_after", "realized_pnl"]].tail(20)) # Display last 20 trades
else:
    print("No trades executed during simulation")

# Display inventory history
logger.info("--- Inventory History ---")
inv_df = get_inventory_history_df(engine)
print("### Recent Inventory Snapshots")
if not inv_df.empty:
    display(inv_df[["datetime", "position", "realized_pnl", "mid_price"]].tail(20)) # Display last 20 inventory snapshots
else:
    print("No inventory snapshots available")

import matplotlib.pyplot as plt
import seaborn as sns

# Ensure inv_df is available and has data
if 'inv_df' in locals() and not inv_df.empty:
    fig, axes = plt.subplots(3, 1, figsize=(14, 12), sharex=True)

    # Plot 1: Inventory Position Over Time
    sns.lineplot(ax=axes[0], x='datetime', y='position', data=inv_df, marker='o', markersize=4, label='Position')
    axes[0].axhline(0, color='grey', linestyle='--', linewidth=0.7)
    axes[0].set_title('Inventory Position Over Time')
    axes[0].set_ylabel('Position (BTC)')
    axes[0].legend()
    axes[0].grid(True, linestyle='--', alpha=0.6)

    # Plot 2: Realized PnL Over Time
    sns.lineplot(ax=axes[1], x='datetime', y='realized_pnl', data=inv_df, marker='o', markersize=4, color='green', label='Realized PnL')
    axes[1].axhline(0, color='grey', linestyle='--', linewidth=0.7)
    axes[1].set_title('Realized PnL Over Time')
    axes[1].set_ylabel('Realized PnL (USD)')
    axes[1].legend()
    axes[1].grid(True, linestyle='--', alpha=0.6)

    # Plot 3: Mid-Price Over Time
    sns.lineplot(ax=axes[2], x='datetime', y='mid_price', data=inv_df, marker='o', markersize=4, color='purple', label='Mid-Price')
    axes[2].set_title('Mid-Price Over Time')
    axes[2].set_ylabel('Mid-Price (USD)')
    axes[2].set_xlabel('Time')
    axes[2].legend()
    axes[2].grid(True, linestyle='--', alpha=0.6)

    plt.tight_layout()
    plt.show()
else:
    print("Inventory history DataFrame (inv_df) is empty or not available for plotting.")