hyper_playbook/

backtest.rs

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

#[allow(deprecated)]
use hyper_ta::technical_analysis::calculate_indicators;
use hyper_ta::Candle;

use crate::engine::{PlaybookEngine, TickAction};

// ---------------------------------------------------------------------------
// Data types
// ---------------------------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TradeRecord {
    pub regime: String,
    pub side: String,
    pub entry_price: f64,
    pub exit_price: f64,
    pub pnl: f64,
    pub hold_time_secs: u64,
    pub exit_reason: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BacktestResult {
    pub total_trades: u32,
    pub win_rate: f64,
    pub total_pnl: f64,
    pub max_drawdown: f64,
    pub sharpe_ratio: f64,
    pub avg_hold_time_secs: u64,
    pub regime_distribution: HashMap<String, u32>,
    pub trades: Vec<TradeRecord>,
    pub total_ticks: u32,
}

// ---------------------------------------------------------------------------
// Internal tracking
// ---------------------------------------------------------------------------

struct OpenTrade {
    regime: String,
    side: String,
    entry_price: f64,
    entry_time: u64,
}

// ---------------------------------------------------------------------------
// BacktestRunner
// ---------------------------------------------------------------------------

pub struct BacktestRunner {
    engine: PlaybookEngine,
}

impl BacktestRunner {
    pub fn new(engine: PlaybookEngine) -> Self {
        Self { engine }
    }

    /// Run backtest over historical candles.
    /// Uses a sliding window of `window_size` candles for indicator calculation.
    pub async fn run(&mut self, candles: &[Candle], window_size: usize) -> BacktestResult {
        let mut trades: Vec<TradeRecord> = Vec::new();
        let mut regime_distribution: HashMap<String, u32> = HashMap::new();
        let mut total_ticks = 0u32;

        // Track open trade state
        let mut open_trade: Option<OpenTrade> = None;

        for i in window_size..candles.len() {
            let window = &candles[i + 1 - window_size..=i];
            #[allow(deprecated)]
            let indicators = calculate_indicators(window);
            let now = candles[i].time;
            let current_price = candles[i].close;

            let tick = self.engine.tick(&indicators, now).await;
            total_ticks += 1;

            // Track regime distribution
            *regime_distribution.entry(tick.regime.clone()).or_insert(0) += 1;

            // Track trades based on TickAction
            match &tick.action {
                TickAction::OrderPlaced { .. } => {
                    // Order placed but not yet filled — nothing to record yet
                }
                TickAction::OrderFilled { entry_price, .. } => {
                    open_trade = Some(OpenTrade {
                        regime: tick.regime.clone(),
                        side: "long".into(), // simplified: PaperOrderExecutor doesn't track side
                        entry_price: *entry_price,
                        entry_time: now,
                    });
                }
                TickAction::PositionClosed { reason } | TickAction::ForceClose { reason } => {
                    if let Some(trade) = open_trade.take() {
                        let pnl = if trade.side == "sell" || trade.side == "short" {
                            trade.entry_price - current_price
                        } else {
                            current_price - trade.entry_price
                        };
                        trades.push(TradeRecord {
                            regime: trade.regime,
                            side: trade.side,
                            entry_price: trade.entry_price,
                            exit_price: current_price,
                            pnl,
                            hold_time_secs: now.saturating_sub(trade.entry_time),
                            exit_reason: reason.clone(),
                        });
                    }
                }
                TickAction::OrderCancelled { .. } | TickAction::None => {}
            }
        }

        // Calculate metrics
        let total_trades = trades.len() as u32;
        let wins = trades.iter().filter(|t| t.pnl > 0.0).count() as f64;
        let win_rate = if total_trades > 0 {
            wins / total_trades as f64
        } else {
            0.0
        };
        let total_pnl: f64 = trades.iter().map(|t| t.pnl).sum();
        let max_drawdown = calculate_max_drawdown(&trades);
        let sharpe_ratio = calculate_sharpe_ratio(&trades);
        let avg_hold_time_secs = if total_trades > 0 {
            trades.iter().map(|t| t.hold_time_secs).sum::<u64>() / total_trades as u64
        } else {
            0
        };

        BacktestResult {
            total_trades,
            win_rate,
            total_pnl,
            max_drawdown,
            sharpe_ratio,
            avg_hold_time_secs,
            regime_distribution,
            trades,
            total_ticks,
        }
    }
}

