//! MAMBA-2 Bayesian Hyperparameter Optimization using Egobox
//!
//! **STATUS: BLOCKED BY NDARRAY VERSION CONFLICT**
//!
//! This example demonstrates the correct usage of egobox for Bayesian optimization,
//! but cannot run due to ndarray version incompatibility:
//! - Egobox 0.33 requires ndarray 0.15.6
//! - Foxhunt uses ndarray 0.16.1
//!
//! **Recommended Alternative**: Use Optuna or wait for egobox to upgrade.
//!
//! ## Implementation Features (when usable)
//!
//! This script would provide production-ready Bayesian optimization for MAMBA-2 using:
//! - Egobox library (Rust-native Bayesian optimization)
//! - Expected Improvement (EI) acquisition function
//! - Latin Hypercube Sampling for initial exploration
//! - Log-scale search for learning rate and weight decay
//! - GPU-accelerated training evaluations
//!
//! ## Configuration
//! ```yaml
//! Search Space:
//!   Learning Rate: 1e-5 to 1e-2 (log scale)
//!   Batch Size: 16 to 256 (integer)
//!   Dropout: 0.0 to 0.5 (linear scale)
//!   Weight Decay: 1e-6 to 1e-2 (log scale)
//!
//! Optimization:
//!   Initial Samples: 5 (Latin Hypercube)
//!   Acquisition: Expected Improvement (EI)
//!   Surrogate: Gaussian Process
//!   Max Trials: 30 (default)
//!   Epochs per Trial: 10 (fast feedback)
//! ```
//!
//! ## Features
//! - **Fast Convergence**: Finds good hyperparameters in 20-30 trials
//! - **GPU Accelerated**: Each trial trains on CUDA
//! - **Smart Exploration**: Balances exploration vs exploitation
//! - **Progress Tracking**: Real-time trial updates
//! - **YAML Export**: Save best parameters for production
//!
//! ## Usage
//! ```bash
//! # Default: 30 trials on ES.FUT data
//! cargo run -p ml --example optimize_mamba2_egobox --release --features cuda
//!
//! # Show all available options:
//! cargo run -p ml --example optimize_mamba2_egobox --release --features cuda -- --help
//!
//! # Custom search space and trials:
//! cargo run -p ml --example optimize_mamba2_egobox --release --features cuda -- \
//!     --parquet-file test_data/NQ_FUT_180d.parquet \
//!     --max-trials 50 \
//!     --epochs-per-trial 15 \
//!     --lr-min 0.00001 \
//!     --lr-max 0.01 \
//!     --batch-size-min 32 \
//!     --batch-size-max 128
//!
//! # Save results to YAML:
//! cargo run -p ml --example optimize_mamba2_egobox --release --features cuda -- \
//!     --parquet-file test_data/ES_FUT_180d.parquet \
//!     --max-trials 30 \
//!     --output-yaml ml/hyperparams/mamba2_best.yaml
//! ```
//!
//! ## Expected Performance
//! - Trial Duration: ~18 seconds (10 epochs)
//! - Total Time (30 trials): ~9 minutes
//! - GPU Utilization: ~60-70%
//! - Memory: ~2GB VRAM per trial
//!
//! ## Output
//! - Console: Real-time progress and best parameters
//! - YAML file (optional): Best hyperparameters for production
//! - Metrics: Validation loss and perplexity

use anyhow::{Context, Result};
use clap::Parser;
use std::path::PathBuf;
use tracing::info;

use ml::hyperopt::egobox_tuner::{optimize_mamba2, HyperparameterSpace};

/// MAMBA-2 Bayesian Optimization CLI Arguments
#[derive(Parser, Debug)]
#[command(
    name = "optimize_mamba2_egobox",
    about = "MAMBA-2 Bayesian Hyperparameter Optimization using Egobox",
    long_about = "Efficiently find optimal MAMBA-2 hyperparameters using Bayesian optimization with Gaussian Process surrogates and Expected Improvement acquisition."
)]
struct Args {
    /// Path to Parquet file containing market data
    #[arg(long, default_value = "test_data/ES_FUT_180d.parquet")]
    parquet_file: PathBuf,

