engine/

backtest.rs

use crate::data_source::DataSource;
use crate::engine::Engine;
use crate::matcher::Matcher;
use crate::types::{DEFAULT_AGENT, Side};

#[derive(Debug, Clone)]
pub struct BacktestResult {
    pub total_return: f64,
    pub annualized_return: f64,
    pub volatility: f64,
    pub sharpe_ratio: f64,
    pub sortino_ratio: f64,
    pub max_drawdown: f64,
    pub total_trades: usize,
    pub final_equity: f64,
    pub mean_inventory: f64,
    pub max_inventory: f64,
    pub min_inventory: f64,
    pub adverse_selection_bps: f64,
    pub realized_edge_bps: f64,
    pub volatility_path: Option<Vec<f64>>,
    /// Var(q) = (1/T) sum (q_t - q_bar)^2
    pub inventory_variance: f64,
    /// PnL_spread = sum |P_i - S_{t_i}| in price units
    pub pnl_spread: f64,
    /// PnL_dir = sum q_{t-1} * (S_t - S_{t-1}) in price units
    pub pnl_dir: f64,
    /// Number of buy fills
    pub fill_buy_count: usize,
    /// Number of sell fills
    pub fill_sell_count: usize,
    /// Mean steps with non-zero inventory per hold episode
    pub mean_hold_time: f64,
    /// Terminal liquidation cost: |final_q| * half_spread (0 if not applied)
    pub terminal_liquidation_cost: f64,
}

impl std::fmt::Display for BacktestResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "--- Backtest Results ---")?;
        writeln!(f, "Total Return:        {:.2}%", self.total_return * 100.0)?;
        writeln!(
            f,
            "Annualized Return:   {:.2}%",
            self.annualized_return * 100.0
        )?;
        writeln!(f, "Volatility:          {:.2}%", self.volatility * 100.0)?;
        writeln!(f, "Sharpe Ratio:        {:.2}", self.sharpe_ratio)?;
        writeln!(f, "Sortino Ratio:       {:.2}", self.sortino_ratio)?;
        writeln!(f, "Max Drawdown:        {:.2}%", self.max_drawdown * 100.0)?;
        writeln!(f, "Total Trades:        {}", self.total_trades)?;
        writeln!(f, "Final Equity:        {:.2}", self.final_equity)?;
        writeln!(f, "Mean Inventory:      {:.2}", self.mean_inventory)?;
        writeln!(f, "Max Inventory:       {:.2}", self.max_inventory)?;
        writeln!(f, "Min Inventory:       {:.2}", self.min_inventory)?;
        writeln!(
            f,
            "Adverse Selection:   {:.2} bps",
            self.adverse_selection_bps
        )?;
        writeln!(f, "Realized Edge:       {:.2} bps", self.realized_edge_bps)?;
        writeln!(f, "Inventory Variance:  {:.4}", self.inventory_variance)?;
        writeln!(f, "PnL Spread:          {:.4}", self.pnl_spread)?;
        writeln!(f, "PnL Directional:     {:.4}", self.pnl_dir)?;
        writeln!(f, "Fill Buy Count:      {}", self.fill_buy_count)?;
        writeln!(f, "Fill Sell Count:     {}", self.fill_sell_count)?;
        writeln!(f, "Mean Hold Time:      {:.2} steps", self.mean_hold_time)?;
        writeln!(
            f,
            "Terminal Liq. Cost:  {:.4}",
            self.terminal_liquidation_cost
        )?;
        Ok(())
    }
}

/// Default adverse selection lookback (steps after fill).
const DEFAULT_LOOKBACK: usize = 10;

/// Run backtest with the default adverse selection lookback (10 steps).
pub fn run_backtest<M, D>(engine: &mut Engine<M, D>, dt_years: f64) -> BacktestResult
where
    M: Matcher,
    D: DataSource,
{
    run_backtest_impl(engine, dt_years, DEFAULT_LOOKBACK, None)
}

