use neuro_divergent::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create an LSTM model with modern defaults
    let lstm = LSTM::builder()
        .hidden_size(128)
        .num_layers(2)
        .horizon(12)          // Predict 12 steps ahead
        .input_size(24)       // Use 24 historical steps
        .dropout(0.1)
        .build()?;

    // Create NeuralForecast instance
    let mut nf = NeuralForecast::builder()
        .with_model(Box::new(lstm))
        .with_frequency(Frequency::Daily)
        .with_prediction_intervals(PredictionIntervals::new(vec![80, 90, 95]))
        .build()?;

    // Load your time series data (CSV with 'unique_id', 'ds', 'y' columns)
    let data = TimeSeriesDataFrame::from_csv("sales_data.csv")?;

    // Fit the model
    println!("Training LSTM model...");
    nf.fit(data.clone())?;

    // Generate forecasts with prediction intervals
    let forecasts = nf.predict()?;
    
    println!("Forecasts generated for {} series", forecasts.len());
    
    // Display forecast for first series
    if let Some(first_series) = forecasts.get(0) {
        println!("Series: {}", first_series.unique_id);
        println!("Mean forecast: {:?}", &first_series.mean[0..5]);  // First 5 predictions
        println!("80% PI lower: {:?}", &first_series.pi_lower_80[0..5]);
        println!("80% PI upper: {:?}", &first_series.pi_upper_80[0..5]);
    }

    Ok(())
}

use neuro_divergent::prelude::*;

fn ensemble_forecasting() -> Result<(), Box<dyn std::error::Error>> {
    // Create multiple models for ensemble forecasting
    let models: Vec<Box<dyn BaseModel<f64>>> = vec![
        // LSTM for capturing long-term dependencies
        Box::new(LSTM::builder()
            .horizon(12)
            .hidden_size(128)
            .num_layers(2)
            .dropout(0.1)
            .build()?),
        
        // N-BEATS for interpretable decomposition
        Box::new(NBEATS::builder()
            .horizon(12)
            .stacks(4)
            .layers(4)
            .layer_width(512)
            .build()?),
        
        // Temporal Fusion Transformer for complex patterns
        Box::new(TFT::builder()
            .horizon(12)
            .hidden_size(64)
            .attention_head_size(4)
            .dropout(0.1)
            .build()?),
            
        // TCN for fast training and good performance
        Box::new(TCN::builder()
            .horizon(12)
            .kernel_size(3)
            .num_filters(32)
            .dilations(vec![1, 2, 4, 8])
            .build()?),
    ];

    let mut nf = NeuralForecast::builder()
        .with_models(models)
        .with_frequency(Frequency::Daily)
        .with_prediction_intervals(PredictionIntervals::new(vec![80, 90, 95]))
        .with_ensemble_strategy(EnsembleStrategy::Average)  // Or Weighted, Stacked
        .build()?;

    let data = TimeSeriesDataFrame::from_csv("complex_sales_data.csv")?;
    
    // Fit all models with progress tracking
    println!("Training ensemble of 4 models...");
    nf.fit_with_callback(data.clone(), |model_name, epoch, loss| {
        println!("{}: Epoch {}, Loss: {:.6}", model_name, epoch, loss);
        CallbackResult::Continue
    })?;

    // Generate probabilistic forecasts
    let forecasts = nf.predict()?;
    
    // Cross-validation for model comparison
    println!("Running cross-validation...");
    let cv_results = nf.cross_validation(
        data,
        CrossValidationConfig::new()
            .with_n_windows(3)
            .with_horizon(12)
            .with_step_size(12)
    )?;

    println!("Cross-validation results:");
    for result in cv_results.model_results() {
        println!("  {}: MAE={:.4}, MAPE={:.2}%", 
                 result.model_name, result.mae, result.mape * 100.0);
    }

    Ok(())
}

use neuro_divergent::prelude::*;