    /// Maximum number of optimization trials
    #[arg(
        long,
        default_value = "30",
        help = "Total trials (including 5 initial LHS samples)"
    )]
    max_trials: usize,

    /// Number of training epochs per trial
    #[arg(
        long,
        default_value = "10",
        help = "Epochs per trial - lower for faster feedback"
    )]
    epochs_per_trial: usize,

    /// Minimum learning rate (actual value, not log)
    #[arg(long, default_value = "0.00001", help = "Minimum learning rate (1e-5)")]
    lr_min: f64,

    /// Maximum learning rate (actual value, not log)
    #[arg(long, default_value = "0.01", help = "Maximum learning rate (1e-2)")]
    lr_max: f64,

    /// Minimum weight decay (actual value, not log)
    #[arg(long, default_value = "0.000001", help = "Minimum weight decay (1e-6)")]
    wd_min: f64,

    /// Maximum weight decay (actual value, not log)
    #[arg(long, default_value = "0.01", help = "Maximum weight decay (1e-2)")]
    wd_max: f64,

    /// Minimum dropout rate
    #[arg(
        long,
        default_value = "0.0",
        help = "Minimum dropout (0.0 = no dropout)"
    )]
    dropout_min: f64,

    /// Maximum dropout rate
    #[arg(
        long,
        default_value = "0.5",
        help = "Maximum dropout (0.5 = aggressive)"
    )]
    dropout_max: f64,

    /// Minimum batch size
    #[arg(
        long,
        default_value = "16",
        help = "Minimum batch size (small batches)"
    )]
    batch_size_min: usize,

    /// Maximum batch size
    #[arg(
        long,
        default_value = "256",
        help = "Maximum batch size (large batches)"
    )]
    batch_size_max: usize,

    /// Output YAML file for best hyperparameters
    #[arg(
        long,
        help = "Optional: Save best hyperparameters to YAML file for production use"
    )]
    output_yaml: Option<PathBuf>,
}

impl Args {
    /// Validate CLI arguments
    fn validate(&self) -> Result<()> {
        // Validate learning rate bounds
        if self.lr_min <= 0.0 || self.lr_min >= self.lr_max {
            anyhow::bail!(
                "Invalid learning rate bounds: min={}, max={}. Must be 0 < min < max",
                self.lr_min,
                self.lr_max
            );
        }

        // Validate weight decay bounds
        if self.wd_min < 0.0 || self.wd_min >= self.wd_max {
            anyhow::bail!(
                "Invalid weight decay bounds: min={}, max={}. Must be 0 <= min < max",
                self.wd_min,
                self.wd_max
            );
        }

        // Validate dropout bounds
        if self.dropout_min < 0.0 || self.dropout_min >= self.dropout_max || self.dropout_max > 1.0
        {
            anyhow::bail!(
                "Invalid dropout bounds: min={}, max={}. Must be 0 <= min < max <= 1",
                self.dropout_min,
                self.dropout_max
            );
        }

        // Validate batch size bounds
        if self.batch_size_min == 0 || self.batch_size_min >= self.batch_size_max {
            anyhow::bail!(
                "Invalid batch size bounds: min={}, max={}. Must be 0 < min < max",
                self.batch_size_min,
                self.batch_size_max
            );
        }

        // Validate trials
        if self.max_trials < 6 {
            anyhow::bail!(
                "Max trials must be >= 6 (5 initial LHS samples + at least 1 optimization)"
            );
        }

        // Validate epochs
        if self.epochs_per_trial == 0 {
            anyhow::bail!("Epochs per trial must be > 0");
        }

        // Validate Parquet file exists
        if !self.parquet_file.exists() {
            anyhow::bail!("Parquet file not found: {:?}", self.parquet_file);
        }

        Ok(())
    }

    /// Convert to HyperparameterSpace
    fn to_space(&self) -> HyperparameterSpace {
        HyperparameterSpace {
            learning_rate_log_min: self.lr_min.log10(),
            learning_rate_log_max: self.lr_max.log10(),
            batch_size_min: self.batch_size_min,
            batch_size_max: self.batch_size_max,
            dropout_min: self.dropout_min,
            dropout_max: self.dropout_max,
            weight_decay_log_min: self.wd_min.log10(),
            weight_decay_log_max: self.wd_max.log10(),
        }
    }
}