/// Run backtest with terminal liquidation applied uniformly at the end.
/// `liquidation_half_spread` is the half-spread cost per unit of residual
/// inventory: `|final_q| * liquidation_half_spread` is deducted from both
/// `pnl_spread` and `final_equity` so all strategies are evaluated on equal
/// footing regardless of whether they have their own terminal flattening logic.
pub fn run_backtest_with_liquidation<M, D>(
    engine: &mut Engine<M, D>,
    dt_years: f64,
    liquidation_half_spread: f64,
) -> BacktestResult
where
    M: Matcher,
    D: DataSource,
{
    run_backtest_impl(
        engine,
        dt_years,
        DEFAULT_LOOKBACK,
        Some(liquidation_half_spread),
    )
}

/// Run backtest with a custom adverse selection lookback for computing M(k).
pub fn run_backtest_lookback<M, D>(
    engine: &mut Engine<M, D>,
    dt_years: f64,
    lookback: usize,
) -> BacktestResult
where
    M: Matcher,
    D: DataSource,
{
    run_backtest_impl(engine, dt_years, lookback, None)
}

fn run_backtest_impl<M, D>(
    engine: &mut Engine<M, D>,
    dt_years: f64,
    lookback: usize,
    liquidation_half_spread: Option<f64>,
) -> BacktestResult
where
    M: Matcher,
    D: DataSource,
{
    let initial_cash = engine.get_portfolio().cash;
    let mut max_equity = initial_cash;
    let mut max_drawdown = 0.0;

    let mut prev_equity = initial_cash;

    // Statistics accumulators
    let mut sum_returns = 0.0;
    let mut sum_sq_returns = 0.0;
    let mut sum_downside_sq = 0.0;
    let mut count_returns = 0.0;

    let mut sum_inventory = 0.0;
    let mut sum_inventory_sq = 0.0;
    let mut max_inventory = 0.0;
    let mut min_inventory = 0.0;
    let mut count_steps = 0.0;

    // Directional PnL: sum q_{t-1} * (S_t - S_{t-1})
    let mut pnl_dir_val = 0.0;
    let mut prev_pos = 0.0_f64;
    let mut prev_price = 0.0_f64;

    // Hold time: consecutive steps with non-zero inventory
    let mut hold_duration: usize = 0;
    let mut hold_times: Vec<usize> = Vec::new();

    let mut volatility_path = Vec::with_capacity(5000);

    // Fill-quality tracking
    let mut mid_prices: Vec<f64> = Vec::with_capacity(5000);
    // (step_index, side, fill_price, mid_at_fill)
    let mut fill_records: Vec<(usize, Side, f64, f64)> = Vec::new();
    let mut step_idx: usize = 0;

    while engine.step() {
        let portfolio = engine.get_portfolio();
        let last_state = engine.get_last_state();

        let price = if let Some(state) = last_state {
            if let Some(vol) = state.true_volatility {
                volatility_path.push(vol);
            }
            (state.best_bid + state.best_ask) / 2.0
        } else {
            0.0
        };

        mid_prices.push(price);

        // Collect fills from this step (for default agent)
        for (agent_id, fill) in engine.last_step_fills() {
            if *agent_id == DEFAULT_AGENT {
                fill_records.push((step_idx, fill.side, fill.price, price));
            }
        }

        // Mark to market
        let equity = portfolio.cash + portfolio.position * price;

        // Update Max Drawdown
        if equity > max_equity {
            max_equity = equity;
        } else {
            let drawdown = (max_equity - equity) / max_equity;
            if drawdown > max_drawdown {
                max_drawdown = drawdown;
            }
        }

        // Update Inventory Stats
        let pos = portfolio.position;
        sum_inventory += pos;
        sum_inventory_sq += pos * pos;
        if pos > max_inventory {
            max_inventory = pos;
        }
        if pos < min_inventory {
            min_inventory = pos;
        }
        count_steps += 1.0;

        // Directional PnL: q_{t-1} * (S_t - S_{t-1})
        // prev_pos is zero on iteration 0, so the first dS is ignored safely.
        let d_price = price - prev_price;
        pnl_dir_val += prev_pos * d_price;

        // Hold time tracking: record run length when inventory returns to zero.
        if pos.abs() < 1e-9 {
            if hold_duration > 0 {
                hold_times.push(hold_duration);
                hold_duration = 0;
            }
        } else {
            hold_duration += 1;
        }

        // Update Return Stats
        if prev_equity.abs() > 1e-9 {
            let r = (equity - prev_equity) / prev_equity;
            sum_returns += r;
            sum_sq_returns += r * r;
            // Downside deviation: only count negative returns
            if r < 0.0 {
                sum_downside_sq += r * r;
            }
            count_returns += 1.0;
        }

        prev_equity = equity;
        prev_pos = pos;
        prev_price = price;
        step_idx += 1;
    }

    // Close any open hold episode at end of simulation.
    if hold_duration > 0 {
        hold_times.push(hold_duration);
    }
    let mean_hold_time = if hold_times.is_empty() {
        0.0
    } else {
        hold_times.iter().sum::<usize>() as f64 / hold_times.len() as f64
    };

    // Apply uniform terminal liquidation cost if requested.
    // Deduct |final_q| * half_spread from both pnl_spread and final_equity
    // so that all strategies are penalised equally for residual inventory.
    let terminal_liquidation_cost = if let Some(hs) = liquidation_half_spread {
        prev_pos.abs() * hs
    } else {
        0.0
    };
    let final_equity = prev_equity - terminal_liquidation_cost;
    let total_return = (final_equity - initial_cash) / initial_cash;

    let mean_inventory = if count_steps > 0.0 {
        sum_inventory / count_steps
    } else {
        0.0
    };
    let inventory_variance = if count_steps > 0.0 {
        (sum_inventory_sq / count_steps - mean_inventory * mean_inventory).max(0.0)
    } else {
        0.0
    };

    let (mean_return, std_dev) = if count_returns > 1.0 {
        let mean = sum_returns / count_returns;
        let variance =
            (sum_sq_returns - (sum_returns * sum_returns) / count_returns) / (count_returns - 1.0);
        let variance = variance.max(0.0);
        (mean, variance.sqrt())
    } else {
        (0.0, 0.0)
    };

    let downside_deviation = if count_returns > 1.0 {
        (sum_downside_sq / count_returns).sqrt()
    } else {
        0.0
    };

    let steps_per_year = 1.0 / dt_years;
    let annualized_return = mean_return * steps_per_year;
    let annualized_volatility = std_dev * steps_per_year.sqrt();
    let annualized_downside = downside_deviation * steps_per_year.sqrt();

    let sharpe_ratio = if annualized_volatility > 0.0 {
        annualized_return / annualized_volatility
    } else {
        0.0
    };

    let sortino_ratio = if annualized_downside > 0.0 {
        annualized_return / annualized_downside
    } else {
        0.0
    };

    // Fill-quality metrics computed post-loop from fill_records.
    let mut total_as = 0.0;
    let mut as_count = 0usize;
    let mut total_edge = 0.0;
    let mut edge_count = 0usize;
    let mut pnl_spread_val = 0.0;
    let mut fill_buy_count = 0usize;
    let mut fill_sell_count = 0usize;

    for &(step, side, fill_price, mid_at_fill) in &fill_records {
        // Adverse selection: post-trade mid movement (M(k) with k = lookback)
        if !mid_prices.is_empty() {
            let future_step = (step + lookback).min(mid_prices.len() - 1);
            let future_mid = mid_prices[future_step];
            let as_value = match side {
                Side::Buy => future_mid - mid_at_fill,
                Side::Sell => mid_at_fill - future_mid,
            };
            if mid_at_fill.abs() > 1e-9 {
                total_as += as_value / mid_at_fill * 10000.0;
                as_count += 1;
            }
        }
        // Realized edge: |P_i - S_{t_i}| in bps (passive fill is profitable side)
        let edge = match side {
            Side::Buy => mid_at_fill - fill_price,
            Side::Sell => fill_price - mid_at_fill,
        };
        if mid_at_fill.abs() > 1e-9 {
            total_edge += edge / mid_at_fill * 10000.0;
            edge_count += 1;
        }
        // PnL_spread: signed passive-spread captured per fill.
        // Positive for passive fills (bought below mid / sold above mid);
        // negative for aggressive fills (crossed the spread as a taker).
        // Using the same signed-edge convention as realized_edge_bps avoids
        // double-counting aggressive fill COSTS as gains.
        pnl_spread_val += edge;
        match side {
            Side::Buy => fill_buy_count += 1,
            Side::Sell => fill_sell_count += 1,
        }
    }

    let adverse_selection_bps = if as_count > 0 {
        total_as / as_count as f64
    } else {
        0.0
    };
    let realized_edge_bps = if edge_count > 0 {
        total_edge / edge_count as f64
    } else {
        0.0
    };

    // Deduct terminal liquidation cost from spread PnL so the metric reflects
    // the cost of crossing the spread to flatten residual inventory.
    pnl_spread_val -= terminal_liquidation_cost;

    BacktestResult {
        total_return,
        annualized_return,
        volatility: annualized_volatility,
        sharpe_ratio,
        sortino_ratio,
        max_drawdown,
        total_trades: engine.total_fills,
        final_equity,
        inventory_variance,
        pnl_spread: pnl_spread_val,
        pnl_dir: pnl_dir_val,
        fill_buy_count,
        fill_sell_count,
        mean_hold_time,
        terminal_liquidation_cost,
        mean_inventory,
        max_inventory,
        min_inventory,
        adverse_selection_bps,
        realized_edge_bps,
        volatility_path: if volatility_path.is_empty() {
            None
        } else {
            Some(volatility_path)
        },
    }
}

