hyper_strategy/

rule_executor.rs

//! Deterministic order decision engine.
//!
//! Maps triggered rule signals to concrete order actions (buy/sell/close/hold).
//! No AI involved — purely rule-based.

use serde::{Deserialize, Serialize};

use crate::rule_engine::SignalSummary;
use crate::strategy_config::Playbook;

// ---------------------------------------------------------------------------
// Types
// ---------------------------------------------------------------------------

/// A deterministic order decision produced by the rule engine.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RuleDecision {
    /// "buy", "sell", "close", or "hold"
    pub action: String,
    /// Trading symbol
    pub symbol: String,
    /// Position size (from playbook max_position_size)
    pub size: f64,
    /// Human-readable explanation of why this decision was made
    pub reasoning: String,
    /// Which rules triggered this decision
    pub triggered_rules: Vec<TriggeredRule>,
}

/// A single rule that contributed to the decision.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TriggeredRule {
    pub indicator: String,
    pub condition: String,
    pub value: f64,
    pub threshold: f64,
    pub signal: String,
    pub action: String,
}

// ---------------------------------------------------------------------------
// Decision logic
// ---------------------------------------------------------------------------

/// Infer action from signal name when no explicit action is set.
fn infer_action(signal: &str) -> &'static str {
    let s = signal.to_lowercase();
    if s.contains("buy")
        || s.contains("long")
        || s.contains("oversold")
        || s.contains("bullish")
        || s.contains("golden")
    {
        "buy"
    } else if s.contains("sell")
        || s.contains("short")
        || s.contains("overbought")
        || s.contains("bearish")
        || s.contains("death")
    {
        "sell"
    } else if s.contains("close") || s.contains("exit") || s.contains("flat") {
        "close"
    } else {
        "hold"
    }
}

/// Produce a deterministic order decision from evaluated signals.
///
/// Logic:
/// 1. Collect all triggered rules with their actions.
/// 2. Count buy vs sell votes.
/// 3. Majority wins. Ties → hold.
/// 4. Check stop-loss / take-profit if position exists.
pub fn decide_from_signals(
    signal_summary: &SignalSummary,
    playbook: &Playbook,
    current_position_side: Option<&str>,
    current_entry_price: Option<f64>,
    current_price: Option<f64>,
) -> RuleDecision {
    // Check stop-loss / take-profit first (highest priority)
    if let (Some(side), Some(entry), Some(price)) =
        (current_position_side, current_entry_price, current_price)
    {
        let pnl_pct = if side == "buy" {
            (price - entry) / entry * 100.0
        } else {
            (entry - price) / entry * 100.0
        };

        if let Some(sl) = playbook.stop_loss_pct {
            if pnl_pct <= -sl {
                let action = if side == "buy" { "sell" } else { "buy" };
                return RuleDecision {
                    action: action.to_string(),
                    symbol: signal_summary.symbol.clone(),
                    size: playbook.max_position_size,
                    reasoning: format!(
                        "Stop-loss triggered: PnL {:.2}% exceeded -{:.1}% limit",
                        pnl_pct, sl
                    ),
                    triggered_rules: vec![TriggeredRule {
                        indicator: "stop_loss".to_string(),
                        condition: "pnl_below".to_string(),
                        value: pnl_pct,
                        threshold: -sl,
                        signal: "stop_loss".to_string(),
                        action: action.to_string(),
                    }],
                };
            }
        }

        if let Some(tp) = playbook.take_profit_pct {
            if pnl_pct >= tp {
                let action = if side == "buy" { "sell" } else { "buy" };
                return RuleDecision {
                    action: action.to_string(),
                    symbol: signal_summary.symbol.clone(),
                    size: playbook.max_position_size,
                    reasoning: format!(
                        "Take-profit triggered: PnL {:.2}% exceeded +{:.1}% target",
                        pnl_pct, tp
                    ),
                    triggered_rules: vec![TriggeredRule {
                        indicator: "take_profit".to_string(),
                        condition: "pnl_above".to_string(),
                        value: pnl_pct,
                        threshold: tp,
                        signal: "take_profit".to_string(),
                        action: action.to_string(),
                    }],
                };
            }
        }
    }

    let mut buy_votes = 0u32;
    let mut sell_votes = 0u32;
    let mut triggered = Vec::new();

    for eval in &signal_summary.evaluations {
        if !eval.triggered {
            continue;
        }

        let action = eval
            .rule
            .action
            .as_deref()
            .unwrap_or_else(|| infer_action(&eval.signal));

        match action {
            "buy" => buy_votes += 1,
            "sell" => sell_votes += 1,
            "close" => {
                // Close counts against the current position direction
                match current_position_side {
                    Some("buy") => sell_votes += 1,
                    Some("sell") => buy_votes += 1,
                    _ => {}
                }
            }
            _ => {}
        }

        triggered.push(TriggeredRule {
            indicator: eval.rule.indicator.clone(),
            condition: eval.rule.condition.clone(),
            value: eval.current_value,
            threshold: eval.rule.threshold,
            signal: eval.signal.clone(),
            action: action.to_string(),
        });
    }

    // No triggered rules → hold
    if triggered.is_empty() {
        return RuleDecision {
            action: "hold".to_string(),
            symbol: signal_summary.symbol.clone(),
            size: 0.0,
            reasoning: "No rules triggered — holding current position".to_string(),
            triggered_rules: vec![],
        };
    }

    // Majority vote
    let (action, reasoning) = if buy_votes > sell_votes {
        (
            "buy",
            format!(
                "{} buy signal(s) vs {} sell signal(s)",
                buy_votes, sell_votes
            ),
        )
    } else if sell_votes > buy_votes {
        (
            "sell",
            format!(
                "{} sell signal(s) vs {} buy signal(s)",
                sell_votes, buy_votes
            ),
        )
    } else {
        (
            "hold",
            format!("Tie: {} buy vs {} sell — holding", buy_votes, sell_votes),
        )
    };

    let size = if action == "hold" {
        0.0
    } else {
        playbook.max_position_size
    };

    RuleDecision {
        action: action.to_string(),
        symbol: signal_summary.symbol.clone(),
        size,
        reasoning,
        triggered_rules: triggered,
    }
}

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