/// Main optimization function
#[tokio::main]
async fn main() -> Result<()> {
    // Initialize tracing
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .with_target(false)
        .with_thread_ids(false)
        .init();

    info!("╔═══════════════════════════════════════════════════════════╗");
    info!("║   MAMBA-2 Bayesian Hyperparameter Optimization           ║");
    info!("║   Powered by Egobox (Efficient Global Optimization)      ║");
    info!("╚═══════════════════════════════════════════════════════════╝");

    // Parse and validate arguments
    let args = Args::parse();

    if let Err(e) = args.validate() {
        tracing::error!("❌ Invalid arguments: {}", e);
        std::process::exit(1);
    }

    info!("Configuration:");
    info!("  Parquet File: {:?}", args.parquet_file);
    info!("  Max Trials: {}", args.max_trials);
    info!("  Epochs per Trial: {}", args.epochs_per_trial);
    info!("  Learning Rate: {} to {}", args.lr_min, args.lr_max);
    info!(
        "  Batch Size: {} to {}",
        args.batch_size_min, args.batch_size_max
    );
    info!("  Dropout: {} to {}", args.dropout_min, args.dropout_max);
    info!("  Weight Decay: {} to {}", args.wd_min, args.wd_max);

    if let Some(ref output_file) = args.output_yaml {
        info!("  Output YAML: {:?}", output_file);
    }

    // Create hyperparameter space
    let space = args.to_space();

    // Run optimization
    info!("");
    info!("Starting Bayesian optimization...");
    info!(
        "Expected duration: ~{:.1} minutes",
        (args.max_trials as f64 * args.epochs_per_trial as f64 * 1.8) / 60.0
    );
    info!("");

    let result = optimize_mamba2(
        space,
        args.parquet_file.to_str().unwrap(),
        args.max_trials,
        args.epochs_per_trial,
    )
    .await
    .context("Optimization failed")?;

    // Display results
    info!("");
    info!("╔═══════════════════════════════════════════════════════════╗");
    info!("║   Optimization Results                                    ║");
    info!("╚═══════════════════════════════════════════════════════════╝");
    info!("Best Hyperparameters:");
    info!("  Learning Rate: {:.6}", result.best_params.learning_rate);
    info!("  Batch Size: {}", result.best_params.batch_size);
    info!("  Dropout: {:.3}", result.best_params.dropout);
    info!("  Weight Decay: {:.6}", result.best_params.weight_decay);
    info!("");
    info!("Performance:");
    info!(
        "  Best Validation Loss: {:.6}",
        result.best_params.best_validation_loss
    );
    info!(
        "  Best Perplexity: {:.4}",
        result.best_params.best_validation_loss.exp()
    );
    info!("  Trials Used: {}", result.best_params.trials_used);

    // Save to YAML if requested
    if let Some(output_file) = args.output_yaml {
        // Create parent directories if needed
        if let Some(parent) = output_file.parent() {
            std::fs::create_dir_all(parent).context("Failed to create output directory")?;
        }

        let yaml_content =
            serde_yaml::to_string(&result.best_params).context("Failed to serialize to YAML")?;

        std::fs::write(&output_file, yaml_content).context("Failed to write YAML file")?;

        info!("");
        info!("✓ Best hyperparameters saved to: {:?}", output_file);
    }

    info!("");
    info!("╔═══════════════════════════════════════════════════════════╗");
    info!("║   Optimization Complete                                   ║");
    info!("╚═══════════════════════════════════════════════════════════╝");
    info!("");
    info!("Next Steps:");
    info!("  1. Use these hyperparameters for full 50-200 epoch training");
    info!(
        "  2. Run: cargo run -p ml --example train_mamba2_parquet --release --features cuda -- \\"
    );
    info!(
        "         --learning-rate {} \\",
        result.best_params.learning_rate
    );
    info!("         --batch-size {} \\", result.best_params.batch_size);
    info!("         --dropout {} \\", result.best_params.dropout);
    info!(
        "         --weight-decay {} \\",
        result.best_params.weight_decay
    );
    info!("         --epochs 100");

    Ok(())
}