pub struct BacktestSummary {
    pub mean_total_return: f64,
    pub std_dev_total_return: f64,
    pub mean_sharpe_ratio: f64,
    pub std_dev_sharpe_ratio: f64,
    pub mean_sortino_ratio: f64,
    pub mean_max_drawdown: f64,
    pub mean_inventory: f64,
    pub mean_max_inventory: f64,
    pub mean_min_inventory: f64,
    pub mean_total_trades: f64,
    pub abs_max_inventory: f64,
    pub abs_min_inventory: f64,
    pub mean_adverse_selection_bps: f64,
    pub mean_realized_edge_bps: f64,
    pub total_trajectories: usize,
    /// Mean Var(q) = (1/T) sum (q_t - q_bar)^2 across paths
    pub mean_inventory_variance: f64,
    /// Mean PnL_spread = sum |P_i - S_{t_i}| in price units
    pub mean_pnl_spread: f64,
    /// Mean PnL_dir = sum q_{t-1}*(S_t - S_{t-1}) in price units
    pub mean_pnl_dir: f64,
    /// Mean fill rate asymmetry N_buy / N_sell (0 if no sells)
    pub mean_fill_asymmetry: f64,
    /// Mean hold time (steps per non-zero inventory episode)
    pub mean_hold_time: f64,
    // ----- Per-metric standard deviations (across paths) -----
    pub std_sortino_ratio: f64,
    pub std_max_drawdown: f64,
    pub std_inventory_variance: f64,
    pub std_pnl_spread: f64,
    pub std_pnl_dir: f64,
    pub std_fill_asymmetry: f64,
    pub std_hold_time: f64,
    pub std_adverse_selection_bps: f64,
    pub std_realized_edge_bps: f64,
    pub std_total_trades: f64,
    /// Mean of max(|q_max|, |q_min|) per path (distributional peak inventory)
    pub mean_abs_peak_inventory: f64,
    /// Std of abs peak inventory across paths
    pub std_abs_peak_inventory: f64,
}