// ---------------------------------------------------------------------------
// Helper functions
// ---------------------------------------------------------------------------

fn calculate_max_drawdown(trades: &[TradeRecord]) -> f64 {
    let mut equity = 0.0_f64;
    let mut peak = 0.0_f64;
    let mut max_dd = 0.0_f64;
    for trade in trades {
        equity += trade.pnl;
        if equity > peak {
            peak = equity;
        }
        let dd = peak - equity;
        if dd > max_dd {
            max_dd = dd;
        }
    }
    -max_dd // negative number
}

fn calculate_sharpe_ratio(trades: &[TradeRecord]) -> f64 {
    if trades.len() < 2 {
        return 0.0;
    }
    let pnls: Vec<f64> = trades.iter().map(|t| t.pnl).collect();
    let mean = pnls.iter().sum::<f64>() / pnls.len() as f64;
    let variance = pnls.iter().map(|p| (p - mean).powi(2)).sum::<f64>() / (pnls.len() - 1) as f64;
    let std_dev = variance.sqrt();
    if std_dev == 0.0 {
        return 0.0;
    }
    mean / std_dev
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    use crate::executor::PaperOrderExecutor;
    use hyper_strategy::strategy_config::{
        HysteresisConfig, Playbook, RegimeRule, StrategyGroup, TaRule,
    };

    // -- Candle generators --

    /// Generate synthetic candles: trending up, then ranging, then down.
    /// Returns at least 250 candles with 300-second intervals.
    fn generate_synthetic_candles(count: usize) -> Vec<Candle> {
        let mut candles = Vec::with_capacity(count);
        let base_time = 1_700_000_000u64;
        let interval = 300u64;
        let mut price = 50_000.0;

        for i in 0..count {
            let phase = if i < count / 3 {
                // Phase 1: trending up
                1
            } else if i < 2 * count / 3 {
                // Phase 2: ranging
                2
            } else {
                // Phase 3: trending down
                3
            };

            let delta = match phase {
                1 => 50.0 + 20.0 * ((i as f64 * 0.1).sin()),   // uptrend
                2 => 30.0 * ((i as f64 * 0.3).sin()),          // ranging
                3 => -60.0 + 15.0 * ((i as f64 * 0.15).sin()), // downtrend
                _ => 0.0,
            };

            price += delta;
            if price < 1000.0 {
                price = 1000.0;
            }

            let open = price - delta * 0.3;
            let high = price.max(open) + 100.0;
            let low = price.min(open) - 100.0;
            let volume = 1000.0 + 500.0 * ((i as f64 * 0.05).sin()).abs();

            candles.push(Candle {
                time: base_time + (i as u64) * interval,
                open,
                high,
                low,
                close: price,
                volume,
            });
        }

        candles
    }

    // -- Strategy group for tests --

    fn make_ta_rule(
        indicator: &str,
        params: Vec<f64>,
        condition: &str,
        threshold: f64,
        signal: &str,
    ) -> TaRule {
        TaRule {
            indicator: indicator.to_string(),
            params,
            condition: condition.to_string(),
            threshold,
            threshold_upper: None,
            signal: signal.to_string(),
            action: None,
        }
    }

    fn make_ta_rule_between(
        indicator: &str,
        params: Vec<f64>,
        lo: f64,
        hi: f64,
        signal: &str,
    ) -> TaRule {
        TaRule {
            indicator: indicator.to_string(),
            params,
            condition: "between".to_string(),
            threshold: lo,
            threshold_upper: Some(hi),
            signal: signal.to_string(),
            action: None,
        }
    }

    fn simple_strategy_group() -> StrategyGroup {
        let mut playbooks = HashMap::new();

        // bull playbook: entry when RSI > 60, exit when RSI < 40
        playbooks.insert(
            "bull".to_string(),
            Playbook {
                rules: vec![],
                entry_rules: vec![make_ta_rule("RSI", vec![14.0], "gt", 60.0, "buy_momentum")],
                exit_rules: vec![make_ta_rule("RSI", vec![14.0], "lt", 40.0, "momentum_lost")],
                system_prompt: "bull".into(),
                max_position_size: 1000.0,
                stop_loss_pct: Some(5.0),
                take_profit_pct: Some(10.0),
                timeout_secs: Some(600),
                side: Some("buy".into()),
            },
        );

        // bear playbook: zero position size (no trading)
        playbooks.insert(
            "bear".to_string(),
            Playbook {
                rules: vec![],
                entry_rules: vec![],
                exit_rules: vec![],
                system_prompt: "bear".into(),
                max_position_size: 0.0,
                stop_loss_pct: Some(3.0),
                take_profit_pct: None,
                timeout_secs: None,
                side: None,
            },
        );

        // neutral playbook: entry when RSI < 30, exit when RSI between 45-55
        playbooks.insert(
            "neutral".to_string(),
            Playbook {
                rules: vec![],
                entry_rules: vec![make_ta_rule("RSI", vec![14.0], "lt", 30.0, "oversold_buy")],
                exit_rules: vec![make_ta_rule_between(
                    "RSI",
                    vec![14.0],
                    45.0,
                    55.0,
                    "rsi_neutral_exit",
                )],
                system_prompt: "neutral".into(),
                max_position_size: 500.0,
                stop_loss_pct: Some(5.0),
                take_profit_pct: Some(10.0),
                timeout_secs: Some(300),
                side: None,
            },
        );

        StrategyGroup {
            id: "sg-backtest".into(),
            name: "Backtest Test".into(),
            vault_address: None,
            is_active: true,
            created_at: "2026-01-01T00:00:00Z".into(),
            symbol: "BTC-USD".into(),
            interval_secs: 300,
            regime_rules: vec![
                RegimeRule {
                    regime: "bull".into(),
                    conditions: vec![make_ta_rule("ADX", vec![14.0], "gt", 50.0, "strong_bull")],
                    priority: 1,
                },
                RegimeRule {
                    regime: "bear".into(),
                    conditions: vec![make_ta_rule("ADX", vec![14.0], "lt", 10.0, "weak_bear")],
                    priority: 2,
                },
            ],
            default_regime: "neutral".into(),
            hysteresis: HysteresisConfig {
                min_hold_secs: 0,
                confirmation_count: 1,
            },
            playbooks,
        }
    }

    fn new_engine() -> PlaybookEngine {
        PlaybookEngine::new(
            "BTC-USD".into(),
            simple_strategy_group(),
            Box::new(PaperOrderExecutor::new()),
        )
    }

    // -----------------------------------------------------------------------
    // 1. Backtest run with synthetic candles — basic smoke test
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_backtest_run_synthetic_candles() {
        let candles = generate_synthetic_candles(250);
        let engine = new_engine();
        let mut runner = BacktestRunner::new(engine);

        let result = runner.run(&candles, 50).await;

        // We should have processed candles[50..250] = 200 ticks
        assert_eq!(result.total_ticks, 200);
        assert!(
            !result.regime_distribution.is_empty(),
            "regime_distribution should have entries"
        );
    }

    // -----------------------------------------------------------------------
    // 2. BacktestResult serializes to JSON
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_backtest_result_serializes_to_json() {
        let candles = generate_synthetic_candles(250);
        let engine = new_engine();
        let mut runner = BacktestRunner::new(engine);

        let result = runner.run(&candles, 50).await;

        let json = serde_json::to_string(&result).unwrap();
        let parsed: BacktestResult = serde_json::from_str(&json).unwrap();

        assert_eq!(parsed.total_ticks, result.total_ticks);
        assert_eq!(parsed.total_trades, result.total_trades);
        assert!((parsed.total_pnl - result.total_pnl).abs() < 1e-10);
    }

    // -----------------------------------------------------------------------
    // 3. max_drawdown calculation with known values
    // -----------------------------------------------------------------------

    #[test]
    fn test_max_drawdown_known_values() {
        // Trades: +10, -5, +20, -30, +5
        // Equity: 10, 5, 25, -5, 0
        // Peak:   10, 10, 25, 25, 25
        // DD:     0,  5,  0,  30, 25
        // max_dd = -30
        let trades = vec![
            TradeRecord {
                regime: "bull".into(),
                side: "long".into(),
                entry_price: 100.0,
                exit_price: 110.0,
                pnl: 10.0,
                hold_time_secs: 60,
                exit_reason: "exit_rule".into(),
            },
            TradeRecord {
                regime: "bull".into(),
                side: "long".into(),
                entry_price: 110.0,
                exit_price: 105.0,
                pnl: -5.0,
                hold_time_secs: 30,
                exit_reason: "stop_loss".into(),
            },
            TradeRecord {
                regime: "bull".into(),
                side: "long".into(),
                entry_price: 105.0,
                exit_price: 125.0,
                pnl: 20.0,
                hold_time_secs: 120,
                exit_reason: "take_profit".into(),
            },
            TradeRecord {
                regime: "neutral".into(),
                side: "long".into(),
                entry_price: 125.0,
                exit_price: 95.0,
                pnl: -30.0,
                hold_time_secs: 300,
                exit_reason: "stop_loss".into(),
            },
            TradeRecord {
                regime: "neutral".into(),
                side: "long".into(),
                entry_price: 95.0,
                exit_price: 100.0,
                pnl: 5.0,
                hold_time_secs: 60,
                exit_reason: "exit_rule".into(),
            },
        ];

        let dd = calculate_max_drawdown(&trades);
        assert!(
            (dd - (-30.0)).abs() < 1e-10,
            "max drawdown should be -30.0, got {}",
            dd
        );
    }

    #[test]
    fn test_max_drawdown_empty() {
        let dd = calculate_max_drawdown(&[]);
        assert!((dd - 0.0).abs() < 1e-10);
    }

    #[test]
    fn test_max_drawdown_all_wins() {
        let trades = vec![
            TradeRecord {
                regime: "bull".into(),
                side: "long".into(),
                entry_price: 100.0,
                exit_price: 110.0,
                pnl: 10.0,
                hold_time_secs: 60,
                exit_reason: "take_profit".into(),
            },
            TradeRecord {
                regime: "bull".into(),
                side: "long".into(),
                entry_price: 110.0,
                exit_price: 120.0,
                pnl: 10.0,
                hold_time_secs: 60,
                exit_reason: "take_profit".into(),
            },
        ];
        let dd = calculate_max_drawdown(&trades);
        assert!((dd - 0.0).abs() < 1e-10, "no drawdown for all wins");
    }

    // -----------------------------------------------------------------------
    // 4. sharpe_ratio calculation with known values
    // -----------------------------------------------------------------------

    #[test]
    fn test_sharpe_ratio_known_values() {
        // PnLs: [10, -5, 20, -30, 5]
        // mean = 0.0
        // variance = (100 + 25 + 400 + 900 + 25) / 4 = 1450/4 = 362.5
        // std_dev = sqrt(362.5) ~ 19.039
        // sharpe = 0.0 / 19.039 = 0.0
        let trades = vec![
            TradeRecord {
                regime: "a".into(),
                side: "long".into(),
                entry_price: 0.0,
                exit_price: 0.0,
                pnl: 10.0,
                hold_time_secs: 0,
                exit_reason: "".into(),
            },
            TradeRecord {
                regime: "a".into(),
                side: "long".into(),
                entry_price: 0.0,
                exit_price: 0.0,
                pnl: -5.0,
                hold_time_secs: 0,
                exit_reason: "".into(),
            },
            TradeRecord {
                regime: "a".into(),
                side: "long".into(),
                entry_price: 0.0,
                exit_price: 0.0,
                pnl: 20.0,
                hold_time_secs: 0,
                exit_reason: "".into(),
            },
            TradeRecord {
                regime: "a".into(),
                side: "long".into(),
                entry_price: 0.0,
                exit_price: 0.0,
                pnl: -30.0,
                hold_time_secs: 0,
                exit_reason: "".into(),
            },
            TradeRecord {
                regime: "a".into(),
                side: "long".into(),
                entry_price: 0.0,
                exit_price: 0.0,
                pnl: 5.0,
                hold_time_secs: 0,
                exit_reason: "".into(),
            },
        ];
        let sr = calculate_sharpe_ratio(&trades);
        assert!(
            sr.abs() < 1e-10,
            "sharpe should be 0 when mean is 0, got {}",
            sr
        );
    }

    #[test]
    fn test_sharpe_ratio_positive() {
        // PnLs: [10, 20, 15]
        // mean = 15.0
        // variance = (25 + 25 + 0) / 2 = 25.0
        // std_dev = 5.0
        // sharpe = 15.0 / 5.0 = 3.0
        let trades = vec![
            TradeRecord {
                regime: "a".into(),
                side: "long".into(),
                entry_price: 0.0,
                exit_price: 0.0,
                pnl: 10.0,
                hold_time_secs: 0,
                exit_reason: "".into(),
            },
            TradeRecord {
                regime: "a".into(),
                side: "long".into(),
                entry_price: 0.0,
                exit_price: 0.0,
                pnl: 20.0,
                hold_time_secs: 0,
                exit_reason: "".into(),
            },
            TradeRecord {
                regime: "a".into(),
                side: "long".into(),
                entry_price: 0.0,
                exit_price: 0.0,
                pnl: 15.0,
                hold_time_secs: 0,
                exit_reason: "".into(),
            },
        ];
        let sr = calculate_sharpe_ratio(&trades);
        assert!((sr - 3.0).abs() < 1e-10, "sharpe should be 3.0, got {}", sr);
    }

    #[test]
    fn test_sharpe_ratio_single_trade() {
        let trades = vec![TradeRecord {
            regime: "a".into(),
            side: "long".into(),
            entry_price: 0.0,
            exit_price: 0.0,
            pnl: 10.0,
            hold_time_secs: 0,
            exit_reason: "".into(),
        }];
        let sr = calculate_sharpe_ratio(&trades);
        assert!(
            (sr - 0.0).abs() < 1e-10,
            "sharpe should be 0 for single trade"
        );
    }

    #[test]
    fn test_sharpe_ratio_empty() {
        let sr = calculate_sharpe_ratio(&[]);
        assert!((sr - 0.0).abs() < 1e-10);
    }

    // -----------------------------------------------------------------------
    // 5. Backtest with adaptive_trend template
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_backtest_with_adaptive_trend_template() {
        use hyper_strategy::strategy_templates::build_template;

        let sg = build_template("adaptive_trend", "BTC-USD").unwrap();
        let engine = PlaybookEngine::new("BTC-USD".into(), sg, Box::new(PaperOrderExecutor::new()));
        let mut runner = BacktestRunner::new(engine);

        let candles = generate_synthetic_candles(300);
        let result = runner.run(&candles, 50).await;

        assert!(result.total_ticks > 0, "should have processed ticks");
        assert_eq!(result.total_ticks, 250);
        assert!(
            !result.regime_distribution.is_empty(),
            "should have regime distribution entries"
        );

        // Verify JSON roundtrip
        let json = serde_json::to_string(&result).unwrap();
        let _: BacktestResult = serde_json::from_str(&json).unwrap();
    }

    // -----------------------------------------------------------------------
    // 6. Empty candles / edge cases
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_backtest_empty_candles() {
        let engine = new_engine();
        let mut runner = BacktestRunner::new(engine);
        let result = runner.run(&[], 50).await;

        assert_eq!(result.total_ticks, 0);
        assert_eq!(result.total_trades, 0);
        assert!((result.win_rate - 0.0).abs() < 1e-10);
        assert!((result.total_pnl - 0.0).abs() < 1e-10);
        assert!((result.max_drawdown - 0.0).abs() < 1e-10);
        assert!((result.sharpe_ratio - 0.0).abs() < 1e-10);
        assert_eq!(result.avg_hold_time_secs, 0);
    }

    #[tokio::test]
    async fn test_backtest_window_larger_than_candles() {
        let candles = generate_synthetic_candles(30);
        let engine = new_engine();
        let mut runner = BacktestRunner::new(engine);

        let result = runner.run(&candles, 50).await;
        assert_eq!(result.total_ticks, 0);
    }
}