hyper_strategy/

strategy_composer.rs

use serde::{Deserialize, Serialize};

use crate::rule_engine::evaluate_rules;
use crate::strategy_templates::build_template;
use hyper_risk::risk_defaults::{
    apply_adx_filter, base_position_pct, volume_strength_modifier, VolumeContext,
};
use hyper_ta::technical_analysis::TechnicalIndicators;

// ---------------------------------------------------------------------------
// Market State
// ---------------------------------------------------------------------------

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum TrendDirection {
    Bullish,
    Bearish,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(rename_all = "snake_case", tag = "type")]
pub enum MarketState {
    StrongTrend { direction: TrendDirection },
    MildTrend { direction: TrendDirection },
    Ranging,
    SqueezeBuilding,
    VolExpansion,
    VolContraction,
}

impl std::fmt::Display for MarketState {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            MarketState::StrongTrend { direction } => {
                write!(f, "StrongTrend ({:?})", direction)
            }
            MarketState::MildTrend { direction } => {
                write!(f, "MildTrend ({:?})", direction)
            }
            MarketState::Ranging => write!(f, "Ranging"),
            MarketState::SqueezeBuilding => write!(f, "SqueezeBuilding"),
            MarketState::VolExpansion => write!(f, "VolExpansion"),
            MarketState::VolContraction => write!(f, "VolContraction"),
        }
    }
}

// ---------------------------------------------------------------------------
// Composer Profile
// ---------------------------------------------------------------------------

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum ComposerProfile {
    Conservative,
    AllWeather,
    TurtleSystem,
}

impl std::fmt::Display for ComposerProfile {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ComposerProfile::Conservative => write!(f, "Conservative"),
            ComposerProfile::AllWeather => write!(f, "AllWeather"),
            ComposerProfile::TurtleSystem => write!(f, "TurtleSystem"),
        }
    }
}