impl BacktestSummary {
    pub fn new(results: &[BacktestResult]) -> Self {
        let n = results.len() as f64;
        if n == 0.0 {
            return Self {
                mean_total_return: 0.0,
                std_dev_total_return: 0.0,
                mean_sharpe_ratio: 0.0,
                std_dev_sharpe_ratio: 0.0,
                mean_sortino_ratio: 0.0,
                mean_max_drawdown: 0.0,
                mean_inventory: 0.0,
                mean_max_inventory: 0.0,
                mean_min_inventory: 0.0,
                mean_total_trades: 0.0,
                abs_max_inventory: 0.0,
                abs_min_inventory: 0.0,
                mean_adverse_selection_bps: 0.0,
                mean_realized_edge_bps: 0.0,
                total_trajectories: 0,
                mean_inventory_variance: 0.0,
                mean_pnl_spread: 0.0,
                mean_pnl_dir: 0.0,
                mean_fill_asymmetry: 0.0,
                mean_hold_time: 0.0,
                std_sortino_ratio: 0.0,
                std_max_drawdown: 0.0,
                std_inventory_variance: 0.0,
                std_pnl_spread: 0.0,
                std_pnl_dir: 0.0,
                std_fill_asymmetry: 0.0,
                std_hold_time: 0.0,
                std_adverse_selection_bps: 0.0,
                std_realized_edge_bps: 0.0,
                std_total_trades: 0.0,
                mean_abs_peak_inventory: 0.0,
                std_abs_peak_inventory: 0.0,
            };
        }

        let mean_total_return = results.iter().map(|r| r.total_return).sum::<f64>() / n;
        let var_total_return = results
            .iter()
            .map(|r| (r.total_return - mean_total_return).powi(2))
            .sum::<f64>()
            / n;
        let std_dev_total_return = var_total_return.sqrt();

        let mean_sharpe_ratio = results.iter().map(|r| r.sharpe_ratio).sum::<f64>() / n;
        let var_sharpe_ratio = results
            .iter()
            .map(|r| (r.sharpe_ratio - mean_sharpe_ratio).powi(2))
            .sum::<f64>()
            / n;
        let std_dev_sharpe_ratio = var_sharpe_ratio.sqrt();

        let mean_sortino_ratio = results.iter().map(|r| r.sortino_ratio).sum::<f64>() / n;
        let mean_max_drawdown = results.iter().map(|r| r.max_drawdown).sum::<f64>() / n;

        let std_sortino_ratio = {
            let m = mean_sortino_ratio;
            (results
                .iter()
                .map(|r| (r.sortino_ratio - m).powi(2))
                .sum::<f64>()
                / n)
                .sqrt()
        };
        let std_max_drawdown = {
            let m = mean_max_drawdown;
            (results
                .iter()
                .map(|r| (r.max_drawdown - m).powi(2))
                .sum::<f64>()
                / n)
                .sqrt()
        };

        let mean_inventory = results.iter().map(|r| r.mean_inventory).sum::<f64>() / n;
        let mean_max_inventory = results.iter().map(|r| r.max_inventory).sum::<f64>() / n;
        let mean_min_inventory = results.iter().map(|r| r.min_inventory).sum::<f64>() / n;
        let mean_total_trades = results.iter().map(|r| r.total_trades as f64).sum::<f64>() / n;
        let std_total_trades = {
            let m = mean_total_trades;
            (results
                .iter()
                .map(|r| (r.total_trades as f64 - m).powi(2))
                .sum::<f64>()
                / n)
                .sqrt()
        };

        let abs_max_inventory = results
            .iter()
            .fold(f64::NEG_INFINITY, |a, r| a.max(r.max_inventory));
        let abs_min_inventory = results
            .iter()
            .fold(f64::INFINITY, |a, r| a.min(r.min_inventory));

        // Per-path absolute peak inventory: max(|q_max|, |q_min|) for each path.
        let abs_peak_per_path: Vec<f64> = results
            .iter()
            .map(|r| r.max_inventory.abs().max(r.min_inventory.abs()))
            .collect();
        let mean_abs_peak_inventory = abs_peak_per_path.iter().sum::<f64>() / n;
        let std_abs_peak_inventory = {
            let m = mean_abs_peak_inventory;
            (abs_peak_per_path
                .iter()
                .map(|x| (x - m).powi(2))
                .sum::<f64>()
                / n)
                .sqrt()
        };

        let mean_adverse_selection_bps =
            results.iter().map(|r| r.adverse_selection_bps).sum::<f64>() / n;
        let mean_realized_edge_bps = results.iter().map(|r| r.realized_edge_bps).sum::<f64>() / n;
        let std_adverse_selection_bps = {
            let m = mean_adverse_selection_bps;
            (results
                .iter()
                .map(|r| (r.adverse_selection_bps - m).powi(2))
                .sum::<f64>()
                / n)
                .sqrt()
        };
        let std_realized_edge_bps = {
            let m = mean_realized_edge_bps;
            (results
                .iter()
                .map(|r| (r.realized_edge_bps - m).powi(2))
                .sum::<f64>()
                / n)
                .sqrt()
        };

        let mean_inventory_variance = results.iter().map(|r| r.inventory_variance).sum::<f64>() / n;
        let std_inventory_variance = {
            let m = mean_inventory_variance;
            (results
                .iter()
                .map(|r| (r.inventory_variance - m).powi(2))
                .sum::<f64>()
                / n)
                .sqrt()
        };

        let mean_pnl_spread = results.iter().map(|r| r.pnl_spread).sum::<f64>() / n;
        let std_pnl_spread = {
            let m = mean_pnl_spread;
            (results
                .iter()
                .map(|r| (r.pnl_spread - m).powi(2))
                .sum::<f64>()
                / n)
                .sqrt()
        };

        let mean_pnl_dir = results.iter().map(|r| r.pnl_dir).sum::<f64>() / n;
        let std_pnl_dir = {
            let m = mean_pnl_dir;
            (results.iter().map(|r| (r.pnl_dir - m).powi(2)).sum::<f64>() / n).sqrt()
        };

        let mean_hold_time = results.iter().map(|r| r.mean_hold_time).sum::<f64>() / n;
        let std_hold_time = {
            let m = mean_hold_time;
            (results
                .iter()
                .map(|r| (r.mean_hold_time - m).powi(2))
                .sum::<f64>()
                / n)
                .sqrt()
        };

        // Fill asymmetry per path (filter inf before computing std).
        let asym_vals: Vec<f64> = results
            .iter()
            .map(|r| {
                if r.fill_sell_count > 0 {
                    r.fill_buy_count as f64 / r.fill_sell_count as f64
                } else if r.fill_buy_count > 0 {
                    f64::INFINITY
                } else {
                    1.0
                }
            })
            .filter(|v| v.is_finite())
            .collect();
        let n_asym = asym_vals.len() as f64;
        let mean_fill_asymmetry = if n_asym > 0.0 {
            asym_vals.iter().sum::<f64>() / n_asym
        } else {
            1.0
        };
        let std_fill_asymmetry = if n_asym > 1.0 {
            let m = mean_fill_asymmetry;
            (asym_vals.iter().map(|x| (x - m).powi(2)).sum::<f64>() / n_asym).sqrt()
        } else {
            0.0
        };

        Self {
            mean_total_return,
            std_dev_total_return,
            mean_sharpe_ratio,
            std_dev_sharpe_ratio,
            mean_sortino_ratio,
            mean_max_drawdown,
            mean_inventory,
            mean_max_inventory,
            mean_min_inventory,
            mean_total_trades,
            abs_max_inventory,
            abs_min_inventory,
            mean_adverse_selection_bps,
            mean_realized_edge_bps,
            total_trajectories: results.len(),
            mean_inventory_variance,
            mean_pnl_spread,
            mean_pnl_dir,
            mean_fill_asymmetry,
            mean_hold_time,
            std_sortino_ratio,
            std_max_drawdown,
            std_inventory_variance,
            std_pnl_spread,
            std_pnl_dir,
            std_fill_asymmetry,
            std_hold_time,
            std_adverse_selection_bps,
            std_realized_edge_bps,
            std_total_trades,
            mean_abs_peak_inventory,
            std_abs_peak_inventory,
        }
    }