fn advanced_forecasting() -> Result<(), Box<dyn std::error::Error>> {
    // Create model with exogenous variables and static features
    let tft = TFT::builder()
        .horizon(24)                    // 24 hours ahead
        .input_size(168)               // 1 week of hourly data
        .hidden_size(128)
        .attention_head_size(8)
        .num_encoder_layers(3)
        .num_decoder_layers(3)
        .with_static_features(vec!["store_id", "category"])
        .with_time_varying_known_features(vec!["hour", "day_of_week", "month"])
        .with_time_varying_unknown_features(vec!["temperature", "promotion"])
        .dropout(0.1)
        .build()?;

    let mut nf = NeuralForecast::builder()
        .with_model(Box::new(tft))
        .with_frequency(Frequency::Hourly)
        .with_prediction_intervals(PredictionIntervals::new(vec![50, 80, 90, 95]))
        .build()?;

    // Load data with multiple features
    let data = TimeSeriesDataFrame::from_csv("retail_hourly_data.csv")?
        .with_static_features(vec!["store_id", "category", "size"])
        .with_time_features(vec!["hour", "day_of_week", "month", "is_holiday"])
        .with_future_features(vec!["temperature_forecast", "planned_promotion"]);

    // Advanced training configuration
    let training_config = TrainingConfig::new()
        .with_max_epochs(100)
        .with_early_stopping(10)        // Stop if no improvement for 10 epochs
        .with_learning_rate(0.001)
        .with_batch_size(64)
        .with_gradient_clipping(1.0)
        .with_weight_decay(1e-4)
        .with_scheduler(LRScheduler::ReduceOnPlateau { patience: 5, factor: 0.5 });

    nf.fit_with_config(data.clone(), training_config)?;

    // Generate forecasts with feature importance
    let forecasts_with_analysis = nf.predict_with_analysis()?;
    
    for analysis in forecasts_with_analysis {
        println!("Series: {}", analysis.unique_id);
        println!("Feature importance:");
        for (feature, importance) in analysis.feature_importance {
            println!("  {}: {:.4}", feature, importance);
        }
        println!("Attention weights (top 5 timesteps):");
        for (timestep, weight) in analysis.attention_weights.iter().take(5) {
            println!("  t-{}: {:.4}", timestep, weight);
        }
    }

    Ok(())
}

// Multi-Layer Perceptron - Simple but effective
let mlp = MLP::builder()
    .horizon(12)
    .hidden_size(128)
    .num_layers(3)
    .build()?;

// Direct Linear - Fast baseline
let dlinear = DLinear::builder()
    .horizon(12)
    .seasonal_length(24)
    .build()?;

// Normalized Linear - Improved baseline
let nlinear = NLinear::builder()
    .horizon(12)
    .build()?;

// Multivariate MLP
let mlp_mv = MLPMultivariate::builder()
    .horizon(12)
    .hidden_size(64)
    .num_series(10)
    .build()?;

// Simple RNN
let rnn = RNN::builder()
    .horizon(12)
    .hidden_size(64)
    .num_layers(2)
    .build()?;

// Long Short-Term Memory
let lstm = LSTM::builder()
    .horizon(12)
    .hidden_size(128)
    .num_layers(2)
    .dropout(0.1)
    .bidirectional(true)
    .build()?;

// Gated Recurrent Unit
let gru = GRU::builder()
    .horizon(12)
    .hidden_size(96)
    .num_layers(2)
    .build()?;

// N-BEATS - Neural basis expansion analysis
let nbeats = NBEATS::builder()
    .horizon(12)
    .stacks(4)
    .blocks_per_stack(4)
    .layer_width(512)
    .sharing_weights_across_stacks(true)
    .build()?;

// N-BEATSx - Extended version with exogenous variables
let nbeatsx = NBEATSx::builder()
    .horizon(12)
    .stacks(4)
    .blocks_per_stack(4)
    .layer_width(256)
    .exog_size(5)
    .build()?;

// N-HITS - Neural hierarchical interpolation
let nhits = NHITS::builder()
    .horizon(12)
    .stacks(3)
    .max_pool_sizes(vec![2, 2, 2])
    .n_freq_downsample(vec![8, 4, 1])
    .build()?;

// TiDE - Time-series Dense Encoder
let tide = TiDE::builder()
    .horizon(12)
    .input_size(48)
    .hidden_size(256)
    .num_encoder_layers(2)
    .num_decoder_layers(2)
    .build()?;