// ---------------------------------------------------------------------------
// Signal types
// ---------------------------------------------------------------------------

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum SignalDirection {
    Long,
    Short,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ActiveStrategy {
    pub template_id: String,
    pub category: String,
    pub weight: f64,
    pub reason: String,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct StrategySignal {
    pub template_id: String,
    pub direction: Option<SignalDirection>,
    pub strength: f64,
    pub triggered_rules: Vec<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ComposedSignal {
    pub market_state: MarketState,
    pub active_strategies: Vec<ActiveStrategy>,
    pub direction: Option<SignalDirection>,
    pub aggregated_strength: f64,
    pub suggested_exposure_pct: f64,
    pub signals: Vec<StrategySignal>,
    pub conflicts: Vec<String>,
}

// ---------------------------------------------------------------------------
// StrategyComposer
// ---------------------------------------------------------------------------

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct StrategyComposer {
    pub profile: ComposerProfile,
    pub symbol: String,
    pub max_exposure_pct: f64,
}

impl StrategyComposer {
    pub fn new(profile: ComposerProfile, symbol: &str) -> Self {
        Self {
            profile,
            symbol: symbol.to_string(),
            max_exposure_pct: 100.0,
        }
    }

    /// Detect current market state from indicators.
    pub fn detect_market_state(indicators: &TechnicalIndicators) -> MarketState {
        // Squeeze detection: BB inside KC
        if let (Some(bb_upper), Some(bb_lower), Some(kc_upper), Some(kc_lower)) = (
            indicators.bb_upper,
            indicators.bb_lower,
            indicators.kc_upper_20,
            indicators.kc_lower_20,
        ) {
            if bb_upper < kc_upper && bb_lower > kc_lower {
                return MarketState::SqueezeBuilding;
            }
        }

        // Trend strength via ADX
        if let Some(adx) = indicators.adx_14 {
            if adx > 30.0 {
                let direction = Self::detect_trend_direction(indicators);
                return MarketState::StrongTrend { direction };
            }
            if adx >= 20.0 {
                let direction = Self::detect_trend_direction(indicators);
                return MarketState::MildTrend { direction };
            }
        }

        // Volatility expansion / contraction
        if let (Some(hv_20), Some(hv_60)) = (indicators.hv_20, indicators.hv_60) {
            if hv_20 > hv_60 {
                return MarketState::VolExpansion;
            } else {
                return MarketState::VolContraction;
            }
        }

        // Default: Ranging (low ADX or missing data)
        MarketState::Ranging
    }

    /// Determine trend direction from available indicators.
    fn detect_trend_direction(indicators: &TechnicalIndicators) -> TrendDirection {
        // Use SMA crossover as primary signal
        if let (Some(sma20), Some(sma50)) = (indicators.sma_20, indicators.sma_50) {
            return if sma20 > sma50 {
                TrendDirection::Bullish
            } else {
                TrendDirection::Bearish
            };
        }
        // Fallback: EMA
        if let (Some(ema12), Some(ema26)) = (indicators.ema_12, indicators.ema_26) {
            return if ema12 > ema26 {
                TrendDirection::Bullish
            } else {
                TrendDirection::Bearish
            };
        }
        // Fallback: SuperTrend direction
        if let Some(st_dir) = indicators.supertrend_direction {
            return if st_dir > 0.0 {
                TrendDirection::Bullish
            } else {
                TrendDirection::Bearish
            };
        }
        TrendDirection::Bullish // default when no data
    }

    /// Get active strategy template IDs for current market state.
    pub fn active_strategies(&self, state: &MarketState) -> Vec<ActiveStrategy> {
        match &self.profile {
            ComposerProfile::Conservative => self.conservative_strategies(state),
            ComposerProfile::AllWeather => self.all_weather_strategies(state),
            ComposerProfile::TurtleSystem => self.turtle_strategies(state),
        }
    }

    fn conservative_strategies(&self, state: &MarketState) -> Vec<ActiveStrategy> {
        match state {
            MarketState::StrongTrend { .. } => vec![
                ActiveStrategy {
                    template_id: "supertrend".into(),
                    category: "trend_following".into(),
                    weight: 1.0,
                    reason: "Strong trend detected — SuperTrend for trend capture".into(),
                },
                ActiveStrategy {
                    template_id: "adx_di_crossover".into(),
                    category: "trend_following".into(),
                    weight: 1.0,
                    reason: "Strong trend detected — ADX/DI for directional confirmation".into(),
                },
            ],
            MarketState::Ranging => vec![ActiveStrategy {
                template_id: "bb_confirmed".into(),
                category: "mean_reversion".into(),
                weight: 1.0,
                reason: "Ranging market — BB confirmed for mean reversion".into(),
            }],
            MarketState::SqueezeBuilding => vec![ActiveStrategy {
                template_id: "keltner_squeeze".into(),
                category: "volatility".into(),
                weight: 1.0,
                reason: "Squeeze building — Keltner squeeze for breakout".into(),
            }],
            MarketState::MildTrend { .. } => vec![ActiveStrategy {
                template_id: "ma_crossover".into(),
                category: "trend_following".into(),
                weight: 0.7,
                reason: "Mild trend — MA crossover with reduced weight".into(),
            }],
            _ => vec![], // VolExpansion, VolContraction — sit out
        }
    }

    fn all_weather_strategies(&self, state: &MarketState) -> Vec<ActiveStrategy> {
        let mut strategies = vec![
            ActiveStrategy {
                template_id: "cta_trend_following".into(),
                category: "trend_following".into(),
                weight: 1.0,
                reason: "Always active — CTA trend following core".into(),
            },
            ActiveStrategy {
                template_id: "confluence".into(),
                category: "composite".into(),
                weight: 0.5,
                reason: "Always active — confluence triple-confirm filter".into(),
            },
        ];

        match state {
            MarketState::StrongTrend { .. } => {
                strategies.push(ActiveStrategy {
                    template_id: "macd_momentum".into(),
                    category: "momentum".into(),
                    weight: 0.8,
                    reason: "Strong trend — MACD momentum boost".into(),
                });
            }
            MarketState::Ranging => {
                strategies.push(ActiveStrategy {
                    template_id: "zscore_reversion".into(),
                    category: "mean_reversion".into(),
                    weight: 0.8,
                    reason: "Ranging — z-score mean reversion".into(),
                });
                strategies.push(ActiveStrategy {
                    template_id: "bb_confirmed".into(),
                    category: "mean_reversion".into(),
                    weight: 0.7,
                    reason: "Ranging — BB confirmed mean reversion".into(),
                });
            }
            MarketState::SqueezeBuilding => {
                strategies.push(ActiveStrategy {
                    template_id: "breakout_volume".into(),
                    category: "volatility".into(),
                    weight: 0.9,
                    reason: "Squeeze building — volume breakout".into(),
                });
            }
            MarketState::VolExpansion => {
                strategies.push(ActiveStrategy {
                    template_id: "atr_breakout".into(),
                    category: "volatility".into(),
                    weight: 0.8,
                    reason: "Vol expansion — ATR breakout".into(),
                });
            }
            _ => {}
        }

        strategies
    }

    fn turtle_strategies(&self, state: &MarketState) -> Vec<ActiveStrategy> {
        let mut strategies = vec![ActiveStrategy {
            template_id: "donchian_breakout".into(),
            category: "trend_following".into(),
            weight: 1.0,
            reason: "Always active — Donchian breakout core".into(),
        }];

        if matches!(state, MarketState::StrongTrend { .. }) {
            strategies.push(ActiveStrategy {
                template_id: "supertrend".into(),
                category: "trend_following".into(),
                weight: 0.8,
                reason: "Strong trend — SuperTrend confirmation".into(),
            });
        }

        strategies
    }

    /// Evaluate all active strategies and aggregate signals.
    pub fn compose_signals(
        &self,
        indicators: &TechnicalIndicators,
        prev_indicators: Option<&TechnicalIndicators>,
        volume_context: &VolumeContext,
    ) -> ComposedSignal {
        let market_state = Self::detect_market_state(indicators);
        let active = self.active_strategies(&market_state);

        let mut signals: Vec<StrategySignal> = Vec::new();
        let mut long_count: usize = 0;
        let mut short_count: usize = 0;
        let mut long_strength_sum: f64 = 0.0;
        let mut short_strength_sum: f64 = 0.0;
        let mut conflicts: Vec<String> = Vec::new();
        let mut dominant_category = String::new();
        let mut max_weight: f64 = 0.0;

        for active_strat in &active {
            // Track dominant category (highest weight)
            if active_strat.weight > max_weight {
                max_weight = active_strat.weight;
                dominant_category = active_strat.category.clone();
            }

            let group = match build_template(&active_strat.template_id, &self.symbol) {
                Some(g) => g,
                None => continue,
            };

            // Get rules from the default regime playbook
            let playbook = match group.playbooks.get(&group.default_regime) {
                Some(pb) => pb,
                None => continue,
            };

            let evaluations = evaluate_rules(
                playbook.effective_entry_rules(),
                indicators,
                prev_indicators,
            );
            let total_rules = playbook.effective_entry_rules().len();
            let triggered: Vec<String> = evaluations
                .iter()
                .filter(|e| e.triggered)
                .map(|e| e.signal.clone())
                .collect();
            let triggered_count = triggered.len();

            // Classify direction from signal names
            let (has_long, has_short) = classify_signals(&triggered);

            let direction = if has_long && !has_short {
                Some(SignalDirection::Long)
            } else if has_short && !has_long {
                Some(SignalDirection::Short)
            } else {
                None
            };

            // Per-strategy strength
            let raw_strength = if total_rules > 0 {
                (triggered_count as f64 / total_rules as f64) * active_strat.weight
            } else {
                0.0
            };

            // Apply ADX filter for mean_reversion strategies
            let strength = if active_strat.category == "mean_reversion" {
                apply_adx_filter(raw_strength, indicators.adx_14)
            } else {
                raw_strength
            };

            match &direction {
                Some(SignalDirection::Long) => {
                    long_count += 1;
                    long_strength_sum += strength;
                }
                Some(SignalDirection::Short) => {
                    short_count += 1;
                    short_strength_sum += strength;
                }
                None => {
                    if has_long && has_short {
                        conflicts.push(format!(
                            "{}: mixed long/short signals",
                            active_strat.template_id
                        ));
                    }
                }
            }

            signals.push(StrategySignal {
                template_id: active_strat.template_id.clone(),
                direction,
                strength,
                triggered_rules: triggered,
            });
        }

        // Aggregate direction and strength
        let (agg_direction, base_strength) = if long_count > 0 && short_count > 0 {
            // Conflicting signals across strategies
            conflicts.push(format!(
                "Cross-strategy conflict: {} long vs {} short signals",
                long_count, short_count
            ));
            (None, 0.0)
        } else if long_count > 0 {
            let avg = long_strength_sum / long_count as f64;
            let modifier = count_modifier(long_count);
            (Some(SignalDirection::Long), (avg * modifier).min(1.0))
        } else if short_count > 0 {
            let avg = short_strength_sum / short_count as f64;
            let modifier = count_modifier(short_count);
            (Some(SignalDirection::Short), (avg * modifier).min(1.0))
        } else {
            (None, 0.0)
        };

        // Apply volume modifier
        let cat_for_volume = if dominant_category.is_empty() {
            "unknown"
        } else {
            &dominant_category
        };
        let vol_mod = volume_strength_modifier(volume_context, cat_for_volume);
        let aggregated_strength = (base_strength * vol_mod).min(1.0).max(0.0);

        // Position sizing
        let base_pct = base_position_pct(cat_for_volume);
        let suggested_exposure_pct =
            (base_pct * aggregated_strength * 100.0).min(self.max_exposure_pct);

        ComposedSignal {
            market_state,
            active_strategies: active,
            direction: agg_direction,
            aggregated_strength,
            suggested_exposure_pct,
            signals,
            conflicts,
        }
    }

    /// Format a ComposedSignal for inclusion in a Claude prompt.
    pub fn format_for_claude(&self, signal: &ComposedSignal) -> String {
        let mut lines = Vec::new();

        lines.push(format!("📊 Market State: {}", signal.market_state));
        lines.push(format!("📋 Profile: {}", self.profile));

        let active_names: Vec<&str> = signal
            .active_strategies
            .iter()
            .map(|a| a.template_id.as_str())
            .collect();
        lines.push(format!("🎯 Active Strategies: {}", active_names.join(", ")));

        match &signal.direction {
            Some(SignalDirection::Long) => {
                lines.push(format!(
                    "📈 Signal: LONG (strength: {:.2})",
                    signal.aggregated_strength
                ));
            }
            Some(SignalDirection::Short) => {
                lines.push(format!(
                    "📉 Signal: SHORT (strength: {:.2})",
                    signal.aggregated_strength
                ));
            }
            None => {
                if signal.conflicts.is_empty() {
                    lines.push("⏸️ Signal: NONE (no triggers)".into());
                } else {
                    lines.push("⚠️ Signal: NONE (conflicting)".into());
                }
            }
        }

        lines.push(format!(
            "💰 Suggested Exposure: {:.1}%",
            signal.suggested_exposure_pct
        ));

        // Per-strategy breakdown
        let has_triggered = signal.signals.iter().any(|s| !s.triggered_rules.is_empty());
        if has_triggered {
            lines.push("⚡ Triggered:".into());
            for s in &signal.signals {
                if !s.triggered_rules.is_empty() {
                    let dir_str = match &s.direction {
                        Some(SignalDirection::Long) => "LONG",
                        Some(SignalDirection::Short) => "SHORT",
                        None => "MIXED",
                    };
                    lines.push(format!(
                        "  - {}: {} → {}",
                        s.template_id,
                        s.triggered_rules.join(" + "),
                        dir_str
                    ));
                }
            }
        }

        if !signal.conflicts.is_empty() {
            lines.push("⚠️ Conflicts:".into());
            for c in &signal.conflicts {
                lines.push(format!("  - {}", c));
            }
        }

        lines.join("\n")
    }
}

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

/// Classify signal names into long/short buckets.
fn classify_signals(signals: &[String]) -> (bool, bool) {
    let mut has_long = false;
    let mut has_short = false;
    for s in signals {
        let lower = s.to_lowercase();
        if lower.contains("long")
            || lower.contains("bull")
            || lower.contains("buy")
            || lower.contains("golden")
        {
            has_long = true;
        }
        if lower.contains("short")
            || lower.contains("bear")
            || lower.contains("sell")
            || lower.contains("death")
        {
            has_short = true;
        }
    }
    (has_long, has_short)
}

/// Count modifier: more strategies confirming = stronger signal.
fn count_modifier(count: usize) -> f64 {
    match count {
        0 => 0.0,
        1 => 1.0,
        2 => 1.3,
        _ => 1.5,
    }
}

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

    // =======================================================================
    // Market State Detection
    // =======================================================================

    #[test]
    fn test_detect_strong_trend_bullish() {
        let ind = make_indicators(|i| {
            i.adx_14 = Some(35.0);
            i.sma_20 = Some(110.0);
            i.sma_50 = Some(100.0);
        });
        let state = StrategyComposer::detect_market_state(&ind);
        assert_eq!(
            state,
            MarketState::StrongTrend {
                direction: TrendDirection::Bullish
            }
        );
    }

    #[test]
    fn test_detect_strong_trend_bearish() {
        let ind = make_indicators(|i| {
            i.adx_14 = Some(40.0);
            i.sma_20 = Some(90.0);
            i.sma_50 = Some(100.0);
        });
        let state = StrategyComposer::detect_market_state(&ind);
        assert_eq!(
            state,
            MarketState::StrongTrend {
                direction: TrendDirection::Bearish
            }
        );
    }

    #[test]
    fn test_detect_mild_trend() {
        let ind = make_indicators(|i| {
            i.adx_14 = Some(25.0);
            i.sma_20 = Some(105.0);
            i.sma_50 = Some(100.0);
        });
        let state = StrategyComposer::detect_market_state(&ind);
        assert_eq!(
            state,
            MarketState::MildTrend {
                direction: TrendDirection::Bullish
            }
        );
    }

    #[test]
    fn test_detect_ranging_low_adx() {
        let ind = make_indicators(|i| {
            i.adx_14 = Some(15.0);
        });
        let state = StrategyComposer::detect_market_state(&ind);
        assert_eq!(state, MarketState::Ranging);
    }

    #[test]
    fn test_detect_squeeze_building() {
        let ind = make_indicators(|i| {
            i.bb_upper = Some(105.0);
            i.bb_lower = Some(95.0);
            i.kc_upper_20 = Some(110.0);
            i.kc_lower_20 = Some(90.0);
            i.adx_14 = Some(35.0); // ADX high but squeeze takes priority
            i.sma_20 = Some(100.0);
            i.sma_50 = Some(100.0);
        });
        let state = StrategyComposer::detect_market_state(&ind);
        assert_eq!(state, MarketState::SqueezeBuilding);
    }

    #[test]
    fn test_detect_squeeze_not_building_bb_outside_kc() {
        let ind = make_indicators(|i| {
            i.bb_upper = Some(115.0); // BB wider than KC
            i.bb_lower = Some(85.0);
            i.kc_upper_20 = Some(110.0);
            i.kc_lower_20 = Some(90.0);
            i.adx_14 = Some(15.0);
        });
        let state = StrategyComposer::detect_market_state(&ind);
        // Not squeeze, ADX < 20 and no HV -> Ranging
        assert_eq!(state, MarketState::Ranging);
    }

    #[test]
    fn test_detect_vol_expansion() {
        let ind = make_indicators(|i| {
            i.adx_14 = Some(15.0);
            i.hv_20 = Some(0.5);
            i.hv_60 = Some(0.3);
        });
        let state = StrategyComposer::detect_market_state(&ind);
        assert_eq!(state, MarketState::VolExpansion);
    }

    #[test]
    fn test_detect_vol_contraction() {
        let ind = make_indicators(|i| {
            i.adx_14 = Some(15.0);
            i.hv_20 = Some(0.2);
            i.hv_60 = Some(0.4);
        });
        let state = StrategyComposer::detect_market_state(&ind);
        assert_eq!(state, MarketState::VolContraction);
    }

    #[test]
    fn test_detect_ranging_no_data() {
        let ind = TechnicalIndicators::empty();
        let state = StrategyComposer::detect_market_state(&ind);
        assert_eq!(state, MarketState::Ranging);
    }

    #[test]
    fn test_detect_trend_direction_ema_fallback() {
        let ind = make_indicators(|i| {
            i.adx_14 = Some(35.0);
            // No SMA, use EMA fallback
            i.ema_12 = Some(90.0);
            i.ema_26 = Some(100.0);
        });
        let state = StrategyComposer::detect_market_state(&ind);
        assert_eq!(
            state,
            MarketState::StrongTrend {
                direction: TrendDirection::Bearish
            }
        );
    }

    #[test]
    fn test_detect_trend_direction_supertrend_fallback() {
        let ind = make_indicators(|i| {
            i.adx_14 = Some(35.0);
            i.supertrend_direction = Some(1.0);
        });
        let state = StrategyComposer::detect_market_state(&ind);
        assert_eq!(
            state,
            MarketState::StrongTrend {
                direction: TrendDirection::Bullish
            }
        );
    }

    // =======================================================================
    // Strategy Selection — Conservative
    // =======================================================================

    #[test]
    fn test_conservative_strong_trend() {
        let composer = StrategyComposer::new(ComposerProfile::Conservative, "BTC-USD");
        let state = MarketState::StrongTrend {
            direction: TrendDirection::Bullish,
        };
        let active = composer.active_strategies(&state);
        assert_eq!(active.len(), 2);
        assert_eq!(active[0].template_id, "supertrend");
        assert_eq!(active[1].template_id, "adx_di_crossover");
        assert_eq!(active[0].weight, 1.0);
    }

    #[test]
    fn test_conservative_ranging() {
        let composer = StrategyComposer::new(ComposerProfile::Conservative, "BTC-USD");
        let active = composer.active_strategies(&MarketState::Ranging);
        assert_eq!(active.len(), 1);
        assert_eq!(active[0].template_id, "bb_confirmed");
    }

    #[test]
    fn test_conservative_squeeze() {
        let composer = StrategyComposer::new(ComposerProfile::Conservative, "BTC-USD");
        let active = composer.active_strategies(&MarketState::SqueezeBuilding);
        assert_eq!(active.len(), 1);
        assert_eq!(active[0].template_id, "keltner_squeeze");
    }

    #[test]
    fn test_conservative_mild_trend() {
        let composer = StrategyComposer::new(ComposerProfile::Conservative, "BTC-USD");
        let state = MarketState::MildTrend {
            direction: TrendDirection::Bearish,
        };
        let active = composer.active_strategies(&state);
        assert_eq!(active.len(), 1);
        assert_eq!(active[0].template_id, "ma_crossover");
        assert!((active[0].weight - 0.7).abs() < 1e-10);
    }

    #[test]
    fn test_conservative_vol_expansion_sits_out() {
        let composer = StrategyComposer::new(ComposerProfile::Conservative, "BTC-USD");
        let active = composer.active_strategies(&MarketState::VolExpansion);
        assert!(active.is_empty());
    }

    #[test]
    fn test_conservative_vol_contraction_sits_out() {
        let composer = StrategyComposer::new(ComposerProfile::Conservative, "BTC-USD");
        let active = composer.active_strategies(&MarketState::VolContraction);
        assert!(active.is_empty());
    }

    // =======================================================================
    // Strategy Selection — AllWeather
    // =======================================================================

    #[test]
    fn test_all_weather_always_has_core() {
        let composer = StrategyComposer::new(ComposerProfile::AllWeather, "BTC-USD");
        // Any state should have cta_trend_following and confluence
        let states = vec![
            MarketState::Ranging,
            MarketState::VolExpansion,
            MarketState::VolContraction,
        ];
        for state in &states {
            let active = composer.active_strategies(state);
            let ids: Vec<&str> = active.iter().map(|a| a.template_id.as_str()).collect();
            assert!(
                ids.contains(&"cta_trend_following"),
                "Missing cta_trend_following for {:?}",
                state
            );
            assert!(
                ids.contains(&"confluence"),
                "Missing confluence for {:?}",
                state
            );
        }
    }

    #[test]
    fn test_all_weather_strong_trend_adds_macd() {
        let composer = StrategyComposer::new(ComposerProfile::AllWeather, "BTC-USD");
        let state = MarketState::StrongTrend {
            direction: TrendDirection::Bullish,
        };
        let active = composer.active_strategies(&state);
        let ids: Vec<&str> = active.iter().map(|a| a.template_id.as_str()).collect();
        assert!(ids.contains(&"macd_momentum"));
    }

    #[test]
    fn test_all_weather_ranging_adds_reversion() {
        let composer = StrategyComposer::new(ComposerProfile::AllWeather, "BTC-USD");
        let active = composer.active_strategies(&MarketState::Ranging);
        let ids: Vec<&str> = active.iter().map(|a| a.template_id.as_str()).collect();
        assert!(ids.contains(&"zscore_reversion"));
        assert!(ids.contains(&"bb_confirmed"));
    }

    #[test]
    fn test_all_weather_squeeze_adds_breakout_volume() {
        let composer = StrategyComposer::new(ComposerProfile::AllWeather, "BTC-USD");
        let active = composer.active_strategies(&MarketState::SqueezeBuilding);
        let ids: Vec<&str> = active.iter().map(|a| a.template_id.as_str()).collect();
        assert!(ids.contains(&"breakout_volume"));
    }

    #[test]
    fn test_all_weather_vol_expansion_adds_atr_breakout() {
        let composer = StrategyComposer::new(ComposerProfile::AllWeather, "BTC-USD");
        let active = composer.active_strategies(&MarketState::VolExpansion);
        let ids: Vec<&str> = active.iter().map(|a| a.template_id.as_str()).collect();
        assert!(ids.contains(&"atr_breakout"));
    }

    // =======================================================================
    // Strategy Selection — Turtle
    // =======================================================================

    #[test]
    fn test_turtle_always_has_donchian() {
        let composer = StrategyComposer::new(ComposerProfile::TurtleSystem, "BTC-USD");
        let active = composer.active_strategies(&MarketState::Ranging);
        assert_eq!(active.len(), 1);
        assert_eq!(active[0].template_id, "donchian_breakout");
    }

    #[test]
    fn test_turtle_strong_trend_adds_supertrend() {
        let composer = StrategyComposer::new(ComposerProfile::TurtleSystem, "BTC-USD");
        let state = MarketState::StrongTrend {
            direction: TrendDirection::Bearish,
        };
        let active = composer.active_strategies(&state);
        assert_eq!(active.len(), 2);
        assert_eq!(active[1].template_id, "supertrend");
        assert!((active[1].weight - 0.8).abs() < 1e-10);
    }

    // =======================================================================
    // Signal Classification
    // =======================================================================

    #[test]
    fn test_classify_long_signals() {
        let signals = vec!["supertrend_bullish".to_string(), "golden_cross".to_string()];
        let (has_long, has_short) = classify_signals(&signals);
        assert!(has_long);
        assert!(!has_short);
    }

    #[test]
    fn test_classify_short_signals() {
        let signals = vec![
            "supertrend_bearish".to_string(),
            "death_cross".to_string(),
            "sell_signal".to_string(),
        ];
        let (has_long, has_short) = classify_signals(&signals);
        assert!(!has_long);
        assert!(has_short);
    }

    #[test]
    fn test_classify_mixed_signals() {
        let signals = vec!["supertrend_bullish".to_string(), "macd_bearish".to_string()];
        let (has_long, has_short) = classify_signals(&signals);
        assert!(has_long);
        assert!(has_short);
    }

    #[test]
    fn test_classify_neutral_signals() {
        let signals = vec!["some_neutral".to_string()];
        let (has_long, has_short) = classify_signals(&signals);
        assert!(!has_long);
        assert!(!has_short);
    }

    #[test]
    fn test_classify_empty() {
        let (has_long, has_short) = classify_signals(&[]);
        assert!(!has_long);
        assert!(!has_short);
    }

    // =======================================================================
    // Count Modifier
    // =======================================================================

    #[test]
    fn test_count_modifier_values() {
        assert_eq!(count_modifier(0), 0.0);
        assert_eq!(count_modifier(1), 1.0);
        assert_eq!(count_modifier(2), 1.3);
        assert_eq!(count_modifier(3), 1.5);
        assert_eq!(count_modifier(5), 1.5);
    }

    // =======================================================================
    // Compose Signals — Integration
    // =======================================================================

    #[test]
    fn test_compose_signals_no_data_returns_empty() {
        let composer = StrategyComposer::new(ComposerProfile::Conservative, "BTC-USD");
        let ind = TechnicalIndicators::empty();
        let signal = composer.compose_signals(&ind, None, &VolumeContext::Normal);
        // With empty indicators, market state = Ranging, bb_confirmed is active
        // but rules won't trigger because indicators are missing
        assert_eq!(signal.market_state, MarketState::Ranging);
        assert_eq!(signal.aggregated_strength, 0.0);
        assert_eq!(signal.suggested_exposure_pct, 0.0);
    }

    #[test]
    fn test_compose_signals_conservative_sits_out_vol_expansion() {
        let composer = StrategyComposer::new(ComposerProfile::Conservative, "BTC-USD");
        let ind = make_indicators(|i| {
            i.adx_14 = Some(15.0);
            i.hv_20 = Some(0.5);
            i.hv_60 = Some(0.3);
        });
        let signal = composer.compose_signals(&ind, None, &VolumeContext::Normal);
        assert_eq!(signal.market_state, MarketState::VolExpansion);
        assert!(signal.active_strategies.is_empty());
        assert_eq!(signal.aggregated_strength, 0.0);
    }

    #[test]
    fn test_compose_signals_exposure_capped_at_max() {
        let mut composer = StrategyComposer::new(ComposerProfile::Conservative, "BTC-USD");
        composer.max_exposure_pct = 10.0;
        let ind = make_indicators(|i| {
            i.adx_14 = Some(35.0);
            i.sma_20 = Some(110.0);
            i.sma_50 = Some(100.0);
            i.supertrend_direction = Some(1.0);
        });
        let signal = composer.compose_signals(&ind, None, &VolumeContext::Normal);
        assert!(signal.suggested_exposure_pct <= 10.0);
    }

    #[test]
    fn test_compose_signals_turtle_strong_trend() {
        let composer = StrategyComposer::new(ComposerProfile::TurtleSystem, "BTC-USD");
        let ind = make_indicators(|i| {
            i.adx_14 = Some(35.0);
            i.sma_20 = Some(110.0);
            i.sma_50 = Some(100.0);
            // Supertrend bullish
            i.supertrend_direction = Some(1.0);
            i.supertrend_value = Some(95.0);
            // Donchian
            i.donchian_upper_20 = Some(120.0);
            i.donchian_lower_20 = Some(80.0);
            i.donchian_upper_10 = Some(115.0);
            i.donchian_lower_10 = Some(85.0);
        });
        let signal = composer.compose_signals(&ind, None, &VolumeContext::Normal);
        assert_eq!(
            signal.market_state,
            MarketState::StrongTrend {
                direction: TrendDirection::Bullish
            }
        );
        assert_eq!(signal.active_strategies.len(), 2);
    }

    // =======================================================================
    // Format for Claude
    // =======================================================================

    #[test]
    fn test_format_for_claude_contains_key_info() {
        let composer = StrategyComposer::new(ComposerProfile::AllWeather, "BTC-USD");
        let signal = ComposedSignal {
            market_state: MarketState::StrongTrend {
                direction: TrendDirection::Bullish,
            },
            active_strategies: vec![ActiveStrategy {
                template_id: "cta_trend_following".into(),
                category: "trend_following".into(),
                weight: 1.0,
                reason: "test".into(),
            }],
            direction: Some(SignalDirection::Long),
            aggregated_strength: 0.85,
            suggested_exposure_pct: 45.0,
            signals: vec![StrategySignal {
                template_id: "cta_trend_following".into(),
                direction: Some(SignalDirection::Long),
                strength: 0.85,
                triggered_rules: vec!["sma_bullish".into()],
            }],
            conflicts: vec![],
        };
        let output = composer.format_for_claude(&signal);
        assert!(output.contains("StrongTrend"));
        assert!(output.contains("AllWeather"));
        assert!(output.contains("LONG"));
        assert!(output.contains("0.85"));
        assert!(output.contains("45.0%"));
        assert!(output.contains("cta_trend_following"));
        assert!(output.contains("sma_bullish"));
    }

    #[test]
    fn test_format_for_claude_no_signals() {
        let composer = StrategyComposer::new(ComposerProfile::Conservative, "BTC-USD");
        let signal = ComposedSignal {
            market_state: MarketState::Ranging,
            active_strategies: vec![],
            direction: None,
            aggregated_strength: 0.0,
            suggested_exposure_pct: 0.0,
            signals: vec![],
            conflicts: vec![],
        };
        let output = composer.format_for_claude(&signal);
        assert!(output.contains("NONE"));
        assert!(output.contains("no triggers"));
    }

    #[test]
    fn test_format_for_claude_conflicts() {
        let composer = StrategyComposer::new(ComposerProfile::AllWeather, "BTC-USD");
        let signal = ComposedSignal {
            market_state: MarketState::Ranging,
            active_strategies: vec![],
            direction: None,
            aggregated_strength: 0.0,
            suggested_exposure_pct: 0.0,
            signals: vec![],
            conflicts: vec!["Cross-strategy conflict".into()],
        };
        let output = composer.format_for_claude(&signal);
        assert!(output.contains("conflicting"));
        assert!(output.contains("Cross-strategy conflict"));
    }

    // =======================================================================
    // Serialization
    // =======================================================================

    #[test]
    fn test_market_state_serialization_roundtrip() {
        let states = vec![
            MarketState::StrongTrend {
                direction: TrendDirection::Bullish,
            },
            MarketState::MildTrend {
                direction: TrendDirection::Bearish,
            },
            MarketState::Ranging,
            MarketState::SqueezeBuilding,
            MarketState::VolExpansion,
            MarketState::VolContraction,
        ];
        for state in &states {
            let json = serde_json::to_string(state).unwrap();
            let parsed: MarketState = serde_json::from_str(&json).unwrap();
            assert_eq!(*state, parsed);
        }
    }

    #[test]
    fn test_composer_profile_serialization_roundtrip() {
        let profiles = vec![
            ComposerProfile::Conservative,
            ComposerProfile::AllWeather,
            ComposerProfile::TurtleSystem,
        ];
        for p in &profiles {
            let json = serde_json::to_string(p).unwrap();
            let parsed: ComposerProfile = serde_json::from_str(&json).unwrap();
            assert_eq!(*p, parsed);
        }
    }

    #[test]
    fn test_signal_direction_serialization() {
        let long = SignalDirection::Long;
        let json = serde_json::to_string(&long).unwrap();
        let parsed: SignalDirection = serde_json::from_str(&json).unwrap();
        assert_eq!(parsed, SignalDirection::Long);
    }

    #[test]
    fn test_composer_new_defaults() {
        let composer = StrategyComposer::new(ComposerProfile::AllWeather, "ETH-USD");
        assert_eq!(composer.symbol, "ETH-USD");
        assert_eq!(composer.max_exposure_pct, 100.0);
        assert_eq!(composer.profile, ComposerProfile::AllWeather);
    }
}