hyper_strategy/

rule_engine.rs

use crate::strategy_config::{HysteresisConfig, RegimeRule, TaRule};
use hyper_ta::technical_analysis::TechnicalIndicators;
use serde::{Deserialize, Serialize};

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

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct RegimeState {
    pub current: String,
    pub since: u64,
    pub pending_switch: Option<PendingSwitch>,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct PendingSwitch {
    pub target_regime: String,
    pub confirmation_count: u32,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct RuleEvaluation {
    pub rule: TaRule,
    pub current_value: f64,
    pub triggered: bool,
    pub signal: String,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct SignalSummary {
    pub symbol: String,
    pub timestamp: u64,
    pub current_regime: String,
    pub regime_changed: bool,
    pub evaluations: Vec<RuleEvaluation>,
    pub triggered_signals: Vec<String>,
}

// ---------------------------------------------------------------------------
// Indicator value extraction
// ---------------------------------------------------------------------------

/// Extract an indicator value from `TechnicalIndicators` by name and params.
///
/// Mapping rules:
/// - "RSI" → rsi_14
/// - "MACD" → macd_line; "MACD_signal" → macd_signal; "MACD_histogram" → macd_histogram
/// - "SMA" with param 20 → sma_20, param 50 → sma_50
/// - "EMA" with param 12 → ema_12, param 26 → ema_26
/// - "BB_upper" → bb_upper; "BB_middle" → bb_middle; "BB_lower" → bb_lower
/// - "ADX" → adx_14
/// - "ATR" → atr_14
/// - "STOCH_K" → stoch_k; "STOCH_D" → stoch_d
/// - "CCI" → cci_20
/// - "WILLIAMS_R" → williams_r_14
/// - "OBV" → obv
/// - "MFI" → mfi_14
pub fn get_indicator_value(
    indicators: &TechnicalIndicators,
    name: &str,
    params: &[f64],
) -> Option<f64> {
    let upper = name.to_uppercase();
    match upper.as_str() {
        "RSI" => indicators.rsi_14,
        "MACD" | "MACD_LINE" => indicators.macd_line,
        "MACD_SIGNAL" => indicators.macd_signal,
        "MACD_HISTOGRAM" => indicators.macd_histogram,
        "SMA" => {
            let period = params.first().copied().unwrap_or(20.0) as u32;
            match period {
                20 => indicators.sma_20,
                50 => indicators.sma_50,
                _ => None,
            }
        }
        "EMA" => {
            let period = params.first().copied().unwrap_or(12.0) as u32;
            match period {
                12 => indicators.ema_12,
                20 => indicators.ema_20,
                26 => indicators.ema_26,
                50 => indicators.ema_50,
                _ => None,
            }
        }
        "BB_UPPER" => indicators.bb_upper,
        "BB_MIDDLE" => indicators.bb_middle,
        "BB_LOWER" => indicators.bb_lower,
        "BB" => indicators.bb_middle, // default BB → middle band
        "ADX" => indicators.adx_14,
        "ATR" => indicators.atr_14,
        "STOCH_K" => indicators.stoch_k,
        "STOCH_D" => indicators.stoch_d,
        "CCI" => indicators.cci_20,
        "WILLIAMS_R" => indicators.williams_r_14,
        "OBV" => indicators.obv,
        "MFI" => indicators.mfi_14,
        "ROC" => indicators.roc_12,
        "DONCHIAN_UPPER" => {
            let period = params.first().copied().unwrap_or(20.0) as u32;
            match period {
                10 => indicators.donchian_upper_10,
                _ => indicators.donchian_upper_20,
            }
        }
        "DONCHIAN_LOWER" => {
            let period = params.first().copied().unwrap_or(20.0) as u32;
            match period {
                10 => indicators.donchian_lower_10,
                _ => indicators.donchian_lower_20,
            }
        }
        "ZSCORE" => indicators.close_zscore_20,
        "VOL_ZSCORE" => indicators.volume_zscore_20,
        "HV" => {
            let period = params.first().copied().unwrap_or(20.0) as u32;
            match period {
                60 => indicators.hv_60,
                _ => indicators.hv_20,
            }
        }
        "KC_UPPER" => indicators.kc_upper_20,
        "KC_LOWER" => indicators.kc_lower_20,
        "SUPERTREND" => indicators.supertrend_value,
        "SUPERTREND_DIR" => indicators.supertrend_direction,
        "VWAP" => indicators.vwap,
        "PLUS_DI" => indicators.plus_di_14,
        "MINUS_DI" => indicators.minus_di_14,
        _ => None,
    }
}

/// For cross_above / cross_below with two-param indicators (e.g., EMA 50 vs EMA 200),
/// resolve the second indicator value using the second param.
fn get_secondary_indicator_value(
    indicators: &TechnicalIndicators,
    name: &str,
    params: &[f64],
) -> Option<f64> {
    if params.len() < 2 {
        return None;
    }
    get_indicator_value(indicators, name, &params[1..])
}

// ---------------------------------------------------------------------------
// Condition evaluation
// ---------------------------------------------------------------------------

fn evaluate_condition(
    condition: &str,
    current: f64,
    threshold: f64,
    threshold_upper: Option<f64>,
    prev_value: Option<f64>,
    prev_threshold: Option<f64>,
) -> bool {
    match condition {
        "gt" => current > threshold,
        "lt" => current < threshold,
        "gte" => current >= threshold,
        "lte" => current <= threshold,
        "cross_above" => {
            // current > threshold AND prev <= prev_threshold
            if let (Some(pv), Some(pt)) = (prev_value, prev_threshold) {
                current > threshold && pv <= pt
            } else {
                false
            }
        }
        "cross_below" => {
            if let (Some(pv), Some(pt)) = (prev_value, prev_threshold) {
                current < threshold && pv >= pt
            } else {
                false
            }
        }
        "between" => {
            if let Some(upper) = threshold_upper {
                current >= threshold && current <= upper
            } else {
                false
            }
        }
        "outside" => {
            if let Some(upper) = threshold_upper {
                current < threshold || current > upper
            } else {
                false
            }
        }
        _ => false,
    }
}

// ---------------------------------------------------------------------------
// Regime detection
// ---------------------------------------------------------------------------

/// Detect current market regime based on regime rules, with hysteresis.
///
/// Hysteresis logic:
///   1. If current regime held < min_hold_secs -> ignore new regime signals
///   2. If pending_switch exists and target matches -> confirmation_count += 1
///   3. If confirmation_count >= hysteresis.confirmation_count -> switch
///   4. Else record pending_switch, wait for next confirmation
pub fn detect_regime(
    regime_rules: &[RegimeRule],
    default_regime: &str,
    indicators: &TechnicalIndicators,
    current_state: &mut RegimeState,
    hysteresis: &HysteresisConfig,
    now: u64,
) -> String {
    // Evaluate all regime rules and find the matching one with highest priority
    let mut matched_regime: Option<&str> = None;
    let mut best_priority: Option<u32> = None;

    // Sort regime rules by priority — lower number = higher priority
    let mut sorted_rules: Vec<&RegimeRule> = regime_rules.iter().collect();
    sorted_rules.sort_by_key(|r| r.priority);

    for rule in &sorted_rules {
        let all_conditions_met = rule.conditions.iter().all(|cond| {
            let val = get_indicator_value(indicators, &cond.indicator, &cond.params);
            let val = match val {
                Some(v) => v,
                None => return false,
            };

            // For cross_above/cross_below in regime detection we need secondary values,
            // but since we don't have prev_indicators in regime detection, we use
            // the threshold approach: compare indicator value vs threshold directly.
            let threshold = if cond.condition == "cross_above" || cond.condition == "cross_below" {
                // For two-param indicators, compare first param indicator vs second param indicator
                get_secondary_indicator_value(indicators, &cond.indicator, &cond.params)
                    .unwrap_or(cond.threshold)
            } else {
                cond.threshold
            };

            evaluate_condition(
                &cond.condition,
                val,
                threshold,
                cond.threshold_upper,
                None, // No prev for regime detection in this simplified model
                None,
            )
        });

        if all_conditions_met {
            if best_priority.is_none() || rule.priority < best_priority.unwrap() {
                matched_regime = Some(&rule.regime);
                best_priority = Some(rule.priority);
            }
        }
    }

    let detected = matched_regime.unwrap_or(default_regime);

    // If detected regime is same as current, clear any pending switch
    if detected == current_state.current {
        current_state.pending_switch = None;
        return current_state.current.clone();
    }

    // Hysteresis check 1: min hold time
    let held_secs = now.saturating_sub(current_state.since);
    if held_secs < hysteresis.min_hold_secs {
        return current_state.current.clone();
    }

    // Hysteresis check 2: confirmation counting
    if let Some(ref mut pending) = current_state.pending_switch {
        if pending.target_regime == detected {
            pending.confirmation_count += 1;
            if pending.confirmation_count >= hysteresis.confirmation_count {
                // Switch!
                current_state.current = detected.to_string();
                current_state.since = now;
                current_state.pending_switch = None;
                return current_state.current.clone();
            }
            return current_state.current.clone();
        } else {
            // Different target — reset pending
            current_state.pending_switch = Some(PendingSwitch {
                target_regime: detected.to_string(),
                confirmation_count: 1,
            });
            return current_state.current.clone();
        }
    }

    // No pending switch yet — start one
    current_state.pending_switch = Some(PendingSwitch {
        target_regime: detected.to_string(),
        confirmation_count: 1,
    });
    current_state.current.clone()
}

// ---------------------------------------------------------------------------
// Signal evaluation
// ---------------------------------------------------------------------------

/// Evaluate playbook rules against current (and optionally previous) indicators.
pub fn evaluate_rules(
    rules: &[TaRule],
    indicators: &TechnicalIndicators,
    prev_indicators: Option<&TechnicalIndicators>,
) -> Vec<RuleEvaluation> {
    rules
        .iter()
        .filter_map(|rule| {
            let current_val = get_indicator_value(indicators, &rule.indicator, &rule.params)?;

            // For cross_above / cross_below, resolve threshold from secondary indicator
            // or use the static threshold.
            let threshold = if rule.condition == "cross_above" || rule.condition == "cross_below" {
                get_secondary_indicator_value(indicators, &rule.indicator, &rule.params)
                    .unwrap_or(rule.threshold)
            } else {
                rule.threshold
            };

            let prev_value = prev_indicators
                .and_then(|pi| get_indicator_value(pi, &rule.indicator, &rule.params));

            let prev_threshold = prev_indicators.and_then(|pi| {
                if rule.condition == "cross_above" || rule.condition == "cross_below" {
                    get_secondary_indicator_value(pi, &rule.indicator, &rule.params)
                } else {
                    Some(rule.threshold)
                }
            });

            let triggered = evaluate_condition(
                &rule.condition,
                current_val,
                threshold,
                rule.threshold_upper,
                prev_value,
                prev_threshold,
            );

            Some(RuleEvaluation {
                rule: rule.clone(),
                current_value: current_val,
                triggered,
                signal: rule.signal.clone(),
            })
        })
        .collect()
}

// ---------------------------------------------------------------------------
// Signal formatting for Claude
// ---------------------------------------------------------------------------

/// Format a `SignalSummary` into a human-readable string suitable for an LLM prompt.
pub fn format_signals_for_claude(summary: &SignalSummary) -> String {
    let mut lines = Vec::new();
    lines.push(format!("=== Signal Report for {} ===", summary.symbol));
    lines.push(format!("Timestamp: {}", summary.timestamp));
    lines.push(format!("Current Regime: {}", summary.current_regime));
    lines.push(format!(
        "Regime Changed: {}",
        if summary.regime_changed { "YES" } else { "NO" }
    ));
    lines.push(String::new());

    if summary.evaluations.is_empty() {
        lines.push("No rules evaluated.".to_string());
    } else {
        lines.push(format!("Rule Evaluations ({}):", summary.evaluations.len()));
        for eval in &summary.evaluations {
            let status = if eval.triggered {
                "TRIGGERED"
            } else {
                "not triggered"
            };
            lines.push(format!(
                "  - {} {} {}: value={:.4} [{}] -> {}",
                eval.rule.indicator,
                eval.rule.condition,
                eval.rule.threshold,
                eval.current_value,
                status,
                eval.signal,
            ));
        }
    }

    lines.push(String::new());
    if summary.triggered_signals.is_empty() {
        lines.push("No signals triggered.".to_string());
    } else {
        lines.push(format!(
            "Triggered Signals: {}",
            summary.triggered_signals.join(", ")
        ));
    }

    lines.join("\n")
}

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

#[cfg(test)]
mod tests {
    use super::*;

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

    fn make_regime_state(current: &str, since: u64) -> RegimeState {
        RegimeState {
            current: current.to_string(),
            since,
            pending_switch: None,
        }
    }

    fn make_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_rule_with_upper(
        indicator: &str,
        params: Vec<f64>,
        condition: &str,
        threshold: f64,
        threshold_upper: f64,
        signal: &str,
    ) -> TaRule {
        TaRule {
            indicator: indicator.to_string(),
            params,
            condition: condition.to_string(),
            threshold,
            threshold_upper: Some(threshold_upper),
            signal: signal.to_string(),
            action: None,
        }
    }

    // --- Condition tests ---

    #[test]
    fn test_condition_gt() {
        let ind = make_indicators(|i| i.rsi_14 = Some(75.0));
        let rules = vec![make_rule("RSI", vec![14.0], "gt", 70.0, "overbought")];
        let evals = evaluate_rules(&rules, &ind, None);
        assert_eq!(evals.len(), 1);
        assert!(evals[0].triggered);
    }

    #[test]
    fn test_condition_gt_not_triggered() {
        let ind = make_indicators(|i| i.rsi_14 = Some(65.0));
        let rules = vec![make_rule("RSI", vec![14.0], "gt", 70.0, "overbought")];
        let evals = evaluate_rules(&rules, &ind, None);
        assert!(!evals[0].triggered);
    }

    #[test]
    fn test_condition_lt() {
        let ind = make_indicators(|i| i.rsi_14 = Some(25.0));
        let rules = vec![make_rule("RSI", vec![14.0], "lt", 30.0, "oversold")];
        let evals = evaluate_rules(&rules, &ind, None);
        assert!(evals[0].triggered);
    }

    #[test]
    fn test_condition_lt_not_triggered() {
        let ind = make_indicators(|i| i.rsi_14 = Some(35.0));
        let rules = vec![make_rule("RSI", vec![14.0], "lt", 30.0, "oversold")];
        let evals = evaluate_rules(&rules, &ind, None);
        assert!(!evals[0].triggered);
    }

    #[test]
    fn test_condition_gte() {
        let ind = make_indicators(|i| i.rsi_14 = Some(70.0));
        let rules = vec![make_rule("RSI", vec![14.0], "gte", 70.0, "overbought")];
        let evals = evaluate_rules(&rules, &ind, None);
        assert!(evals[0].triggered);
    }

    #[test]
    fn test_condition_lte() {
        let ind = make_indicators(|i| i.rsi_14 = Some(30.0));
        let rules = vec![make_rule("RSI", vec![14.0], "lte", 30.0, "oversold")];
        let evals = evaluate_rules(&rules, &ind, None);
        assert!(evals[0].triggered);
    }

    #[test]
    fn test_condition_between() {
        let ind = make_indicators(|i| i.rsi_14 = Some(50.0));
        let rules = vec![make_rule_with_upper(
            "RSI",
            vec![14.0],
            "between",
            30.0,
            70.0,
            "neutral",
        )];
        let evals = evaluate_rules(&rules, &ind, None);
        assert!(evals[0].triggered);
    }

    #[test]
    fn test_condition_between_not_triggered() {
        let ind = make_indicators(|i| i.rsi_14 = Some(80.0));
        let rules = vec![make_rule_with_upper(
            "RSI",
            vec![14.0],
            "between",
            30.0,
            70.0,
            "neutral",
        )];
        let evals = evaluate_rules(&rules, &ind, None);
        assert!(!evals[0].triggered);
    }

    #[test]
    fn test_condition_outside() {
        let ind = make_indicators(|i| i.rsi_14 = Some(80.0));
        let rules = vec![make_rule_with_upper(
            "RSI",
            vec![14.0],
            "outside",
            30.0,
            70.0,
            "extreme",
        )];
        let evals = evaluate_rules(&rules, &ind, None);
        assert!(evals[0].triggered);
    }

    #[test]
    fn test_condition_outside_not_triggered() {
        let ind = make_indicators(|i| i.rsi_14 = Some(50.0));
        let rules = vec![make_rule_with_upper(
            "RSI",
            vec![14.0],
            "outside",
            30.0,
            70.0,
            "extreme",
        )];
        let evals = evaluate_rules(&rules, &ind, None);
        assert!(!evals[0].triggered);
    }

    #[test]
    fn test_condition_cross_above() {
        let prev = make_indicators(|i| {
            i.ema_12 = Some(98.0);
            i.ema_26 = Some(100.0);
        });
        let curr = make_indicators(|i| {
            i.ema_12 = Some(101.0);
            i.ema_26 = Some(100.0);
        });
        let rules = vec![make_rule(
            "EMA",
            vec![12.0, 26.0],
            "cross_above",
            0.0,
            "golden_cross",
        )];
        let evals = evaluate_rules(&rules, &curr, Some(&prev));
        assert!(evals[0].triggered);
    }

    #[test]
    fn test_condition_cross_above_not_triggered() {
        // Already above before
        let prev = make_indicators(|i| {
            i.ema_12 = Some(102.0);
            i.ema_26 = Some(100.0);
        });
        let curr = make_indicators(|i| {
            i.ema_12 = Some(103.0);
            i.ema_26 = Some(100.0);
        });
        let rules = vec![make_rule(
            "EMA",
            vec![12.0, 26.0],
            "cross_above",
            0.0,
            "golden_cross",
        )];
        let evals = evaluate_rules(&rules, &curr, Some(&prev));
        assert!(!evals[0].triggered);
    }

    #[test]
    fn test_condition_cross_below() {
        let prev = make_indicators(|i| {
            i.ema_12 = Some(101.0);
            i.ema_26 = Some(100.0);
        });
        let curr = make_indicators(|i| {
            i.ema_12 = Some(99.0);
            i.ema_26 = Some(100.0);
        });
        let rules = vec![make_rule(
            "EMA",
            vec![12.0, 26.0],
            "cross_below",
            0.0,
            "death_cross",
        )];
        let evals = evaluate_rules(&rules, &curr, Some(&prev));
        assert!(evals[0].triggered);
    }

    #[test]
    fn test_cross_above_no_prev_returns_false() {
        let curr = make_indicators(|i| {
            i.ema_12 = Some(101.0);
            i.ema_26 = Some(100.0);
        });
        let rules = vec![make_rule(
            "EMA",
            vec![12.0, 26.0],
            "cross_above",
            0.0,
            "golden_cross",
        )];
        let evals = evaluate_rules(&rules, &curr, None);
        assert!(!evals[0].triggered);
    }

    // --- Indicator value extraction ---

    #[test]
    fn test_get_indicator_various() {
        let ind = make_indicators(|i| {
            i.rsi_14 = Some(55.0);
            i.macd_line = Some(1.5);
            i.bb_upper = Some(110.0);
            i.adx_14 = Some(25.0);
            i.atr_14 = Some(3.0);
            i.sma_20 = Some(100.0);
            i.sma_50 = Some(99.0);
        });
        assert_eq!(get_indicator_value(&ind, "RSI", &[14.0]), Some(55.0));
        assert_eq!(get_indicator_value(&ind, "MACD", &[]), Some(1.5));
        assert_eq!(get_indicator_value(&ind, "BB_upper", &[]), Some(110.0));
        assert_eq!(get_indicator_value(&ind, "ADX", &[14.0]), Some(25.0));
        assert_eq!(get_indicator_value(&ind, "ATR", &[14.0]), Some(3.0));
        assert_eq!(get_indicator_value(&ind, "SMA", &[20.0]), Some(100.0));
        assert_eq!(get_indicator_value(&ind, "SMA", &[50.0]), Some(99.0));
        assert_eq!(get_indicator_value(&ind, "UNKNOWN_IND", &[]), None);
    }

    #[test]
    fn test_get_indicator_case_insensitive() {
        let ind = make_indicators(|i| i.rsi_14 = Some(42.0));
        assert_eq!(get_indicator_value(&ind, "rsi", &[14.0]), Some(42.0));
        assert_eq!(get_indicator_value(&ind, "Rsi", &[14.0]), Some(42.0));
    }

    // --- Regime detection ---

    #[test]
    fn test_regime_stays_when_min_hold_not_met() {
        let ind = make_indicators(|i| i.rsi_14 = Some(80.0));
        let regime_rules = vec![RegimeRule {
            regime: "bull".to_string(),
            conditions: vec![make_rule("RSI", vec![14.0], "gt", 70.0, "overbought")],
            priority: 1,
        }];
        let hyst = HysteresisConfig {
            min_hold_secs: 3600,
            confirmation_count: 2,
        };
        let mut state = make_regime_state("bear", 1000);
        // now = 2000, held only 1000 secs < 3600
        let result = detect_regime(&regime_rules, "neutral", &ind, &mut state, &hyst, 2000);
        assert_eq!(result, "bear");
        assert!(state.pending_switch.is_none());
    }

    #[test]
    fn test_regime_pending_switch_starts() {
        let ind = make_indicators(|i| i.rsi_14 = Some(80.0));
        let regime_rules = vec![RegimeRule {
            regime: "bull".to_string(),
            conditions: vec![make_rule("RSI", vec![14.0], "gt", 70.0, "overbought")],
            priority: 1,
        }];
        let hyst = HysteresisConfig {
            min_hold_secs: 100,
            confirmation_count: 3,
        };
        let mut state = make_regime_state("bear", 0);
        let result = detect_regime(&regime_rules, "neutral", &ind, &mut state, &hyst, 5000);
        assert_eq!(result, "bear"); // not switched yet
        assert!(state.pending_switch.is_some());
        assert_eq!(state.pending_switch.as_ref().unwrap().target_regime, "bull");
        assert_eq!(state.pending_switch.as_ref().unwrap().confirmation_count, 1);
    }

    #[test]
    fn test_regime_switches_after_confirmations() {
        let ind = make_indicators(|i| i.rsi_14 = Some(80.0));
        let regime_rules = vec![RegimeRule {
            regime: "bull".to_string(),
            conditions: vec![make_rule("RSI", vec![14.0], "gt", 70.0, "overbought")],
            priority: 1,
        }];
        let hyst = HysteresisConfig {
            min_hold_secs: 100,
            confirmation_count: 3,
        };
        let mut state = make_regime_state("bear", 0);
        state.pending_switch = Some(PendingSwitch {
            target_regime: "bull".to_string(),
            confirmation_count: 2,
        });
        let result = detect_regime(&regime_rules, "neutral", &ind, &mut state, &hyst, 5000);
        assert_eq!(result, "bull");
        assert!(state.pending_switch.is_none());
        assert_eq!(state.since, 5000);
    }

    #[test]
    fn test_regime_pending_switch_resets_on_different_target() {
        let ind = make_indicators(|i| {
            i.rsi_14 = Some(20.0); // below 30 -> bear
            i.adx_14 = Some(10.0); // not > 50, so volatile won't match
        });
        let regime_rules = vec![
            RegimeRule {
                regime: "bull".to_string(),
                conditions: vec![make_rule("RSI", vec![14.0], "gt", 70.0, "x")],
                priority: 1,
            },
            RegimeRule {
                regime: "bear".to_string(),
                conditions: vec![make_rule("RSI", vec![14.0], "lt", 30.0, "x")],
                priority: 2,
            },
        ];
        let hyst = HysteresisConfig {
            min_hold_secs: 100,
            confirmation_count: 3,
        };
        let mut state = make_regime_state("neutral", 0);
        state.pending_switch = Some(PendingSwitch {
            target_regime: "bull".to_string(),
            confirmation_count: 2,
        });
        let result = detect_regime(&regime_rules, "neutral", &ind, &mut state, &hyst, 5000);
        assert_eq!(result, "neutral");
        let pending = state.pending_switch.as_ref().unwrap();
        assert_eq!(pending.target_regime, "bear");
        assert_eq!(pending.confirmation_count, 1);
    }

    #[test]
    fn test_regime_clears_pending_when_detected_matches_current() {
        let ind = make_indicators(|i| i.rsi_14 = Some(50.0)); // no rule matches -> default
        let regime_rules = vec![RegimeRule {
            regime: "bull".to_string(),
            conditions: vec![make_rule("RSI", vec![14.0], "gt", 70.0, "x")],
            priority: 1,
        }];
        let hyst = HysteresisConfig {
            min_hold_secs: 100,
            confirmation_count: 3,
        };
        let mut state = make_regime_state("neutral", 0);
        state.pending_switch = Some(PendingSwitch {
            target_regime: "bull".to_string(),
            confirmation_count: 2,
        });
        let result = detect_regime(&regime_rules, "neutral", &ind, &mut state, &hyst, 5000);
        assert_eq!(result, "neutral");
        assert!(state.pending_switch.is_none());
    }

    // --- Format signals ---

    #[test]
    fn test_format_signals_for_claude() {
        let summary = SignalSummary {
            symbol: "BTC-USD".to_string(),
            timestamp: 1700000000,
            current_regime: "bull".to_string(),
            regime_changed: true,
            evaluations: vec![RuleEvaluation {
                rule: make_rule("RSI", vec![14.0], "gt", 70.0, "overbought"),
                current_value: 75.0,
                triggered: true,
                signal: "overbought".to_string(),
            }],
            triggered_signals: vec!["overbought".to_string()],
        };
        let output = format_signals_for_claude(&summary);
        assert!(output.contains("BTC-USD"));
        assert!(output.contains("bull"));
        assert!(output.contains("YES"));
        assert!(output.contains("TRIGGERED"));
        assert!(output.contains("overbought"));
    }

    #[test]
    fn test_format_signals_no_triggers() {
        let summary = SignalSummary {
            symbol: "ETH-USD".to_string(),
            timestamp: 1700000000,
            current_regime: "neutral".to_string(),
            regime_changed: false,
            evaluations: vec![],
            triggered_signals: vec![],
        };
        let output = format_signals_for_claude(&summary);
        assert!(output.contains("NO"));
        assert!(output.contains("No signals triggered"));
        assert!(output.contains("No rules evaluated"));
    }

    // --- Edge cases ---

    #[test]
    fn test_evaluate_rule_missing_indicator_skipped() {
        let ind = TechnicalIndicators::empty();
        let rules = vec![make_rule("RSI", vec![14.0], "gt", 70.0, "overbought")];
        let evals = evaluate_rules(&rules, &ind, None);
        // Rule should be skipped (filter_map returns None) when indicator is None
        assert_eq!(evals.len(), 0);
    }

    #[test]
    fn test_between_without_threshold_upper_returns_false() {
        let ind = make_indicators(|i| i.rsi_14 = Some(50.0));
        // "between" without threshold_upper should not trigger
        let rules = vec![make_rule("RSI", vec![14.0], "between", 30.0, "neutral")];
        let evals = evaluate_rules(&rules, &ind, None);
        assert!(!evals[0].triggered);
    }

    #[test]
    fn test_unknown_condition_returns_false() {
        let ind = make_indicators(|i| i.rsi_14 = Some(50.0));
        let rules = vec![make_rule("RSI", vec![14.0], "foobar", 30.0, "x")];
        let evals = evaluate_rules(&rules, &ind, None);
        assert!(!evals[0].triggered);
    }

    #[test]
    fn test_multiple_rules_mixed_results() {
        let ind = make_indicators(|i| {
            i.rsi_14 = Some(75.0);
            i.adx_14 = Some(20.0);
        });
        let rules = vec![
            make_rule("RSI", vec![14.0], "gt", 70.0, "overbought"),
            make_rule("ADX", vec![14.0], "gt", 25.0, "strong_trend"),
        ];
        let evals = evaluate_rules(&rules, &ind, None);
        assert_eq!(evals.len(), 2);
        assert!(evals[0].triggered);
        assert!(!evals[1].triggered);
    }

    #[test]
    fn test_boundary_values_gte_lte() {
        let ind = make_indicators(|i| i.rsi_14 = Some(70.0));
        let r1 = make_rule("RSI", vec![14.0], "gt", 70.0, "x");
        let r2 = make_rule("RSI", vec![14.0], "gte", 70.0, "x");
        let r3 = make_rule("RSI", vec![14.0], "lt", 70.0, "x");
        let r4 = make_rule("RSI", vec![14.0], "lte", 70.0, "x");
        let e = evaluate_rules(&[r1, r2, r3, r4], &ind, None);
        assert!(!e[0].triggered); // gt 70 when val=70 -> false
        assert!(e[1].triggered); // gte 70 when val=70 -> true
        assert!(!e[2].triggered); // lt 70 when val=70 -> false
        assert!(e[3].triggered); // lte 70 when val=70 -> true
    }

    #[test]
    fn test_between_boundary_inclusive() {
        let lower = make_indicators(|i| i.rsi_14 = Some(30.0));
        let upper = make_indicators(|i| i.rsi_14 = Some(70.0));
        let rule = make_rule_with_upper("RSI", vec![14.0], "between", 30.0, 70.0, "x");
        let e1 = evaluate_rules(&[rule.clone()], &lower, None);
        let e2 = evaluate_rules(&[rule], &upper, None);
        assert!(e1[0].triggered); // boundary inclusive
        assert!(e2[0].triggered);
    }

    #[test]
    fn test_outside_boundary_exclusive() {
        // value = 30.0, outside [30, 70] means < 30 or > 70 -> false (30 is not < 30)
        let at_lower = make_indicators(|i| i.rsi_14 = Some(30.0));
        let below_lower = make_indicators(|i| i.rsi_14 = Some(29.9));
        let rule = make_rule_with_upper("RSI", vec![14.0], "outside", 30.0, 70.0, "x");
        let e1 = evaluate_rules(&[rule.clone()], &at_lower, None);
        let e2 = evaluate_rules(&[rule], &below_lower, None);
        assert!(!e1[0].triggered);
        assert!(e2[0].triggered);
    }
}