// Temporal Fusion Transformer
let tft = TFT::builder()
    .horizon(12)
    .hidden_size(128)
    .attention_head_size(4)
    .num_encoder_layers(3)
    .num_decoder_layers(3)
    .dropout(0.1)
    .build()?;

// Informer - Efficient attention for long sequences
let informer = Informer::builder()
    .horizon(12)
    .hidden_size(128)
    .num_encoder_layers(3)
    .num_decoder_layers(2)
    .attention_factor(5)
    .build()?;

// AutoFormer - Decomposition attention
let autoformer = AutoFormer::builder()
    .horizon(12)
    .hidden_size(128)
    .num_encoder_layers(2)
    .num_decoder_layers(1)
    .moving_avg_window(25)
    .build()?;

// FEDformer - Frequency Enhanced Decomposition
let fedformer = FEDformer::builder()
    .horizon(12)
    .hidden_size(128)
    .modes(32)
    .mode_select("random")
    .build()?;

// PatchTST - Patch-based Time Series Transformer
let patchtst = PatchTST::builder()
    .horizon(12)
    .patch_size(16)
    .stride(8)
    .hidden_size(128)
    .num_layers(3)
    .build()?;

// iTransformer - Inverted Transformer
let itransformer = iTransformer::builder()
    .horizon(12)
    .hidden_size(128)
    .num_layers(4)
    .num_heads(8)
    .build()?;

// DeepAR - Probabilistic forecasting
let deepar = DeepAR::builder()
    .horizon(12)
    .hidden_size(128)
    .num_layers(2)
    .distribution("negative_binomial")  // or "normal", "student_t"
    .build()?;

// DeepNPTS - Non-parametric time series
let deepnpts = DeepNPTS::builder()
    .horizon(12)
    .hidden_size(64)
    .num_layers(2)
    .build()?;

// Temporal Convolutional Network
let tcn = TCN::builder()
    .horizon(12)
    .kernel_size(3)
    .num_filters(32)
    .dilations(vec![1, 2, 4, 8, 16])
    .dropout(0.1)
    .build()?;

// Bidirectional TCN
let bitcn = BiTCN::builder()
    .horizon(12)
    .kernel_size(3)
    .num_filters(32)
    .dilations(vec![1, 2, 4, 8])
    .build()?;

// TimesNet - Time series decomposition network
let timesnet = TimesNet::builder()
    .horizon(12)
    .hidden_size(64)
    .num_kernels(6)
    .build()?;

// StemGNN - Spectral temporal graph neural network
let stemgnn = StemGNN::builder()
    .horizon(12)
    .hidden_size(64)
    .num_layers(2)
    .build()?;

// TSMixer - Simple MLP-based mixer
let tsmixer = TSMixer::builder()
    .horizon(12)
    .hidden_size(128)
    .num_blocks(4)
    .build()?;

// TSMixerx - Extended version with exogenous variables
let tsmixerx = TSMixerx::builder()
    .horizon(12)
    .hidden_size(128)
    .num_blocks(4)
    .exog_size(5)
    .build()?;

// TimeLLM - Large Language Model for time series
let timellm = TimeLLM::builder()
    .horizon(12)
    .llm_model("gpt2")
    .patch_size(16)
    .build()?;

use neuro_divergent::prelude::*;

