Performance Metrics

pub struct BacktestMetrics {
    pub total_pnl: f64,
    pub realized_pnl: f64,
    pub unrealized_pnl: f64,
    pub total_fees: f64,
    pub num_trades: u32,
    pub winning_trades: u32,
    pub losing_trades: u32,
    pub gross_profit: f64,
    pub gross_loss: f64,
    pub max_drawdown_pct: f64,
    pub max_drawdown_abs: f64,
    pub peak_pnl: f64,
    pub total_volume: u64,
    pub buy_fills: u32,
    pub sell_fills: u32,
    pub maker_fills: u32,
    pub taker_fills: u32,
    pub avg_fill_latency_ns: f64,
    pub start_time: Option<Timestamp>,
    pub end_time: Option<Timestamp>,
}

pub fn new() -> Self

pub fn win_rate(&self) -> f64

let metrics = engine.metrics();
println!("Win Rate: {:.2}%", metrics.win_rate() * 100.0);

pub fn profit_factor(&self) -> f64

pub fn avg_trade_pnl(&self) -> f64

pub fn avg_winning_trade(&self) -> f64

pub fn avg_losing_trade(&self) -> f64

pub fn maker_ratio(&self) -> f64

pub fn record_fill(&mut self, fill: &Fill)

pub fn record_trade(&mut self, pnl: f64)

pub fn update_pnl(&mut self, total_pnl: f64, realized: f64, unrealized: f64)

pub fn duration_secs(&self) -> f64

pub struct PerformanceStats {
    pub daily_returns: Vec<f64>,
    pub equity_curve: Vec<f64>,
    pub equity_timestamps: Vec<i64>,
    pub trade_pnls: Vec<f64>,
    pub sharpe_ratio: f64,
    pub sortino_ratio: f64,
    pub calmar_ratio: f64,
    pub max_consecutive_wins: u32,
    pub max_consecutive_losses: u32,
    pub recovery_factor: f64,
}

pub fn new() -> Self

pub fn add_equity_point(&mut self, timestamp: i64, pnl: f64)

pub fn add_daily_return(&mut self, ret: f64)

pub fn add_trade_pnl(&mut self, pnl: f64)

pub fn calculate(&mut self, initial_capital: f64, max_drawdown: f64)

pub struct RollingStats {
    window_size: usize,
    values: VecDeque<f64>,
    sum: f64,
    sum_sq: f64,
}

pub fn new(window_size: usize) -> Self

pub fn add(&mut self, value: f64)

pub fn mean(&self) -> f64

pub fn variance(&self) -> f64

pub fn std_dev(&self) -> f64

pub fn sharpe(&self) -> f64

use nano_backtest::metrics::RollingStats;

let mut rolling = RollingStats::new(20);

for ret in daily_returns {
    rolling.add(ret);
    
    if rolling.is_full() {
        println!("Rolling Sharpe: {:.2}", rolling.sharpe());
    }
}

use nano_backtest::{BacktestConfig, BacktestEngine};

// Run backtest
let config = BacktestConfig::default();
let mut engine = BacktestEngine::new(config);
// ... register instruments and run ...
engine.run(&mut strategy);

// Access metrics
let metrics = engine.metrics();
let stats = engine.stats();

// Basic metrics
println!("=== Performance Summary ===");
println!("Total P&L: ${:.2}", metrics.total_pnl);
println!("Realized P&L: ${:.2}", metrics.realized_pnl);
println!("Total Fees: ${:.2}", metrics.total_fees);
println!("Net P&L: ${:.2}", metrics.realized_pnl - metrics.total_fees);

// Trade statistics
println!("\n=== Trade Statistics ===");
println!("Total Trades: {}", metrics.num_trades);
println!("Win Rate: {:.2}%", metrics.win_rate() * 100.0);
println!("Profit Factor: {:.2}", metrics.profit_factor());
println!("Avg Trade: ${:.2}", metrics.avg_trade_pnl());
println!("Avg Winner: ${:.2}", metrics.avg_winning_trade());
println!("Avg Loser: ${:.2}", metrics.avg_losing_trade());

// Risk metrics
println!("\n=== Risk Metrics ===");
println!("Max Drawdown: {:.2}%", metrics.max_drawdown_pct * 100.0);
println!("Max Drawdown ($): ${:.2}", metrics.max_drawdown_abs);
println!("Peak P&L: ${:.2}", metrics.peak_pnl);

// Risk-adjusted returns
println!("\n=== Risk-Adjusted Returns ===");
println!("Sharpe Ratio: {:.2}", stats.sharpe_ratio);
println!("Sortino Ratio: {:.2}", stats.sortino_ratio);
println!("Calmar Ratio: {:.2}", stats.calmar_ratio);
println!("Recovery Factor: {:.2}", stats.recovery_factor);

// Execution quality
println!("\n=== Execution Quality ===");
println!("Total Volume: {} contracts", metrics.total_volume);
println!("Maker Ratio: {:.2}%", metrics.maker_ratio() * 100.0);
println!("Buy Fills: {}", metrics.buy_fills);
println!("Sell Fills: {}", metrics.sell_fills);

// Streaks
println!("\n=== Streaks ===");
println!("Max Consecutive Wins: {}", stats.max_consecutive_wins);
println!("Max Consecutive Losses: {}", stats.max_consecutive_losses);