hyper_playbook/

engine.rs

use serde::{Deserialize, Serialize};

use hyper_strategy::rule_engine::evaluate_rules;
use hyper_strategy::strategy_config::{Playbook, StrategyGroup};
use hyper_ta::technical_analysis::TechnicalIndicators;
use motosan_ta_stream::snapshot::TaSnapshot;

use crate::executor::{OrderExecutor, PlaybookOrderParams, RiskCheckedOrderExecutor};
use crate::fsm::{PlaybookFsm, PlaybookState};
use crate::regime::RegimeDetector;

use hyper_risk::risk::RiskConfig;

// ---------------------------------------------------------------------------
// TickAction / TickResult
// ---------------------------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case", tag = "type")]
pub enum TickAction {
    None,
    OrderPlaced {
        order_id: String,
        side: String,
        size: f64,
    },
    OrderFilled {
        position_id: String,
        entry_price: f64,
    },
    OrderCancelled {
        order_id: String,
        reason: String,
    },
    PositionClosed {
        reason: String,
    },
    ForceClose {
        reason: String,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TickResult {
    pub regime: String,
    pub regime_changed: bool,
    pub previous_regime: Option<String>,
    pub fsm_state: String,
    pub action: TickAction,
    pub triggered_rules: Vec<String>,
}

// ---------------------------------------------------------------------------
// PlaybookEngine
// ---------------------------------------------------------------------------

pub struct PlaybookEngine {
    symbol: String,
    regime_detector: RegimeDetector,
    fsm: PlaybookFsm,
    executor: Box<dyn OrderExecutor>,
    prev_indicators: Option<TechnicalIndicators>,
    default_timeout_secs: u64,
}

impl PlaybookEngine {
    pub fn new(
        symbol: String,
        strategy_group: StrategyGroup,
        executor: Box<dyn OrderExecutor>,
    ) -> Self {
        Self {
            symbol,
            regime_detector: RegimeDetector::new(strategy_group),
            fsm: PlaybookFsm::new(),
            executor,
            prev_indicators: None,
            default_timeout_secs: 300,
        }
    }

    /// Create an engine that wraps the executor with risk checks.
    ///
    /// If `risk_config` is `Some`, the executor is wrapped in a
    /// [`RiskCheckedOrderExecutor`] so every order goes through pre-trade
    /// risk validation. If `None`, the inner executor is used directly
    /// (identical to [`Self::new`]).
    pub fn new_with_risk_config(
        symbol: String,
        strategy_group: StrategyGroup,
        executor: Box<dyn OrderExecutor>,
        risk_config: Option<RiskConfig>,
    ) -> Self {
        let final_executor: Box<dyn OrderExecutor> = match risk_config {
            Some(config) => Box::new(RiskCheckedOrderExecutor::with_config(executor, config)),
            None => executor,
        };
        Self::new(symbol, strategy_group, final_executor)
    }

    /// Return current FSM state (for external inspection / tests).
    pub fn fsm_state(&self) -> &PlaybookState {
        self.fsm.state()
    }

    /// Tick with a `TaSnapshot` (new API). Converts to `TechnicalIndicators`
    /// internally via `snapshot_to_indicators`.
    pub async fn tick_snapshot(&mut self, snapshot: &TaSnapshot, now: u64) -> TickResult {
        let indicators = hyper_ta::dynamic::snapshot_to_indicators(snapshot);
        self.tick(&indicators, now).await
    }

    /// Core tick — called once per interval.
    pub async fn tick(&mut self, indicators: &TechnicalIndicators, now: u64) -> TickResult {
        // 1. Detect regime
        let regime = self.regime_detector.detect(indicators, now).to_string();
        let regime_changed = self.regime_detector.regime_changed();
        let previous_regime = self
            .regime_detector
            .previous_regime()
            .map(|s| s.to_string());

        // 2. Handle regime change — force-close if new regime has no playbook
        if regime_changed {
            if let PlaybookState::InPosition { position_id, .. } = self.fsm.state().clone() {
                let new_pb = self.regime_detector.current_playbook();
                let should_force_close =
                    new_pb.is_none() || new_pb.map(|p| p.max_position_size == 0.0).unwrap_or(false);
                if should_force_close {
                    if let Ok(order_id) = self
                        .executor
                        .close_position(&position_id, "regime_change")
                        .await
                    {
                        let _ = self.fsm.enter_pending_exit(order_id, now);
                    }
                    self.prev_indicators = Some(indicators.clone());
                    return TickResult {
                        regime,
                        regime_changed,
                        previous_regime,
                        fsm_state: format!("{:?}", self.fsm.state()),
                        action: TickAction::ForceClose {
                            reason: "regime_change".into(),
                        },
                        triggered_rules: vec![],
                    };
                }
            }
            // Idle / Pending states: no special action on regime change
        }

        // 3. Get current playbook
        let playbook = match self.regime_detector.current_playbook() {
            Some(pb) => pb.clone(),
            None => {
                self.prev_indicators = Some(indicators.clone());
                return TickResult {
                    regime,
                    regime_changed,
                    previous_regime,
                    fsm_state: format!("{:?}", self.fsm.state()),
                    action: TickAction::None,
                    triggered_rules: vec![],
                };
            }
        };

        // 4. FSM evaluate based on current state
        let (action, triggered_rules) = match self.fsm.state().clone() {
            PlaybookState::Idle => self.handle_idle(&playbook, indicators, now).await,
            PlaybookState::PendingEntry {
                order_id,
                placed_at,
            } => {
                self.handle_pending_entry(&playbook, indicators, &order_id, placed_at, now)
                    .await
            }
            PlaybookState::InPosition {
                position_id,
                entry_price,
            } => {
                let result = self
                    .handle_in_position(
                        &playbook,
                        indicators,
                        &position_id,
                        entry_price,
                        now,
                        &regime,
                        regime_changed,
                        &previous_regime,
                    )
                    .await;
                match result {
                    InPositionResult::EarlyReturn(tick_result) => {
                        self.prev_indicators = Some(indicators.clone());
                        return tick_result;
                    }
                    InPositionResult::Normal(action, triggered) => (action, triggered),
                }
            }
            PlaybookState::PendingExit {
                order_id,
                placed_at,
            } => {
                self.handle_pending_exit(&playbook, &order_id, placed_at, now)
                    .await
            }
        };

        // 5. Store prev indicators for cross-over detection
        self.prev_indicators = Some(indicators.clone());

        TickResult {
            regime,
            regime_changed,
            previous_regime,
            fsm_state: format!("{:?}", self.fsm.state()),
            action,
            triggered_rules,
        }
    }

    // -- Idle --

    async fn handle_idle(
        &mut self,
        playbook: &Playbook,
        indicators: &TechnicalIndicators,
        now: u64,
    ) -> (TickAction, Vec<String>) {
        let evals = evaluate_rules(
            playbook.effective_entry_rules(),
            indicators,
            self.prev_indicators.as_ref(),
        );
        let triggered: Vec<String> = evals
            .iter()
            .filter(|e| e.triggered)
            .map(|e| e.signal.clone())
            .collect();

        if !triggered.is_empty() && playbook.max_position_size > 0.0 {
            let side = determine_side(playbook, &triggered);
            let params = PlaybookOrderParams {
                symbol: self.symbol.clone(),
                side: side.clone(),
                size: playbook.max_position_size,
                price: None,
                reduce_only: false,
            };
            match self.executor.place_order(&params).await {
                Ok(order_id) => {
                    let _ = self.fsm.enter_pending_entry(order_id.clone(), now);
                    (
                        TickAction::OrderPlaced {
                            order_id,
                            side,
                            size: playbook.max_position_size,
                        },
                        triggered,
                    )
                }
                Err(_) => (TickAction::None, triggered),
            }
        } else {
            (TickAction::None, triggered)
        }
    }

    // -- PendingEntry --

    async fn handle_pending_entry(
        &mut self,
        playbook: &Playbook,
        indicators: &TechnicalIndicators,
        order_id: &str,
        placed_at: u64,
        now: u64,
    ) -> (TickAction, Vec<String>) {
        let timeout = playbook.timeout_secs.unwrap_or(self.default_timeout_secs);
        if now - placed_at > timeout {
            let _ = self.executor.cancel_order(order_id).await;
            let _ = self.fsm.cancel_entry();
            return (
                TickAction::OrderCancelled {
                    order_id: order_id.to_string(),
                    reason: "timeout".into(),
                },
                vec![],
            );
        }
        match self.executor.is_filled(order_id).await {
            Ok(true) => {
                let price = current_price(indicators);
                let position_id = format!("pos-{}", order_id);
                let _ = self.fsm.confirm_entry(position_id.clone(), price);
                (
                    TickAction::OrderFilled {
                        position_id,
                        entry_price: price,
                    },
                    vec![],
                )
            }
            _ => (TickAction::None, vec![]),
        }
    }

    // -- InPosition --

    #[allow(clippy::too_many_arguments)]
    async fn handle_in_position(
        &mut self,
        playbook: &Playbook,
        indicators: &TechnicalIndicators,
        position_id: &str,
        entry_price: f64,
        now: u64,
        regime: &str,
        regime_changed: bool,
        previous_regime: &Option<String>,
    ) -> InPositionResult {
        let price = current_price(indicators);

        // Check hard stop-loss
        if let Some(sl_pct) = playbook.stop_loss_pct {
            let sl_price = entry_price * (1.0 - sl_pct / 100.0);
            if price <= sl_price {
                if let Ok(oid) = self.executor.close_position(position_id, "stop_loss").await {
                    let _ = self.fsm.enter_pending_exit(oid, now);
                    return InPositionResult::EarlyReturn(TickResult {
                        regime: regime.to_string(),
                        regime_changed,
                        previous_regime: previous_regime.clone(),
                        fsm_state: format!("{:?}", self.fsm.state()),
                        action: TickAction::PositionClosed {
                            reason: "stop_loss".into(),
                        },
                        triggered_rules: vec![],
                    });
                }
            }
        }

        // Check hard take-profit
        if let Some(tp_pct) = playbook.take_profit_pct {
            let tp_price = entry_price * (1.0 + tp_pct / 100.0);
            if price >= tp_price {
                if let Ok(oid) = self
                    .executor
                    .close_position(position_id, "take_profit")
                    .await
                {
                    let _ = self.fsm.enter_pending_exit(oid, now);
                    return InPositionResult::EarlyReturn(TickResult {
                        regime: regime.to_string(),
                        regime_changed,
                        previous_regime: previous_regime.clone(),
                        fsm_state: format!("{:?}", self.fsm.state()),
                        action: TickAction::PositionClosed {
                            reason: "take_profit".into(),
                        },
                        triggered_rules: vec![],
                    });
                }
            }
        }

        // Evaluate exit rules
        let evals = evaluate_rules(
            playbook.effective_exit_rules(),
            indicators,
            self.prev_indicators.as_ref(),
        );
        let triggered: Vec<String> = evals
            .iter()
            .filter(|e| e.triggered)
            .map(|e| e.signal.clone())
            .collect();
        if !triggered.is_empty() {
            if let Ok(oid) = self.executor.close_position(position_id, "exit_rule").await {
                let _ = self.fsm.enter_pending_exit(oid, now);
                return InPositionResult::Normal(
                    TickAction::PositionClosed {
                        reason: "exit_rule".into(),
                    },
                    triggered,
                );
            }
        }

        InPositionResult::Normal(TickAction::None, vec![])
    }

    // -- PendingExit --

    async fn handle_pending_exit(
        &mut self,
        playbook: &Playbook,
        order_id: &str,
        placed_at: u64,
        now: u64,
    ) -> (TickAction, Vec<String>) {
        let timeout = playbook.timeout_secs.unwrap_or(self.default_timeout_secs);
        if now - placed_at > timeout {
            self.fsm.force_idle();
            return (
                TickAction::OrderCancelled {
                    order_id: order_id.to_string(),
                    reason: "exit_timeout".into(),
                },
                vec![],
            );
        }
        match self.executor.is_filled(order_id).await {
            Ok(true) => {
                let _ = self.fsm.confirm_exit();
                (
                    TickAction::PositionClosed {
                        reason: "exit_filled".into(),
                    },
                    vec![],
                )
            }
            _ => (TickAction::None, vec![]),
        }
    }
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

enum InPositionResult {
    EarlyReturn(TickResult),
    Normal(TickAction, Vec<String>),
}

/// Extract a "current price" from indicators. Uses sma_20 as a reasonable
/// proxy since `TechnicalIndicators` does not carry a raw close field.
fn current_price(indicators: &TechnicalIndicators) -> f64 {
    indicators
        .sma_20
        .or(indicators.ema_12)
        .or(indicators.bb_middle)
        .unwrap_or(0.0)
}

/// Determine order side from playbook config or from signal names.
fn determine_side(playbook: &Playbook, triggered_signals: &[String]) -> String {
    // 1. Explicit playbook side
    if let Some(ref side) = playbook.side {
        return side.clone();
    }
    // 2. Infer from signal names
    for sig in triggered_signals {
        let lower = sig.to_lowercase();
        if lower.contains("buy") || lower.contains("long") || lower.contains("bull") {
            return "buy".to_string();
        }
        if lower.contains("sell") || lower.contains("short") || lower.contains("bear") {
            return "sell".to_string();
        }
    }
    // 3. Default
    "buy".to_string()
}

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

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

    // -- Helpers --

    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,
        }
    }