fn retail_forecasting() -> Result<(), Box<dyn std::error::Error>> {
    // Load retail sales data with multiple features
    let data = TimeSeriesDataFrame::from_csv("retail_sales.csv")?
        .with_id_column("store_product_id")
        .with_time_column("date")
        .with_target_column("sales")
        .with_static_features(vec!["store_type", "product_category", "store_size"])
        .with_time_features(vec!["is_holiday", "promotion_active", "price"])
        .with_future_features(vec!["planned_promotion", "competitor_price"]);

    // Create ensemble of specialized models
    let models: Vec<Box<dyn BaseModel<f64>>> = vec![
        // TFT for complex feature interactions
        Box::new(TFT::builder()
            .horizon(28)  // 4 weeks ahead
            .hidden_size(128)
            .attention_head_size(4)
            .with_static_features(vec!["store_type", "product_category"])
            .with_time_varying_features(vec!["is_holiday", "promotion_active"])
            .build()?),
        
        // N-BEATS for trend and seasonality
        Box::new(NBEATS::builder()
            .horizon(28)
            .stacks(4)
            .sharing_weights_across_stacks(false)
            .build()?),
        
        // TCN for fast training
        Box::new(TCN::builder()
            .horizon(28)
            .kernel_size(7)
            .num_filters(64)
            .dilations(vec![1, 2, 4, 8, 16, 32])
            .build()?),
    ];

    let mut nf = NeuralForecast::builder()
        .with_models(models)
        .with_frequency(Frequency::Daily)
        .with_prediction_intervals(PredictionIntervals::new(vec![80, 90, 95]))
        .with_ensemble_strategy(EnsembleStrategy::Stacked)  // Meta-learner ensemble
        .build()?;

    // Split data for training and validation
    let (train_data, val_data) = data.train_test_split(0.8)?;

    // Train with validation monitoring
    let training_config = TrainingConfig::new()
        .with_max_epochs(150)
        .with_early_stopping(15)
        .with_validation_data(&val_data)
        .with_learning_rate(0.001)
        .with_batch_size(128)
        .with_gradient_clipping(1.0);

    println!("Training retail forecasting models...");
    nf.fit_with_config(train_data, training_config)?;

    // Generate forecasts
    let forecasts = nf.predict()?;

    // Evaluate performance
    let metrics = nf.evaluate(&val_data)?;
    println!("Validation metrics:");
    println!("  MAE: {:.2}", metrics.mae);
    println!("  RMSE: {:.2}", metrics.rmse);
    println!("  MAPE: {:.2}%", metrics.mape * 100.0);
    println!("  sMAPE: {:.2}%", metrics.smape * 100.0);

    // Save model for production
    nf.save("retail_forecasting_model.neuro")?;

    Ok(())
}

fn energy_load_forecasting() -> Result<(), Box<dyn std::error::Error>> {
    // Load hourly energy consumption data
    let data = TimeSeriesDataFrame::from_csv("energy_load.csv")?
        .with_time_features_auto()  // Automatically generate hour, day, month, etc.
        .with_lag_features(vec![24, 48, 168])  // 1 day, 2 days, 1 week lags
        .with_rolling_features(vec![
            RollingFeature::mean(24),   // 24-hour moving average
            RollingFeature::std(168),   // Weekly standard deviation
        ]);

    // Use Informer for long-term dependencies
    let informer = Informer::builder()
        .horizon(24)          // 24 hours ahead
        .input_size(168)      // 1 week of history
        .hidden_size(256)
        .num_encoder_layers(4)
        .num_decoder_layers(2)
        .attention_factor(3)
        .dropout(0.1)
        .build()?;

    let mut nf = NeuralForecast::builder()
        .with_model(Box::new(informer))
        .with_frequency(Frequency::Hourly)
        .build()?;

    // Cross-validation for robust evaluation
    let cv_results = nf.cross_validation(
        data,
        CrossValidationConfig::new()
            .with_n_windows(12)     // 12 validation windows
            .with_horizon(24)       // 24-hour forecasts
            .with_step_size(24)     // Move forward by 1 day each time
    )?;

    println!("Cross-validation results:");
    println!("  Average MAE: {:.2} kWh", cv_results.average_mae());
    println!("  Average RMSE: {:.2} kWh", cv_results.average_rmse());
    println!("  Average MAPE: {:.2}%", cv_results.average_mape() * 100.0);

    Ok(())
}

