Moving average crossover strategy

pub struct MovingAverageCrossoverStrategy {
    config: StrategyConfig,
    initialized: bool,
    short_period: usize,
    long_period: usize,
    position_size: Decimal,
    last_signal: Option<Signal>,
}

enum Signal {
    Buy,
    Sell,
}

fn calculate_sma(&self, prices: &[Decimal], period: usize) -> Option<Decimal> {
    if prices.len() < period {
        return None;
    }
    
    let sum: Decimal = prices.iter().rev().take(period).sum();
    Some(sum / Decimal::from(period))
}

if let (Some(short), Some(long)) = (short_ma, long_ma) {
    let current_signal = if short > long {
        Some(Signal::Buy)
    } else if short < long {
        Some(Signal::Sell)
    } else {
        None
    };
    
    // Check for signal change
    if current_signal != self.last_signal {
        match current_signal {
            Some(Signal::Buy) => {
                // Close any short positions
                // Open long position
            },
            Some(Signal::Sell) => {
                // Close any long positions
                // Open short position
            },
            None => {}
        }
        
        self.last_signal = current_signal;
    }
}

use gb_types::strategy::{MovingAverageCrossoverStrategy, StrategyConfig, Strategy};
use gb_types::market::Symbol;

// Create 5-day vs 20-day MA crossover strategy
let mut strategy = MovingAverageCrossoverStrategy::new(5, 20);

// Configure
let mut config = StrategyConfig::new(
    "ma_crossover".to_string(),
    "MA Crossover 5/20".to_string()
);
config.add_symbol(Symbol::equity("AAPL"));
config.set_parameter("position_size", 0.90f64);

// Initialize
strategy.initialize(&config)?;

let mut ma_strategy = MovingAverageCrossoverStrategy::new(5, 20);
let mut ma_config = StrategyConfig::new(
    "ma_crossover".to_string(),
    "MA Crossover".to_string()
);
ma_config.add_symbol(symbol.clone());
ma_config.set_parameter("position_size", 0.90f64);

if let Ok(()) = ma_strategy.initialize(&ma_config) {
    println!("  • Initialized: 5-day vs 20-day moving average crossover");
    println!("  • Position size: 90% of capital");
}

// Test custom parameter handling
let mut config = StrategyConfig::new(
    "test_params".to_string(),
    "Test Parameters".to_string()
);
config.set_parameter("short_period", 8);
config.set_parameter("long_period", 21);
config.set_parameter("position_size", 0.80f64);

let mut ma_strategy = MovingAverageCrossoverStrategy::new(5, 10);
assert!(ma_strategy.initialize(&config).is_ok());

// Parameters are applied from config
assert_eq!(ma_strategy.short_period, 8);
assert_eq!(ma_strategy.long_period, 21);

#[test]
fn test_moving_average_crossover_strategy() {
    let mut strategy = MovingAverageCrossoverStrategy::new(5, 10);
    let mut config = StrategyConfig::new(
        "test_ma".to_string(),
        "Test MA Crossover".to_string()
    );
    config.add_symbol(create_test_symbol());
    
    assert!(strategy.initialize(&config).is_ok());
    
    // Create test data with upward trend
    let mut bars = Vec::new();
    let base_time = Utc::now();
    for i in 0..15 {
        let price = dec!(100) + Decimal::from(i); // Increasing prices
        let bar = create_test_bar(price, base_time + chrono::Duration::days(i));
        bars.push(bar);
    }
    
    let context = create_test_context_with_data(bars);
    
    // Test market event processing
    let actions = strategy.on_market_event(&event, &context);
    assert!(actions.is_ok());
    // Should generate buy signal as short MA crosses above long MA
}

#[test]
fn test_sma_calculation() {
    let strategy = MovingAverageCrossoverStrategy::new(3, 5);
    let prices = vec![dec!(100), dec!(101), dec!(102), dec!(103), dec!(104)];
    
    // Test 3-period SMA
    let sma_3 = strategy.calculate_sma(&prices, 3);
    assert_eq!(sma_3.unwrap(), dec!(103)); // (102 + 103 + 104) / 3
    
    // Test 5-period SMA
    let sma_5 = strategy.calculate_sma(&prices, 5);
    assert_eq!(sma_5.unwrap(), dec!(102)); // (100 + 101 + 102 + 103 + 104) / 5
    
    // Test insufficient data
    let sma_6 = strategy.calculate_sma(&prices, 6);
    assert!(sma_6.is_none());
}

let strategy = MovingAverageCrossoverStrategy::new(20, 50);
// Less frequent trades, follows longer-term trends

let strategy = MovingAverageCrossoverStrategy::new(5, 10);
// More frequent trades, responds quickly to price changes

let strategy = MovingAverageCrossoverStrategy::new(50, 200);
// Traditional long-term trend following