    pub fn print(&self, description: &str) {
        println!("\n--- Backtest Summary: {} ---", description);
        if self.total_trajectories == 1 {
            println!("(Single Trajectory / Historical Data)");
            println!("Total Return:        {:.6}", self.mean_total_return);
            println!("Sharpe Ratio:        {:.4}", self.mean_sharpe_ratio);
            println!("Sortino Ratio:       {:.4}", self.mean_sortino_ratio);
            println!("Max Drawdown:        {:.4}", self.mean_max_drawdown);
            println!("Mean Inventory:      {:.2}", self.mean_inventory);
            println!("Max Inventory:       {:.0}", self.mean_max_inventory);
            println!("Min Inventory:       {:.0}", self.mean_min_inventory);
            println!("Total Trades:        {:.0}", self.mean_total_trades);
            println!(
                "Adverse Selection:   {:.2} bps",
                self.mean_adverse_selection_bps
            );
            println!(
                "Realized Edge:       {:.2} bps",
                self.mean_realized_edge_bps
            );
            println!("Inventory Variance:  {:.4}", self.mean_inventory_variance);
            println!("PnL Spread:          {:.4}", self.mean_pnl_spread);
            println!("PnL Directional:     {:.4}", self.mean_pnl_dir);
            println!("Fill Asymmetry:      {:.4}", self.mean_fill_asymmetry);
            println!("Mean Hold Time:      {:.2} steps", self.mean_hold_time);
        } else {
            println!("Trajectories:        {}", self.total_trajectories);
            println!("Mean Total Return:   {:.6}", self.mean_total_return);
            println!("Std Dev Return:      {:.6}", self.std_dev_total_return);
            println!("Mean Sharpe Ratio:   {:.4}", self.mean_sharpe_ratio);
            println!("Std Dev Sharpe:      {:.4}", self.std_dev_sharpe_ratio);
            println!("Mean Sortino Ratio:  {:.4}", self.mean_sortino_ratio);
            println!("Mean Max Drawdown:   {:.4}", self.mean_max_drawdown);
            println!("Mean Inventory:      {:.2}", self.mean_inventory);
            println!("Mean Max Inv:        {:.2}", self.mean_max_inventory);
            println!("Mean Min Inv:        {:.2}", self.mean_min_inventory);
            println!("Abs Max Inv:         {:.0}", self.abs_max_inventory);
            println!("Abs Min Inv:         {:.0}", self.abs_min_inventory);
            println!("Mean Trades:         {:.1}", self.mean_total_trades);
            println!(
                "Mean Adverse Sel:    {:.2} bps",
                self.mean_adverse_selection_bps
            );
            println!(
                "Mean Realized Edge:  {:.2} bps",
                self.mean_realized_edge_bps
            );
            println!("Inv Variance:        {:.4}", self.mean_inventory_variance);
            println!("PnL Spread:          {:.4}", self.mean_pnl_spread);
            println!("PnL Directional:     {:.4}", self.mean_pnl_dir);
            println!("Fill Asymmetry:      {:.4}", self.mean_fill_asymmetry);
            println!("Mean Hold Time:      {:.2} steps", self.mean_hold_time);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::matcher::SimpleMatcher;
    use crate::strategies::Strategy;
    use crate::types::{Observation, Order, OrderRequest};

    struct FixedDataSource {
        ticks: usize,
    }
    impl crate::data_source::DataSource for FixedDataSource {
        fn next_quote(&mut self) -> Option<crate::types::MarketState> {
            if self.ticks == 0 {
                return None;
            }
            self.ticks -= 1;
            Some(crate::types::MarketState {
                timestamp: 0.0,
                best_bid: 99.0,
                best_ask: 101.0,
                last_price: Some(100.0),
                true_volatility: Some(0.2),
                true_drift: None,
                parameters: None,
            })
        }
    }

    struct SpreadCaptureStrategy {
        counter: u64,
    }
    impl Strategy for SpreadCaptureStrategy {
        fn on_tick(&mut self, obs: &Observation, requests: &mut Vec<OrderRequest>) {
            // Place aggressive buy and sell every tick (crosses spread)
            self.counter += 1;
            requests.push(OrderRequest::CancelAll);
            requests.push(OrderRequest::New(Order::new(
                self.counter * 2,
                Side::Buy,
                obs.best_ask + 0.01,
                1.0,
            )));
            self.counter += 1;
            requests.push(OrderRequest::New(Order::new(
                self.counter * 2 + 1,
                Side::Sell,
                obs.best_bid - 0.01,
                1.0,
            )));
        }

        fn as_any(&self) -> &dyn std::any::Any {
            self
        }
        fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
            self
        }
    }

    #[test]
    fn test_backtest_returns_valid_metrics() {
        let matcher = SimpleMatcher::new();
        let strategy = SpreadCaptureStrategy { counter: 0 };
        let data_source = FixedDataSource { ticks: 100 };
        let mut engine = crate::engine::Engine::new(matcher, strategy, data_source, 100000.0, 0.0);

        let result = run_backtest(&mut engine, 1.0 / 252.0);

        assert!(result.total_trades > 0);
        assert!(result.volatility >= 0.0);
        assert!(result.max_drawdown >= 0.0);
        assert!(result.max_drawdown <= 1.0);
        // Sortino should be computed (may be 0 if no downside)
        assert!(result.sortino_ratio.is_finite());
        // Adverse selection and realized edge should be finite
        assert!(result.adverse_selection_bps.is_finite());
        assert!(result.realized_edge_bps.is_finite());
    }

    #[test]
    fn test_realized_edge_for_aggressive_trades() {
        // Aggressive buys at ask (101), mid = 100 -> edge = 100 - 101 = -1 -> negative bps
        // Aggressive sells at bid (99), mid = 100 -> edge = 99 - 100 = -1 -> negative bps
        let matcher = SimpleMatcher::new();
        let strategy = SpreadCaptureStrategy { counter: 0 };
        let data_source = FixedDataSource { ticks: 50 };
        let mut engine = crate::engine::Engine::new(matcher, strategy, data_source, 100000.0, 0.0);

        let result = run_backtest(&mut engine, 1.0 / 252.0);

        // Aggressive crossing should have negative realized edge (paying the spread)
        assert!(
            result.realized_edge_bps < 0.0,
            "Aggressive trades should have negative realized edge, got {:.2} bps",
            result.realized_edge_bps
        );
    }

    #[test]
    fn test_backtest_summary() {
        let results = vec![
            BacktestResult {
                total_return: 0.05,
                annualized_return: 0.10,
                volatility: 0.15,
                sharpe_ratio: 0.67,
                sortino_ratio: 0.80,
                max_drawdown: 0.03,
                total_trades: 100,
                final_equity: 10500.0,
                mean_inventory: 1.0,
                max_inventory: 5.0,
                min_inventory: -3.0,
                adverse_selection_bps: -2.0,
                realized_edge_bps: 5.0,
                volatility_path: None,
                inventory_variance: 2.0,
                pnl_spread: 10.0,
                pnl_dir: 3.0,
                fill_buy_count: 50,
                fill_sell_count: 50,
                mean_hold_time: 5.0,
                terminal_liquidation_cost: 0.0,
            },
            BacktestResult {
                total_return: -0.02,
                annualized_return: -0.04,
                volatility: 0.20,
                sharpe_ratio: -0.20,
                sortino_ratio: -0.15,
                max_drawdown: 0.08,
                total_trades: 80,
                final_equity: 9800.0,
                mean_inventory: -0.5,
                max_inventory: 3.0,
                min_inventory: -4.0,
                adverse_selection_bps: -5.0,
                realized_edge_bps: 3.0,
                volatility_path: None,
                inventory_variance: 1.5,
                pnl_spread: 8.0,
                pnl_dir: -2.0,
                fill_buy_count: 40,
                fill_sell_count: 40,
                mean_hold_time: 4.0,
                terminal_liquidation_cost: 0.0,
            },
        ];

        let summary = BacktestSummary::new(&results);
        assert_eq!(summary.total_trajectories, 2);
        assert!((summary.mean_total_return - 0.015).abs() < 1e-10);
        assert!((summary.mean_adverse_selection_bps - (-3.5)).abs() < 1e-10);
        assert!((summary.mean_realized_edge_bps - 4.0).abs() < 1e-10);
        assert!((summary.mean_sortino_ratio - 0.325).abs() < 1e-10);
    }
}