// first_network.rs
use ruv_fann::{ActivationFunction, NetworkBuilder};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧠 My First Neural Network");
    
    // Create a 2-3-1 network (XOR problem)
    let mut network = NetworkBuilder::<f32>::new()
        .input_layer(2)
        .hidden_layer_with_activation(3, ActivationFunction::Sigmoid, 1.0)
        .output_layer_with_activation(1, ActivationFunction::Sigmoid, 1.0)
        .build();
    
    // XOR test data
    let test_cases = [
        (vec![0.0, 0.0], 0.0), // 0 XOR 0 = 0
        (vec![0.0, 1.0], 1.0), // 0 XOR 1 = 1
        (vec![1.0, 0.0], 1.0), // 1 XOR 0 = 1
        (vec![1.0, 1.0], 0.0), // 1 XOR 1 = 0
    ];
    
    println!("\nTesting untrained network:");
    for (input, expected) in &test_cases {
        let output = network.run(input);
        println!("Input: {:?} → Expected: {:.1}, Got: {:.3}", 
                 input, expected, output[0]);
    }
    
    // Network properties
    println!("\nNetwork Info:");
    println!("  Layers: {}", network.num_layers());
    println!("  Total neurons: {}", network.total_neurons());
    println!("  Total connections: {}", network.total_connections());
    
    Ok(())
}

// forecasting_example.rs
use neuro_divergent::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("📈 My First Forecasting Model");
    
    // Generate synthetic time series data
    let data = generate_sales_data(365)?; // 1 year of daily sales
    println!("✅ Generated {} data points", data.len());
    
    // Create LSTM model
    let model = LSTM::builder()
        .horizon(7)        // Predict 7 days ahead
        .input_size(14)    // Use 14 days of history
        .hidden_size(64)   // 64 hidden neurons
        .num_layers(2)     // 2 LSTM layers
        .learning_rate(0.001)
        .build()?;
    
    println!("✅ Created LSTM model");
    
    // Split data (80% train, 20% test)
    let split_point = (data.len() as f64 * 0.8) as usize;
    let (train_data, test_data) = data.split_at(split_point);
    
    // Create forecasting pipeline
    let mut neural_forecast = NeuralForecast::builder()
        .with_model(Box::new(model))
        .with_frequency(Frequency::Daily)
        .build()?;
    
    // Train the model
    println!("🎯 Training model...");
    let start = std::time::Instant::now();
    neural_forecast.fit(train_data.to_vec())?;
    let duration = start.elapsed();
    
    println!("✅ Training completed in {:.2}s", duration.as_secs_f64());
    
    // Generate forecasts
    let forecasts = neural_forecast.predict(7)?; // 7-day forecast
    
    println!("📊 7-Day Forecast:");
    for (day, value) in forecasts.iter().enumerate() {
        println!("  Day {}: {:.2}", day + 1, value);
    }
    
    Ok(())
}

fn generate_sales_data(days: usize) -> Result<Vec<f32>, Box<dyn std::error::Error>> {
    let mut data = Vec::with_capacity(days);
    let mut rng = rand::thread_rng();
    
    for day in 0..days {
        // Realistic sales pattern with trend, seasonality, and noise
        let trend = day as f32 * 0.5;
        let weekly_pattern = 200.0 * (2.0 * std::f32::consts::PI * day as f32 / 7.0).sin();
        let noise = rng.gen_range(-50.0..50.0);
        let base_sales = 1000.0;
        
        let sales = base_sales + trend + weekly_pattern + noise;
        data.push(sales.max(0.0));
    }
    
    Ok(data)
}