fn financial_forecasting() -> Result<(), Box<dyn std::error::Error>> {
    // Load financial data with technical indicators
    let data = TimeSeriesDataFrame::from_csv("stock_prices.csv")?
        .with_technical_indicators(vec![
            TechnicalIndicator::SMA(20),   // 20-day moving average
            TechnicalIndicator::RSI(14),   # Relative Strength Index
            TechnicalIndicator::MACD,      // Moving Average Convergence Divergence
            TechnicalIndicator::BollingerBands(20, 2.0),
        ])
        .with_volatility_features(true);

    // Use DeepAR for probabilistic forecasting
    let deepar = DeepAR::builder()
        .horizon(5)           // 5 trading days
        .hidden_size(128)
        .num_layers(3)
        .distribution("student_t")  // Heavy-tailed distribution for financial data
        .build()?;

    let mut nf = NeuralForecast::builder()
        .with_model(Box::new(deepar))
        .with_frequency(Frequency::Business)  // Business days only
        .with_prediction_intervals(PredictionIntervals::new(vec![50, 80, 90, 95, 99]))
        .build()?;

    let training_config = TrainingConfig::new()
        .with_max_epochs(200)
        .with_learning_rate(0.0005)
        .with_batch_size(32)
        .with_loss_function(LossFunction::PinballLoss)  // For quantile regression
        .with_early_stopping(20);

    nf.fit_with_config(data.clone(), training_config)?;

    // Generate probabilistic forecasts
    let forecasts = nf.predict()?;

    // Calculate risk metrics
    for forecast in forecasts {
        let var_95 = forecast.quantile(0.05);  // Value at Risk (95%)
        let var_99 = forecast.quantile(0.01);  // Value at Risk (99%)
        let expected_shortfall = forecast.expected_shortfall(0.05);
        
        println!("Asset: {}", forecast.unique_id);
        println!("  VaR (95%): {:.2}", var_95);
        println!("  VaR (99%): {:.2}", var_99);
        println!("  Expected Shortfall: {:.2}", expected_shortfall);
    }

    Ok(())
}

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

fn hybrid_neural_forecasting() -> Result<(), Box<dyn std::error::Error>> {
    // Create base FANN network for feature extraction
    let feature_extractor = NetworkBuilder::<f32>::new()
        .input_layer(50)    // Raw features
        .hidden_layer_with_activation(128, ActivationFunction::ReLU, 1.0)
        .hidden_layer_with_activation(64, ActivationFunction::ReLU, 1.0)
        .output_layer_with_activation(32, ActivationFunction::Linear, 1.0)
        .build();

    // Use extracted features in LSTM model
    let lstm_with_features = LSTM::builder()
        .horizon(12)
        .hidden_size(128)
        .with_feature_extractor(feature_extractor)
        .build()?;

    let mut nf = NeuralForecast::builder()
        .with_model(Box::new(lstm_with_features))
        .build()?;

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

    Ok(())
}

use neuro_divergent::*;
use ruv_swarm::*;

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

    // Define hyperparameter search space
    let hyperparams = vec![
        HyperparameterConfig::new("hidden_size", vec![64, 128, 256]),
        HyperparameterConfig::new("num_layers", vec![2, 3, 4]),
        HyperparameterConfig::new("learning_rate", vec![0.001, 0.01, 0.1]),
        HyperparameterConfig::new("dropout", vec![0.0, 0.1, 0.2]),
    ];

    // Spawn optimization agents
    for i in 0..8 {
        let agent = Agent::new(AgentType::Optimizer)
            .with_hyperparameters(hyperparams.clone())
            .with_model_type("LSTM")
            .spawn(&mut swarm)
            .await?;
    }

    // Coordinate distributed hyperparameter search
    let task = swarm.orchestrate_task()
        .description("Optimize LSTM hyperparameters for forecasting")
        .strategy(OrchestrationStrategy::HyperparameterSearch)
        .execute()
        .await?;

    let result = task.await_completion().await?;
    println!("Best hyperparameters found: {:?}", result.best_params);

    Ok(())
}

use neuro_divergent::losses::*;

// Define custom loss function
#[derive(Clone)]
struct AsymmetricMSE {
    under_penalty: f64,
    over_penalty: f64,
}

impl LossFunction<f64> for AsymmetricMSE {
    fn compute(&self, y_true: &[f64], y_pred: &[f64]) -> f64 {
        y_true.iter().zip(y_pred.iter())
            .map(|(true_val, pred_val)| {
                let error = true_val - pred_val;
                if error > 0.0 {
                    self.under_penalty * error * error
                } else {
                    self.over_penalty * error * error
                }
            })
            .sum::<f64>() / y_true.len() as f64
    }
    