#[cfg(test)]
mod tests {
    use super::*;
    use crate::rule_engine::RuleEvaluation;
    use crate::strategy_config::TaRule;

    fn make_eval(
        signal: &str,
        action: Option<&str>,
        triggered: bool,
        value: f64,
    ) -> RuleEvaluation {
        RuleEvaluation {
            rule: TaRule {
                indicator: "RSI".to_string(),
                params: vec![14.0],
                condition: "lt".to_string(),
                threshold: 30.0,
                threshold_upper: None,
                signal: signal.to_string(),
                action: action.map(|a| a.to_string()),
            },
            current_value: value,
            triggered,
            signal: signal.to_string(),
        }
    }

    fn make_summary(evaluations: Vec<RuleEvaluation>) -> SignalSummary {
        let triggered_signals = evaluations
            .iter()
            .filter(|e| e.triggered)
            .map(|e| e.signal.clone())
            .collect();
        SignalSummary {
            symbol: "BTC-PERP".to_string(),
            timestamp: 1000,
            current_regime: "neutral".to_string(),
            regime_changed: false,
            evaluations,
            triggered_signals,
        }
    }

    fn make_playbook() -> Playbook {
        Playbook {
            rules: vec![],
            entry_rules: vec![],
            exit_rules: vec![],
            system_prompt: String::new(),
            max_position_size: 100.0,
            stop_loss_pct: Some(5.0),
            take_profit_pct: Some(10.0),
            timeout_secs: None,
            side: None,
        }
    }

    #[test]
    fn test_no_triggered_rules_returns_hold() {
        let summary = make_summary(vec![make_eval("oversold", Some("buy"), false, 45.0)]);
        let decision = decide_from_signals(&summary, &make_playbook(), None, None, None);
        assert_eq!(decision.action, "hold");
        assert!(decision.triggered_rules.is_empty());
    }

    #[test]
    fn test_single_buy_signal() {
        let summary = make_summary(vec![make_eval("oversold", Some("buy"), true, 25.0)]);
        let decision = decide_from_signals(&summary, &make_playbook(), None, None, None);
        assert_eq!(decision.action, "buy");
        assert_eq!(decision.size, 100.0);
        assert_eq!(decision.triggered_rules.len(), 1);
    }

    #[test]
    fn test_majority_vote() {
        let summary = make_summary(vec![
            make_eval("oversold", Some("buy"), true, 25.0),
            make_eval("bullish", Some("buy"), true, 1.0),
            make_eval("overbought", Some("sell"), true, 75.0),
        ]);
        let decision = decide_from_signals(&summary, &make_playbook(), None, None, None);
        assert_eq!(decision.action, "buy"); // 2 buy vs 1 sell
    }

    #[test]
    fn test_tie_returns_hold() {
        let summary = make_summary(vec![
            make_eval("oversold", Some("buy"), true, 25.0),
            make_eval("overbought", Some("sell"), true, 75.0),
        ]);
        let decision = decide_from_signals(&summary, &make_playbook(), None, None, None);
        assert_eq!(decision.action, "hold");
    }

    #[test]
    fn test_infer_action_from_signal_name() {
        let summary = make_summary(vec![
            make_eval("oversold", None, true, 25.0), // inferred as "buy"
        ]);
        let decision = decide_from_signals(&summary, &make_playbook(), None, None, None);
        assert_eq!(decision.action, "buy");
    }

    #[test]
    fn test_stop_loss_triggers() {
        let summary = make_summary(vec![make_eval("bullish", Some("buy"), true, 60.0)]);
        let pb = make_playbook(); // stop_loss_pct = 5.0
                                  // Long position, price dropped 6%
        let decision = decide_from_signals(&summary, &pb, Some("buy"), Some(100.0), Some(94.0));
        assert_eq!(decision.action, "sell"); // stop loss overrides buy signal
        assert!(decision.reasoning.contains("Stop-loss"));
    }

    #[test]
    fn test_take_profit_triggers() {
        let summary = make_summary(vec![]);
        let pb = make_playbook(); // take_profit_pct = 10.0
                                  // Long position, price up 11%
        let decision = decide_from_signals(&summary, &pb, Some("buy"), Some(100.0), Some(111.0));
        assert_eq!(decision.action, "sell");
        assert!(decision.reasoning.contains("Take-profit"));
    }
}