use ruv_fann::{ActivationFunction, NetworkBuilder, TrainingAlgorithm};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a neural network with 2 inputs, 3 hidden neurons, and 1 output
    let mut network = NetworkBuilder::<f32>::new()
        .input_layer(2)
        .hidden_layer_with_activation(3, ActivationFunction::Sigmoid, 1.0)
        .output_layer_with_activation(1, ActivationFunction::Linear, 1.0)
        .connection_rate(1.0) // Fully connected
        .build();

    println!("Created network with {} layers", network.num_layers());
    println!("Total neurons: {}", network.total_neurons());
    println!("Total connections: {}", network.total_connections());

    // Run the network with test inputs
    let inputs = vec![0.5, 0.7];
    let outputs = network.run(&inputs);
    println!("Input: {:?} -> Output: {:?}", inputs, outputs);

    Ok(())
}

use ruv_fann::*;
use ruv_fann::training::*;

fn train_xor_network() -> Result<(), Box<dyn std::error::Error>> {
    // Create network for XOR problem
    let mut network = NetworkBuilder::<f32>::new()
        .input_layer(2)
        .hidden_layer_with_activation(4, ActivationFunction::Sigmoid, 1.0)
        .output_layer_with_activation(1, ActivationFunction::Sigmoid, 1.0)
        .build();

    // Create training data for XOR
    let training_data = TrainingData::new(vec![
        TrainingPair::new(vec![0.0, 0.0], vec![0.0]),
        TrainingPair::new(vec![0.0, 1.0], vec![1.0]),
        TrainingPair::new(vec![1.0, 0.0], vec![1.0]),
        TrainingPair::new(vec![1.0, 1.0], vec![0.0]),
    ]);

    // Configure training parameters
    let mut trainer = BackpropTrainer::new()
        .learning_rate(0.7)
        .target_error(0.001)
        .max_epochs(10000);

    // Train the network
    let result = trainer.train(&mut network, &training_data)?;
    println!("Training completed in {} epochs with error: {}", 
             result.epochs, result.final_error);

    // Test the trained network
    for pair in &training_data.pairs {
        let output = network.run(&pair.inputs);
        println!("Input: {:?} -> Expected: {:?}, Got: {:?}", 
                 pair.inputs, pair.outputs, output);
    }

    Ok(())
}

use ruv_fann::gpu::*;

#[cfg(feature = "gpu")]
fn gpu_training() -> Result<(), Box<dyn std::error::Error>> {
    // Create GPU-accelerated trainer
    let mut gpu_trainer = GpuBackpropTrainer::new()?
        .learning_rate(0.1)
        .batch_size(32)
        .target_error(0.001);

    let mut network = NetworkBuilder::<f32>::new()
        .input_layer(784)  // MNIST input size
        .hidden_layer_with_activation(128, ActivationFunction::ReLU, 1.0)
        .hidden_layer_with_activation(64, ActivationFunction::ReLU, 1.0)
        .output_layer_with_activation(10, ActivationFunction::Softmax, 1.0)
        .build();

    // Load MNIST training data
    let training_data = load_mnist_data()?;
    
    // Train on GPU (falls back to CPU if GPU unavailable)
    let result = gpu_trainer.train(&mut network, &training_data)?;
    println!("GPU training completed: {} epochs, {:.6} error", 
             result.epochs, result.final_error);

    Ok(())
}

impl<T: Float> NetworkBuilder<T> {
    pub fn new() -> Self
    pub fn input_layer(self, neurons: usize) -> Self
    pub fn hidden_layer(self, neurons: usize) -> Self
    pub fn hidden_layer_with_activation(
        self, 
        neurons: usize, 
        activation: ActivationFunction, 
        steepness: T
    ) -> Self
    pub fn output_layer_with_activation(
        self, 
        neurons: usize, 
        activation: ActivationFunction, 
        steepness: T
    ) -> Self
    pub fn connection_rate(self, rate: T) -> Self
    pub fn build(self) -> Network<T>
}

impl<T: Float> Network<T> {
    // Forward propagation
    pub fn run(&mut self, inputs: &[T]) -> Vec<T>
    
    // Network introspection
    pub fn num_layers(&self) -> usize
    pub fn num_inputs(&self) -> usize
    pub fn num_outputs(&self) -> usize
    pub fn total_neurons(&self) -> usize
    pub fn total_connections(&self) -> usize
    
    // Weight management
    pub fn get_weights(&self) -> Vec<T>
    pub fn set_weights(&mut self, weights: &[T]) -> Result<(), NetworkError>
    
    // Serialization
    pub fn save(&self, path: &str) -> Result<(), NetworkError>
    pub fn load(path: &str) -> Result<Self, NetworkError>
    
    // Statistics
    pub fn calculate_mse(&mut self, data: &TrainingData<T>) -> T
    pub fn test(&mut self, data: &TrainingData<T>) -> TestResult<T>
}