    fn gradient(&self, y_true: &[f64], y_pred: &[f64]) -> Vec<f64> {
        y_true.iter().zip(y_pred.iter())
            .map(|(true_val, pred_val)| {
                let error = true_val - pred_val;
                if error > 0.0 {
                    -2.0 * self.under_penalty * error
                } else {
                    -2.0 * self.over_penalty * error
                }
            })
            .collect()
    }
}

// Use in training
let custom_loss = AsymmetricMSE {
    under_penalty: 2.0,  // Penalize under-forecasting more
    over_penalty: 1.0,
};

let training_config = TrainingConfig::new()
    .with_loss_function(Box::new(custom_loss))
    .with_max_epochs(100);

use neuro_divergent::interpretability::*;

fn model_interpretation() -> Result<(), Box<dyn std::error::Error>> {
    // Create TFT model (naturally interpretable)
    let tft = TFT::builder()
        .horizon(12)
        .with_static_features(vec!["store_type", "region"])
        .with_time_varying_features(vec!["price", "promotion", "weather"])
        .build()?;

    let mut nf = NeuralForecast::builder()
        .with_model(Box::new(tft))
        .with_interpretability(true)  // Enable interpretation features
        .build()?;

    let data = TimeSeriesDataFrame::from_csv("interpretable_data.csv")?;
    nf.fit(data.clone())?;

    // Generate forecasts with interpretability analysis
    let forecasts_with_analysis = nf.predict_with_interpretation()?;

    for analysis in forecasts_with_analysis {
        println!("Series: {}", analysis.unique_id);
        
        // Variable importance
        println!("Variable importance:");
        for (var, importance) in analysis.variable_importance.iter().take(5) {
            println!("  {}: {:.4}", var, importance);
        }
        
        // Attention weights over time
        println!("Attention patterns (recent 5 timesteps):");
        for (t, weight) in analysis.attention_weights.iter().rev().take(5) {
            println!("  t-{}: {:.4}", t, weight);
        }
        
        // Feature contributions to each forecast step
        for (step, contributions) in analysis.step_contributions.iter().take(3) {
            println!("Forecast step {}: {:?}", step, contributions);
        }
    }

    Ok(())
}

use neuro_divergent::deployment::*;

#[tokio::main]
async fn production_deployment() -> Result<(), Box<dyn std::error::Error>> {
    // Load pre-trained model
    let mut nf = NeuralForecast::load("production_model.neuro")?;

    // Configure for production
    let config = ProductionConfig::new()
        .with_batch_inference(true)
        .with_caching(true)
        .with_monitoring(true)
        .with_max_memory_mb(2048)
        .with_timeout_ms(5000);

    nf.configure_for_production(config)?;

    // Start inference server
    let server = InferenceServer::new(nf)
        .with_port(8080)
        .with_max_concurrent_requests(100)
        .with_health_check_endpoint("/health")
        .with_metrics_endpoint("/metrics");

    println!("Starting inference server on port 8080...");
    server.run().await?;

    Ok(())
}

// Check data preprocessing
let data = data
    .handle_missing_values(MissingValueStrategy::Forward)
    .normalize_targets(NormalizationStrategy::StandardScaler)
    .remove_outliers(OutlierStrategy::IQR(1.5));

// Adjust learning rate
let training_config = TrainingConfig::new()
    .with_learning_rate(0.001)  // Try smaller learning rate
    .with_gradient_clipping(1.0)  // Prevent exploding gradients
    .with_early_stopping(15);     // Prevent overfitting

// Reduce batch size
let training_config = TrainingConfig::new()
    .with_batch_size(16)  // Reduce from default 32
    .with_gradient_accumulation_steps(2);  // Maintain effective batch size

// Use mixed precision
let training_config = TrainingConfig::new()
    .with_mixed_precision(true)  // Reduce memory by 40-50%
    .with_max_memory_mb(1024);

// Enable parallel processing
let training_config = TrainingConfig::new()
    .with_num_workers(8)
    .with_pin_memory(true)
    .with_prefetch_factor(2);

// Use faster model
let tcn = TCN::builder()  // TCN trains 3-5x faster than LSTM
    .horizon(12)
    .kernel_size(3)
    .num_filters(32)
    .build()?;