    /// Build a simple strategy group with:
    /// - regime rules: ADX > 50 => "bull", ADX < 10 => "bear"  (uses ADX, not RSI)
    /// - default regime: "neutral"
    /// - playbooks for bull, bear, neutral
    /// - hysteresis: confirmation_count=1, min_hold_secs=0 (fast switch for tests)
    ///
    /// Entry/exit rules use RSI, which is independent from the ADX-based regime rules.
    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: has zero max_position_size (no trading allowed)
        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-test".into(),
            name: "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 make_indicators(f: impl FnOnce(&mut TechnicalIndicators)) -> TechnicalIndicators {
        let mut ind = TechnicalIndicators::empty();
        f(&mut ind);
        ind
    }

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

    // -----------------------------------------------------------------------
    // 1. Happy path: Idle -> entry -> PendingEntry -> filled -> InPosition
    //    -> exit rule -> PendingExit -> filled -> Idle
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_happy_path_full_cycle() {
        let mut engine = new_engine();

        // Default regime is "neutral" (ADX between 10-50).
        // Entry rule: RSI < 30.
        // ADX=30 keeps us in neutral regime.
        let ind = make_indicators(|i| {
            i.rsi_14 = Some(25.0);
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(50000.0);
        });
        let r = engine.tick(&ind, 1000).await;
        assert_eq!(r.regime, "neutral");
        assert!(!r.triggered_rules.is_empty(), "should trigger oversold_buy");
        assert!(
            matches!(r.action, TickAction::OrderPlaced { .. }),
            "should place order, got {:?}",
            r.action
        );

        // PaperOrderExecutor always fills instantly, so next tick should fill
        let r2 = engine.tick(&ind, 1001).await;
        assert!(
            matches!(r2.action, TickAction::OrderFilled { .. }),
            "should be filled, got {:?}",
            r2.action
        );

        // Now InPosition. RSI between 45-55 triggers exit.
        let ind_exit = make_indicators(|i| {
            i.rsi_14 = Some(50.0);
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(51000.0);
        });
        let r3 = engine.tick(&ind_exit, 2000).await;
        assert_eq!(
            r3.action,
            TickAction::PositionClosed {
                reason: "exit_rule".into()
            }
        );
        assert!(r3.triggered_rules.contains(&"rsi_neutral_exit".to_string()));

        // PendingExit fills next tick
        let r4 = engine.tick(&ind_exit, 2001).await;
        assert_eq!(
            r4.action,
            TickAction::PositionClosed {
                reason: "exit_filled".into()
            }
        );
        assert!(engine.fsm_state() == &PlaybookState::Idle);
    }

    // -----------------------------------------------------------------------
    // 2. Stop loss
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_stop_loss() {
        let mut engine = new_engine();

        // Enter position via neutral playbook (RSI < 30, ADX=30 stays neutral)
        let ind_entry = make_indicators(|i| {
            i.rsi_14 = Some(25.0);
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(50000.0);
        });
        engine.tick(&ind_entry, 1000).await; // place order
        engine.tick(&ind_entry, 1001).await; // fill

        assert!(matches!(
            engine.fsm_state(),
            PlaybookState::InPosition { .. }
        ));

        // Price drops to trigger SL (5% => 47500)
        let ind_sl = make_indicators(|i| {
            i.rsi_14 = Some(35.0);
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(47000.0); // below 47500
        });
        let r = engine.tick(&ind_sl, 3000).await;
        assert_eq!(
            r.action,
            TickAction::PositionClosed {
                reason: "stop_loss".into()
            }
        );
    }

    // -----------------------------------------------------------------------
    // 3. Take profit
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_take_profit() {
        let mut engine = new_engine();

        let ind_entry = make_indicators(|i| {
            i.rsi_14 = Some(25.0);
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(50000.0);
        });
        engine.tick(&ind_entry, 1000).await;
        engine.tick(&ind_entry, 1001).await;

        // Price rises to trigger TP (10% => 55000)
        let ind_tp = make_indicators(|i| {
            i.rsi_14 = Some(35.0); // no exit rule triggered
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(56000.0); // above 55000
        });
        let r = engine.tick(&ind_tp, 3000).await;
        assert_eq!(
            r.action,
            TickAction::PositionClosed {
                reason: "take_profit".into()
            }
        );
    }

    // -----------------------------------------------------------------------
    // 4. Entry timeout
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_entry_timeout() {
        // We need an executor that does NOT auto-fill
        use crate::executor::ExecutionError;
        use async_trait::async_trait;

        struct SlowExecutor;

        #[async_trait]
        impl OrderExecutor for SlowExecutor {
            async fn place_order(
                &self,
                _params: &PlaybookOrderParams,
            ) -> Result<String, ExecutionError> {
                Ok("slow-order-1".into())
            }
            async fn cancel_order(&self, _order_id: &str) -> Result<(), ExecutionError> {
                Ok(())
            }
            async fn is_filled(&self, _order_id: &str) -> Result<bool, ExecutionError> {
                Ok(false) // never fills
            }
            async fn close_position(
                &self,
                _position_id: &str,
                _reason: &str,
            ) -> Result<String, ExecutionError> {
                Ok("close-1".into())
            }
        }

        let mut engine = PlaybookEngine::new(
            "BTC-USD".into(),
            simple_strategy_group(),
            Box::new(SlowExecutor),
        );

        // Trigger entry (neutral playbook, RSI < 30, ADX=30 stays neutral)
        let ind = make_indicators(|i| {
            i.rsi_14 = Some(25.0);
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(50000.0);
        });
        let r = engine.tick(&ind, 1000).await;
        assert!(matches!(r.action, TickAction::OrderPlaced { .. }));

        // Not filled yet, no timeout (placed_at=1000, timeout=300, now=1100 => 100 < 300)
        let r2 = engine.tick(&ind, 1100).await;
        assert_eq!(r2.action, TickAction::None);

        // Timeout (now=1301, 1301-1000=301 > 300)
        let r3 = engine.tick(&ind, 1301).await;
        assert!(
            matches!(r3.action, TickAction::OrderCancelled { ref reason, .. } if reason == "timeout"),
            "expected timeout cancel, got {:?}",
            r3.action
        );
        assert!(engine.fsm_state() == &PlaybookState::Idle);
    }

    // -----------------------------------------------------------------------
    // 5. Regime change force close
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_regime_change_force_close() {
        let mut engine = new_engine();

        // Enter position in neutral regime (RSI < 30, ADX=30)
        let ind_entry = make_indicators(|i| {
            i.rsi_14 = Some(25.0);
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(50000.0);
        });
        engine.tick(&ind_entry, 100).await; // place order
        engine.tick(&ind_entry, 101).await; // fill
        assert!(matches!(
            engine.fsm_state(),
            PlaybookState::InPosition { .. }
        ));

        // Now switch to bear regime (ADX < 10) over 2 ticks
        // Tick 3: ADX=5 => bear detected, starts pending switch
        let ind_bear = make_indicators(|i| {
            i.rsi_14 = Some(35.0);
            i.adx_14 = Some(5.0);
            i.sma_20 = Some(50000.0);
        });
        let r3 = engine.tick(&ind_bear, 200).await;
        assert_eq!(r3.regime, "neutral"); // pending switch started, not yet switched
        assert!(!r3.regime_changed);

        // Tick 4: ADX=5 again => bear confirmed, regime changes
        // InPosition + bear(max_position_size=0) => force close
        let r4 = engine.tick(&ind_bear, 300).await;
        assert_eq!(r4.regime, "bear");
        assert!(r4.regime_changed);
        assert_eq!(
            r4.action,
            TickAction::ForceClose {
                reason: "regime_change".into()
            }
        );
    }

    // -----------------------------------------------------------------------
    // 6. No entry when max_position_size = 0
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_no_entry_when_zero_position_size() {
        let mut engine = new_engine();

        // Switch to bear regime (ADX < 10). Use RSI=50 so no entry rule triggers
        // during the regime switch.
        let ind_switch = make_indicators(|i| {
            i.rsi_14 = Some(50.0);
            i.adx_14 = Some(5.0);
            i.sma_20 = Some(50000.0);
        });
        engine.tick(&ind_switch, 100).await; // pending switch starts
        let r2 = engine.tick(&ind_switch, 200).await; // switch to bear
        assert_eq!(r2.regime, "bear");
        assert!(engine.fsm_state() == &PlaybookState::Idle);

        // Now in bear regime with max_position_size=0.
        // Even with RSI < 30, bear playbook has no entry rules and zero size.
        let ind = make_indicators(|i| {
            i.rsi_14 = Some(20.0);
            i.adx_14 = Some(5.0);
            i.sma_20 = Some(50000.0);
        });
        let r3 = engine.tick(&ind, 300).await;
        assert_eq!(r3.action, TickAction::None);
        assert!(engine.fsm_state() == &PlaybookState::Idle);
    }

    // -----------------------------------------------------------------------
    // 7. determine_side()
    // -----------------------------------------------------------------------

    #[test]
    fn test_determine_side_from_playbook() {
        let pb = Playbook {
            rules: vec![],
            entry_rules: vec![],
            exit_rules: vec![],
            system_prompt: "".into(),
            max_position_size: 100.0,
            stop_loss_pct: None,
            take_profit_pct: None,
            timeout_secs: None,
            side: Some("sell".into()),
        };
        assert_eq!(determine_side(&pb, &["some_signal".into()]), "sell");
    }

    #[test]
    fn test_determine_side_from_signal_buy() {
        let pb = Playbook {
            rules: vec![],
            entry_rules: vec![],
            exit_rules: vec![],
            system_prompt: "".into(),
            max_position_size: 100.0,
            stop_loss_pct: None,
            take_profit_pct: None,
            timeout_secs: None,
            side: None,
        };
        assert_eq!(determine_side(&pb, &["oversold_buy".into()]), "buy");
    }

    #[test]
    fn test_determine_side_from_signal_sell() {
        let pb = Playbook {
            rules: vec![],
            entry_rules: vec![],
            exit_rules: vec![],
            system_prompt: "".into(),
            max_position_size: 100.0,
            stop_loss_pct: None,
            take_profit_pct: None,
            timeout_secs: None,
            side: None,
        };
        assert_eq!(determine_side(&pb, &["overbought_sell".into()]), "sell");
    }

    #[test]
    fn test_determine_side_from_signal_long() {
        let pb = Playbook {
            rules: vec![],
            entry_rules: vec![],
            exit_rules: vec![],
            system_prompt: "".into(),
            max_position_size: 100.0,
            stop_loss_pct: None,
            take_profit_pct: None,
            timeout_secs: None,
            side: None,
        };
        assert_eq!(determine_side(&pb, &["go_long".into()]), "buy");
    }

    #[test]
    fn test_determine_side_from_signal_short() {
        let pb = Playbook {
            rules: vec![],
            entry_rules: vec![],
            exit_rules: vec![],
            system_prompt: "".into(),
            max_position_size: 100.0,
            stop_loss_pct: None,
            take_profit_pct: None,
            timeout_secs: None,
            side: None,
        };
        assert_eq!(determine_side(&pb, &["go_short".into()]), "sell");
    }

    #[test]
    fn test_determine_side_default() {
        let pb = Playbook {
            rules: vec![],
            entry_rules: vec![],
            exit_rules: vec![],
            system_prompt: "".into(),
            max_position_size: 100.0,
            stop_loss_pct: None,
            take_profit_pct: None,
            timeout_secs: None,
            side: None,
        };
        assert_eq!(determine_side(&pb, &["some_neutral_signal".into()]), "buy");
    }

    // -----------------------------------------------------------------------
    // 8. No playbook for regime => TickAction::None
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_no_playbook_returns_none() {
        // Create a strategy group where the default regime has no playbook
        let sg = StrategyGroup {
            id: "sg-no-pb".into(),
            name: "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![],
            default_regime: "unknown_regime".into(),
            hysteresis: HysteresisConfig {
                min_hold_secs: 0,
                confirmation_count: 1,
            },
            playbooks: HashMap::new(),
        };
        let mut engine =
            PlaybookEngine::new("BTC-USD".into(), sg, Box::new(PaperOrderExecutor::new()));
        let ind = make_indicators(|i| i.rsi_14 = Some(50.0));
        let r = engine.tick(&ind, 1000).await;
        assert_eq!(r.action, TickAction::None);
    }

    // -----------------------------------------------------------------------
    // 9. TickAction / TickResult serde roundtrip
    // -----------------------------------------------------------------------

    #[test]
    fn test_tick_action_serde_none() {
        let a = TickAction::None;
        let json = serde_json::to_string(&a).unwrap();
        let back: TickAction = serde_json::from_str(&json).unwrap();
        assert_eq!(a, back);
    }

    #[test]
    fn test_tick_action_serde_order_placed() {
        let a = TickAction::OrderPlaced {
            order_id: "o-1".into(),
            side: "buy".into(),
            size: 100.0,
        };
        let json = serde_json::to_string(&a).unwrap();
        let back: TickAction = serde_json::from_str(&json).unwrap();
        assert_eq!(a, back);
    }

    #[test]
    fn test_tick_result_serde() {
        let tr = TickResult {
            regime: "bull".into(),
            regime_changed: true,
            previous_regime: Some("neutral".into()),
            fsm_state: "Idle".into(),
            action: TickAction::None,
            triggered_rules: vec!["signal_a".into()],
        };
        let json = serde_json::to_string(&tr).unwrap();
        let back: TickResult = serde_json::from_str(&json).unwrap();
        assert_eq!(back.regime, "bull");
        assert!(back.regime_changed);
        assert_eq!(back.previous_regime, Some("neutral".to_string()));
    }

    // -----------------------------------------------------------------------
    // 10. Exit timeout in PendingExit resets to Idle
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_exit_timeout() {
        use crate::executor::ExecutionError;
        use async_trait::async_trait;

        struct SlowCloseExecutor {
            counter: std::sync::atomic::AtomicU64,
        }

        impl SlowCloseExecutor {
            fn new() -> Self {
                Self {
                    counter: std::sync::atomic::AtomicU64::new(1),
                }
            }
            fn next_id(&self) -> String {
                let n = self
                    .counter
                    .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                format!("order-{}", n)
            }
        }

        #[async_trait]
        impl OrderExecutor for SlowCloseExecutor {
            async fn place_order(
                &self,
                _params: &PlaybookOrderParams,
            ) -> Result<String, ExecutionError> {
                Ok(self.next_id())
            }
            async fn cancel_order(&self, _order_id: &str) -> Result<(), ExecutionError> {
                Ok(())
            }
            async fn is_filled(&self, order_id: &str) -> Result<bool, ExecutionError> {
                // Entry fills, but exit does not
                if order_id.starts_with("order-") {
                    // First order (entry) fills; close orders don't
                    let num: u64 = order_id
                        .strip_prefix("order-")
                        .unwrap()
                        .parse()
                        .unwrap_or(0);
                    Ok(num <= 1) // only order-1 fills
                } else {
                    Ok(false)
                }
            }
            async fn close_position(
                &self,
                _position_id: &str,
                _reason: &str,
            ) -> Result<String, ExecutionError> {
                Ok(self.next_id())
            }
        }

        let mut engine = PlaybookEngine::new(
            "BTC-USD".into(),
            simple_strategy_group(),
            Box::new(SlowCloseExecutor::new()),
        );

        // Enter position (ADX=30 stays neutral)
        let ind = make_indicators(|i| {
            i.rsi_14 = Some(25.0);
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(50000.0);
        });
        engine.tick(&ind, 1000).await; // place entry
        engine.tick(&ind, 1001).await; // fill entry

        // Trigger exit via stop loss (5% of 50000 = 47500)
        let ind_sl = make_indicators(|i| {
            i.rsi_14 = Some(35.0);
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(47000.0);
        });
        let r = engine.tick(&ind_sl, 2000).await;
        assert_eq!(
            r.action,
            TickAction::PositionClosed {
                reason: "stop_loss".into()
            }
        );
        assert!(matches!(
            engine.fsm_state(),
            PlaybookState::PendingExit { .. }
        ));

        // Exit not filled, no timeout yet
        let r2 = engine.tick(&ind_sl, 2100).await;
        assert_eq!(r2.action, TickAction::None);

        // Exit timeout (neutral timeout_secs=300)
        let r3 = engine.tick(&ind_sl, 2400).await;
        assert!(
            matches!(r3.action, TickAction::OrderCancelled { ref reason, .. } if reason == "exit_timeout"),
            "expected exit_timeout, got {:?}",
            r3.action
        );
        assert!(engine.fsm_state() == &PlaybookState::Idle);
    }

    // -----------------------------------------------------------------------
    // 11. new_with_risk_config wraps executor with risk checks
    // -----------------------------------------------------------------------

    #[tokio::test]
    async fn test_new_with_risk_config_permissive() {
        use hyper_risk::risk::{
            AnomalyDetection, CircuitBreaker, DailyLossLimits, PositionLimits, RiskConfig,
        };

        // Permissive config — orders should pass through
        let config = RiskConfig {
            position_limits: PositionLimits {
                enabled: true,
                max_total_position: 1_000_000.0,
                max_per_symbol: 500_000.0,
            },
            daily_loss_limits: DailyLossLimits {
                enabled: false,
                max_daily_loss: 100_000.0,
                max_daily_loss_percent: 50.0,
            },
            anomaly_detection: AnomalyDetection {
                enabled: true,
                max_order_size: 1_000_000.0,
                max_orders_per_minute: 100,
                block_duplicate_orders: false,
            },
            circuit_breaker: CircuitBreaker {
                enabled: false,
                trigger_loss: 100_000.0,
                trigger_window_minutes: 60,
                action: "pause_all".to_string(),
                cooldown_minutes: 30,
            },
        };

        let mut engine = PlaybookEngine::new_with_risk_config(
            "BTC-USD".into(),
            simple_strategy_group(),
            Box::new(PaperOrderExecutor::new()),
            Some(config),
        );

        // Neutral regime, RSI < 30 triggers entry
        let ind = make_indicators(|i| {
            i.rsi_14 = Some(25.0);
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(50000.0);
        });
        let r = engine.tick(&ind, 1000).await;
        assert!(
            matches!(r.action, TickAction::OrderPlaced { .. }),
            "permissive risk config should allow order, got {:?}",
            r.action
        );
    }

    #[tokio::test]
    async fn test_new_with_risk_config_circuit_breaker_blocks_order() {
        use crate::executor::RiskCheckedOrderExecutor;
        use hyper_risk::risk::{
            AccountState, AnomalyDetection, CircuitBreaker, DailyLossLimits, PositionLimits,
            RiskConfig,
        };

        // Circuit breaker with a very low trigger so it trips on our account state
        let config = RiskConfig {
            position_limits: PositionLimits {
                enabled: false,
                max_total_position: 1_000_000.0,
                max_per_symbol: 500_000.0,
            },
            daily_loss_limits: DailyLossLimits {
                enabled: false,
                max_daily_loss: 100_000.0,
                max_daily_loss_percent: 50.0,
            },
            anomaly_detection: AnomalyDetection {
                enabled: false,
                max_order_size: 1_000_000.0,
                max_orders_per_minute: 100,
                block_duplicate_orders: false,
            },
            circuit_breaker: CircuitBreaker {
                enabled: true,
                trigger_loss: 1.0, // very low — trips immediately
                trigger_window_minutes: 60,
                action: "pause_all".to_string(),
                cooldown_minutes: 9999,
            },
        };

        // Build RiskCheckedOrderExecutor directly so we can set account state
        let inner = Box::new(PaperOrderExecutor::new());
        let risk_executor = RiskCheckedOrderExecutor::with_config(inner, config);
        risk_executor.update_account_state(AccountState {
            windowed_loss: 10.0, // exceeds trigger_loss of $1
            ..AccountState::default()
        });

        let mut engine = PlaybookEngine::new(
            "BTC-USD".into(),
            simple_strategy_group(),
            Box::new(risk_executor),
        );

        // Neutral regime, RSI < 30 triggers entry — but circuit breaker blocks
        let ind = make_indicators(|i| {
            i.rsi_14 = Some(25.0);
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(50000.0);
        });
        let r = engine.tick(&ind, 1000).await;
        assert_eq!(
            r.action,
            TickAction::None,
            "tripped circuit breaker should block order"
        );
        assert!(engine.fsm_state() == &PlaybookState::Idle);
    }

    #[tokio::test]
    async fn test_new_with_risk_config_none_uses_inner_directly() {
        // None risk config => same as PlaybookEngine::new
        let mut engine = PlaybookEngine::new_with_risk_config(
            "BTC-USD".into(),
            simple_strategy_group(),
            Box::new(PaperOrderExecutor::new()),
            None,
        );

        let ind = make_indicators(|i| {
            i.rsi_14 = Some(25.0);
            i.adx_14 = Some(30.0);
            i.sma_20 = Some(50000.0);
        });
        let r = engine.tick(&ind, 1000).await;
        assert!(
            matches!(r.action, TickAction::OrderPlaced { .. }),
            "None risk config should use inner executor directly, got {:?}",
            r.action
        );
    }
}