hyper_playbook/

regime.rs

use hyper_strategy::rule_engine::{detect_regime, RegimeState};
use hyper_strategy::strategy_config::{Playbook, StrategyGroup};
use hyper_ta::technical_analysis::TechnicalIndicators;

pub struct RegimeDetector {
    strategy_group: StrategyGroup,
    regime_state: RegimeState,
    current_regime: String,
    previous_regime: Option<String>,
    changed: bool,
}

impl RegimeDetector {
    pub fn new(strategy_group: StrategyGroup) -> Self {
        let default = strategy_group.default_regime.clone();
        Self {
            strategy_group,
            regime_state: RegimeState {
                current: default.clone(),
                since: 0,
                pending_switch: None,
            },
            current_regime: default,
            previous_regime: None,
            changed: false,
        }
    }

    /// Detect regime from current indicators. Returns the regime name.
    pub fn detect(&mut self, indicators: &TechnicalIndicators, now: u64) -> &str {
        let new_regime = detect_regime(
            &self.strategy_group.regime_rules,
            &self.strategy_group.default_regime,
            indicators,
            &mut self.regime_state,
            &self.strategy_group.hysteresis,
            now,
        );
        self.changed = new_regime != self.current_regime;
        if self.changed {
            self.previous_regime = Some(self.current_regime.clone());
            self.current_regime = new_regime;
        }
        &self.current_regime
    }

    pub fn current_regime(&self) -> &str {
        &self.current_regime
    }

    pub fn regime_changed(&self) -> bool {
        self.changed
    }

    pub fn previous_regime(&self) -> Option<&str> {
        self.previous_regime.as_deref()
    }

    /// Look up the playbook for the current regime.
    pub fn current_playbook(&self) -> Option<&Playbook> {
        self.strategy_group.playbooks.get(&self.current_regime)
    }