let mut trainer = BackpropTrainer::new()
    .learning_rate(0.1)
    .momentum(0.9)
    .target_error(0.001)
    .max_epochs(1000);

let result = trainer.train(&mut network, &training_data)?;

let mut trainer = RpropTrainer::new()
    .delta_initial(0.1)
    .delta_max(50.0)
    .delta_min(1e-6)
    .target_error(0.001);

let result = trainer.train(&mut network, &training_data)?;

let mut trainer = AdamTrainer::new()
    .learning_rate(0.001)
    .beta1(0.9)
    .beta2(0.999)
    .epsilon(1e-8)
    .target_error(0.001);

let result = trainer.train(&mut network, &training_data)?;

pub enum ActivationFunction {
    Linear,
    Sigmoid,
    SymmetricSigmoid,
    Tanh,
    ReLU,
    LeakyReLU,
    ELU,
    Swish,
    GELU,
    Mish,
    Softmax,
    LogSoftmax,
}

use ruv_fann::*;
use ruv_fann::io::*;

fn mnist_classifier() -> Result<(), Box<dyn std::error::Error>> {
    // Create a deep network for MNIST
    let mut network = NetworkBuilder::<f32>::new()
        .input_layer(784)  // 28x28 pixels
        .hidden_layer_with_activation(256, ActivationFunction::ReLU, 1.0)
        .hidden_layer_with_activation(128, ActivationFunction::ReLU, 1.0)
        .hidden_layer_with_activation(64, ActivationFunction::ReLU, 1.0)
        .output_layer_with_activation(10, ActivationFunction::Softmax, 1.0)
        .build();

    // Load MNIST data
    let training_data = load_training_data_from_file("mnist_train.data")?;
    let test_data = load_training_data_from_file("mnist_test.data")?;

    // Configure advanced training
    let mut trainer = AdamTrainer::new()
        .learning_rate(0.001)
        .batch_size(32)
        .target_error(0.01)
        .max_epochs(100)
        .validation_data(&test_data)  // Early stopping
        .checkpoint_every(10);        // Save progress

    // Train with progress monitoring
    trainer.set_callback(|epoch, error, validation_error| {
        println!("Epoch {}: Error={:.6}, Val_Error={:.6}", 
                 epoch, error, validation_error);
        CallbackResult::Continue
    });

    let result = trainer.train(&mut network, &training_data)?;
    
    // Evaluate final performance
    let test_result = network.test(&test_data);
    println!("Final accuracy: {:.2}%", test_result.accuracy() * 100.0);

    // Save the trained model
    network.save("mnist_classifier.fann")?;
    
    Ok(())
}

fn predict_stock_prices() -> Result<(), Box<dyn std::error::Error>> {
    // Create network for time series prediction
    let mut network = NetworkBuilder::<f32>::new()
        .input_layer(20)  // 20 previous days
        .hidden_layer_with_activation(50, ActivationFunction::Tanh, 1.0)
        .hidden_layer_with_activation(30, ActivationFunction::Tanh, 1.0)
        .output_layer_with_activation(1, ActivationFunction::Linear, 1.0)
        .build();

    // Prepare sliding window training data
    let stock_data = load_stock_data("AAPL.csv")?;
    let training_data = create_sliding_window_data(&stock_data, 20, 1);

    // Use Quickprop for fast convergence
    let mut trainer = QuickpropTrainer::new()
        .learning_rate(0.1)
        .mu(1.75)
        .target_error(0.001)
        .max_epochs(5000);

    let result = trainer.train(&mut network, &training_data)?;
    
    // Predict next day's price
    let last_20_days = get_last_n_days(&stock_data, 20);
    let prediction = network.run(&last_20_days);
    println!("Predicted next day price: ${:.2}", prediction[0]);

    Ok(())
}

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub struct WasmNetwork {
    network: Network<f32>,
}

#[wasm_bindgen]
impl WasmNetwork {
    #[wasm_bindgen(constructor)]
    pub fn new(model_data: &[u8]) -> Result<WasmNetwork, JsValue> {
        let network = Network::load_from_bytes(model_data)
            .map_err(|e| JsValue::from_str(&e.to_string()))?;
        
        Ok(WasmNetwork { network })
    }

    #[wasm_bindgen]
    pub fn predict(&mut self, inputs: &[f32]) -> Vec<f32> {
        self.network.run(inputs)
    }

    #[wasm_bindgen]
    pub fn get_info(&self) -> String {
        format!("Neurons: {}, Connections: {}", 
                self.network.total_neurons(),
                self.network.total_connections())
    }
}

use ruv_fann::*;
use neuro_divergent::*;

fn hybrid_forecasting() -> Result<(), Box<dyn std::error::Error>> {
    // Create base FANN network
    let base_network = NetworkBuilder::<f32>::new()
        .input_layer(24)
        .hidden_layer_with_activation(64, ActivationFunction::ReLU, 1.0)
        .output_layer_with_activation(12, ActivationFunction::Linear, 1.0)
        .build();

    // Wrap in Neuro-Divergent LSTM model
    let lstm_model = LSTM::builder()
        .base_network(base_network)
        .hidden_size(128)
        .horizon(12)
        .build()?;

    // Use with NeuralForecast API
    let mut nf = NeuralForecast::builder()
        .with_model(Box::new(lstm_model))
        .with_frequency(Frequency::Daily)
        .build()?;

    let data = TimeSeriesDataFrame::from_csv("sales.csv")?;
    nf.fit(data)?;
    let forecasts = nf.predict()?;

    Ok(())
}

use ruv_fann::*;
use ruv_swarm::*;

#[tokio::main]
async fn distributed_training() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize swarm for distributed training
    let mut swarm = Swarm::builder()
        .topology(TopologyType::Ring)
        .max_agents(4)
        .build()
        .await?;

    // Create identical networks for each agent
    let network_template = NetworkBuilder::<f32>::new()
        .input_layer(100)
        .hidden_layer_with_activation(200, ActivationFunction::ReLU, 1.0)
        .hidden_layer_with_activation(100, ActivationFunction::ReLU, 1.0)
        .output_layer_with_activation(10, ActivationFunction::Softmax, 1.0)
        .build();

    // Spawn training agents
    for i in 0..4 {
        let agent = Agent::new(AgentType::Coder)
            .with_network(network_template.clone())
            .with_data_partition(i, 4)  // Each agent gets 1/4 of data
            .spawn(&mut swarm)
            .await?;
    }

    // Coordinate distributed training
    let task = swarm.orchestrate_task()
        .description("Train neural network on distributed data")
        .strategy(OrchestrationStrategy::DataParallel)
        .execute()
        .await?;

    let result = task.await_completion().await?;
    println!("Distributed training completed in {}ms", result.duration_ms);

    Ok(())
}

use ruv_fann::*;

// Define custom activation function
#[derive(Clone, Copy)]
struct SwishActivation;

impl ActivationFunction for SwishActivation {
    fn activate<T: Float>(x: T) -> T {
        x * sigmoid(x)
    }
    
    fn derivative<T: Float>(x: T, fx: T) -> T {
        let sigmoid_x = sigmoid(x);
        sigmoid_x + x * sigmoid_x * (T::one() - sigmoid_x)
    }
}

// Use in network
let network = NetworkBuilder::<f32>::new()
    .input_layer(10)
    .hidden_layer_with_custom_activation(20, SwishActivation, 1.0)
    .output_layer_with_activation(1, ActivationFunction::Linear, 1.0)
    .build();

use ruv_fann::memory::*;

// Configure custom memory management
let memory_config = MemoryConfig::new()
    .pool_size(1024 * 1024)  // 1MB pool
    .alignment(32)           // SIMD alignment
    .growth_factor(2.0);     // Double size when expanding

let network = NetworkBuilder::<f32>::new()
    .memory_config(memory_config)
    .input_layer(100)
    .hidden_layer(200)
    .output_layer(10)
    .build();

use ruv_fann::parallel::*;

// Configure parallel training
let parallel_config = ParallelConfig::new()
    .num_threads(8)
    .batch_size(64)
    .sync_frequency(10);  // Sync every 10 batches

let mut trainer = BackpropTrainer::new()
    .parallel_config(parallel_config)
    .learning_rate(0.1)
    .target_error(0.001);

let result = trainer.train_parallel(&mut network, &training_data)?;

// Check learning rate
if result.final_error > 0.1 {
    // Try lower learning rate
    trainer = trainer.learning_rate(0.01);
}

// Check activation functions
network = NetworkBuilder::<f32>::new()
    .input_layer(inputs)
    .hidden_layer_with_activation(hidden, ActivationFunction::ReLU, 1.0)  // Try ReLU
    .output_layer_with_activation(outputs, ActivationFunction::Linear, 1.0)
    .build();

// Check data normalization
training_data.normalize_inputs(-1.0, 1.0);
training_data.normalize_outputs(0.0, 1.0);

// Use smaller batch sizes
let trainer = BackpropTrainer::new()
    .batch_size(16)  // Reduce from default 32
    .learning_rate(0.1);

// Monitor memory usage
println!("Memory usage: {} MB", network.memory_usage_mb());

// Use f32 instead of f64 for mobile/embedded
let network = NetworkBuilder::<f32>::new()  // Not f64
    .input_layer(inputs)
    .build();

// Enable SIMD
#[cfg(target_feature = "avx2")]
let network = NetworkBuilder::<f32>::new()
    .simd_acceleration(true)
    .input_layer(inputs)
    .build();

// Use connection rate < 1.0 for sparse networks
let network = NetworkBuilder::<f32>::new()
    .connection_rate(0.8)  // 80% connections
    .input_layer(inputs)
    .build();

// Profile training
let mut trainer = BackpropTrainer::new()
    .profile(true)  // Enable profiling
    .learning_rate(0.1);