    pub fn strategy_group(&self) -> &StrategyGroup {
        &self.strategy_group
    }
}

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

    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_playbook(prompt: &str) -> Playbook {
        Playbook {
            rules: vec![],
            entry_rules: vec![],
            exit_rules: vec![],
            system_prompt: prompt.to_string(),
            max_position_size: 1000.0,
            stop_loss_pct: Some(5.0),
            take_profit_pct: Some(10.0),
            timeout_secs: None,
            side: None,
        }
    }

    /// Build a simple StrategyGroup with 2 regime rules (bull + bear) and default "neutral".
    fn make_strategy_group(hysteresis: HysteresisConfig) -> StrategyGroup {
        let mut playbooks = HashMap::new();
        playbooks.insert("bull".to_string(), make_playbook("bull prompt"));
        playbooks.insert("bear".to_string(), make_playbook("bear prompt"));
        playbooks.insert("neutral".to_string(), make_playbook("neutral prompt"));

        StrategyGroup {
            id: "sg-test".to_string(),
            name: "Test Group".to_string(),
            vault_address: None,
            is_active: true,
            created_at: "2026-01-01T00:00:00Z".to_string(),
            symbol: "BTC-USD".to_string(),
            interval_secs: 300,
            regime_rules: vec![
                RegimeRule {
                    regime: "bull".to_string(),
                    conditions: vec![make_ta_rule("RSI", vec![14.0], "gt", 70.0, "overbought")],
                    priority: 1,
                },
                RegimeRule {
                    regime: "bear".to_string(),
                    conditions: vec![make_ta_rule("RSI", vec![14.0], "lt", 30.0, "oversold")],
                    priority: 2,
                },
            ],
            default_regime: "neutral".to_string(),
            hysteresis,
            playbooks,
        }
    }

    fn make_indicators(f: impl FnOnce(&mut TechnicalIndicators)) -> TechnicalIndicators {
        let mut ind = TechnicalIndicators::empty();
        f(&mut ind);
        ind
    }

    // -----------------------------------------------------------------------
    // Test: initial regime is default
    // -----------------------------------------------------------------------

    #[test]
    fn test_initial_regime_is_default() {
        let sg = make_strategy_group(HysteresisConfig {
            min_hold_secs: 0,
            confirmation_count: 1,
        });
        let detector = RegimeDetector::new(sg);
        assert_eq!(detector.current_regime(), "neutral");
        assert!(!detector.regime_changed());
        assert!(detector.previous_regime().is_none());
    }

    // -----------------------------------------------------------------------
    // Test: indicators trigger regime change -> regime_changed() is true
    // -----------------------------------------------------------------------

    #[test]
    fn test_regime_change_detected() {
        let sg = make_strategy_group(HysteresisConfig {
            min_hold_secs: 0,
            confirmation_count: 1,
        });
        let mut detector = RegimeDetector::new(sg);

        let ind = make_indicators(|i| i.rsi_14 = Some(80.0));

        // First call: starts pending switch (count=1), not switched yet
        detector.detect(&ind, 1000);
        assert_eq!(detector.current_regime(), "neutral");

        // Second call: increments count to 2 >= 1, switch happens
        detector.detect(&ind, 2000);
        assert_eq!(detector.current_regime(), "bull");
        assert!(detector.regime_changed());
    }

    // -----------------------------------------------------------------------
    // Test: same regime detected again -> regime_changed() is false
    // -----------------------------------------------------------------------

    #[test]
    fn test_same_regime_not_changed() {
        let sg = make_strategy_group(HysteresisConfig {
            min_hold_secs: 0,
            confirmation_count: 1,
        });
        let mut detector = RegimeDetector::new(sg);

        let ind = make_indicators(|i| i.rsi_14 = Some(80.0));

        // Two calls to complete the switch
        detector.detect(&ind, 1000);
        detector.detect(&ind, 2000);
        assert!(detector.regime_changed());
        assert_eq!(detector.current_regime(), "bull");

        // Third detect: same bull indicators -> no change
        detector.detect(&ind, 3000);
        assert!(!detector.regime_changed());
        assert_eq!(detector.current_regime(), "bull");
    }

    // -----------------------------------------------------------------------
    // Test: current_playbook() returns correct playbook
    // -----------------------------------------------------------------------

    #[test]
    fn test_current_playbook_returns_correct() {
        let sg = make_strategy_group(HysteresisConfig {
            min_hold_secs: 0,
            confirmation_count: 1,
        });
        let mut detector = RegimeDetector::new(sg);

        // Default regime is neutral
        let pb = detector.current_playbook().unwrap();
        assert_eq!(pb.system_prompt, "neutral prompt");

        // Switch to bull (two calls needed for hysteresis)
        let ind = make_indicators(|i| i.rsi_14 = Some(80.0));
        detector.detect(&ind, 1000);
        detector.detect(&ind, 2000);

        let pb = detector.current_playbook().unwrap();
        assert_eq!(pb.system_prompt, "bull prompt");
    }

    // -----------------------------------------------------------------------
    // Test: previous_regime() tracks the old regime after change
    // -----------------------------------------------------------------------

    #[test]
    fn test_previous_regime_tracked() {
        let sg = make_strategy_group(HysteresisConfig {
            min_hold_secs: 0,
            confirmation_count: 1,
        });
        let mut detector = RegimeDetector::new(sg);

        assert!(detector.previous_regime().is_none());

        // Switch neutral -> bull (two calls for hysteresis)
        let ind = make_indicators(|i| i.rsi_14 = Some(80.0));
        detector.detect(&ind, 1000);
        detector.detect(&ind, 2000);

        assert_eq!(detector.previous_regime(), Some("neutral"));
        assert_eq!(detector.current_regime(), "bull");
    }

    // -----------------------------------------------------------------------
    // Test: hysteresis prevents rapid switching
    // -----------------------------------------------------------------------

    #[test]
    fn test_hysteresis_prevents_rapid_switch() {
        // Require 3 confirmations
        let sg = make_strategy_group(HysteresisConfig {
            min_hold_secs: 0,
            confirmation_count: 3,
        });
        let mut detector = RegimeDetector::new(sg);

        let bull_ind = make_indicators(|i| i.rsi_14 = Some(80.0));

        // First detect: pending switch starts (count=1), not yet switched
        detector.detect(&bull_ind, 1000);
        assert_eq!(detector.current_regime(), "neutral");
        assert!(!detector.regime_changed());

        // Second detect: count=2, still not switched
        detector.detect(&bull_ind, 2000);
        assert_eq!(detector.current_regime(), "neutral");
        assert!(!detector.regime_changed());

        // Third detect: count=3 >= 3, switch happens
        detector.detect(&bull_ind, 3000);
        assert_eq!(detector.current_regime(), "bull");
        assert!(detector.regime_changed());
        assert_eq!(detector.previous_regime(), Some("neutral"));
    }

    // -----------------------------------------------------------------------
    // Test: min_hold_secs prevents premature regime change
    // -----------------------------------------------------------------------

    #[test]
    fn test_min_hold_secs_prevents_change() {
        let sg = make_strategy_group(HysteresisConfig {
            min_hold_secs: 3600,
            confirmation_count: 1,
        });
        let mut detector = RegimeDetector::new(sg);

        let bull_ind = make_indicators(|i| i.rsi_14 = Some(80.0));

        // Detect at t=100, regime since=0, held=100 < 3600 -> no switch
        detector.detect(&bull_ind, 100);
        assert_eq!(detector.current_regime(), "neutral");
        assert!(!detector.regime_changed());

        // Detect at t=5000, held=5000 > 3600 -> pending switch starts (count=1)
        detector.detect(&bull_ind, 5000);
        assert_eq!(detector.current_regime(), "neutral");
        assert!(!detector.regime_changed());

        // Detect at t=6000 -> count=2 >= 1 -> switch
        detector.detect(&bull_ind, 6000);
        assert_eq!(detector.current_regime(), "bull");
        assert!(detector.regime_changed());
    }

    // -----------------------------------------------------------------------
    // Test: strategy_group() accessor
    // -----------------------------------------------------------------------

    #[test]
    fn test_strategy_group_accessor() {
        let sg = make_strategy_group(HysteresisConfig {
            min_hold_secs: 0,
            confirmation_count: 1,
        });
        let detector = RegimeDetector::new(sg);
        assert_eq!(detector.strategy_group().id, "sg-test");
        assert_eq!(detector.strategy_group().symbol, "BTC-USD");
    }
}