foxhunt/ml/src/random_model.rs

//! # Random Model Baseline
//!
//! Simple random model for baseline comparison and testing.
//! Used to validate the ML pipeline works end-to-end before training real models.
//!
//! ## Purpose
//!
//! - Baseline comparison: Compare trained models against random predictions
//! - Pipeline validation: Prove the system works with a trivial model
//! - Testing infrastructure: Validate backtesting and feature extraction
//!
//! ## Usage
//!
//! ```rust
//! use ml::random_model::RandomModel;
//! use ml::real_data_loader::FeatureMatrix;
//!
//! let model = RandomModel::new();
//! let prediction = model.predict(&feature_matrix);
//!
//! // Prediction is in range [-1.0, 1.0]
//! // Positive = buy signal, Negative = sell signal
//! ```

use rand::{Rng, SeedableRng};
use serde::{Deserialize, Serialize};

use crate::real_data_loader::FeatureMatrix;

/// Random model for baseline comparison
///
/// Generates random predictions in the range [-1.0, 1.0].
/// Useful for:
/// - Validating the ML pipeline works end-to-end
/// - Baseline performance comparison
/// - Testing backtesting infrastructure
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RandomModel {
    /// Random seed for reproducibility
    seed: Option<u64>,
}

impl RandomModel {
    /// Create new random model with optional seed
    ///
    /// # Arguments
    ///
    /// * `seed` - Optional random seed for reproducibility
    pub fn new() -> Self {
        Self { seed: None }
    }

    /// Create random model with specific seed
    ///
    /// Useful for reproducible testing and benchmarking.
    pub fn with_seed(seed: u64) -> Self {
        Self { seed: Some(seed) }
    }

    /// Generate random prediction
    ///
    /// Returns a value in range [-1.0, 1.0]:
    /// - Positive values indicate buy signal
    /// - Negative values indicate sell signal
    /// - Magnitude indicates confidence (0.0 = neutral)
    ///
    /// # Arguments
    ///
    /// * `_features` - Feature matrix (ignored by random model)
    pub fn predict(&self, _features: &FeatureMatrix) -> f32 {
        if let Some(seed) = self.seed {
            // Use seeded RNG for reproducibility
            let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
            rng.gen_range(-1.0..1.0)
        } else {
            // Use thread-local RNG
            let mut rng = rand::thread_rng();
            rng.gen_range(-1.0..1.0)
        }
    }

    /// Generate batch predictions
    ///
    /// Useful for backtesting multiple timesteps at once.
    ///
    /// # Arguments
    ///
    /// * `count` - Number of predictions to generate
    pub fn predict_batch(&self, count: usize) -> Vec<f32> {
        if let Some(seed) = self.seed {
            let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
            (0..count).map(|_| rng.gen_range(-1.0..1.0)).collect()
        } else {
            let mut rng = rand::thread_rng();
            (0..count).map(|_| rng.gen_range(-1.0..1.0)).collect()
        }
    }

    /// Get model name
    pub fn name(&self) -> &str {
        "RandomBaseline"
    }

    /// Get model description
    pub fn description(&self) -> &str {
        "Random baseline model for comparison (uniform distribution [-1, 1])"
    }
}

impl Default for RandomModel {
    fn default() -> Self {
        Self::new()
    }
}

/// Gaussian random model (normal distribution)
///
/// Alternative baseline using normal distribution instead of uniform.
/// Generates predictions centered around 0 with configurable standard deviation.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GaussianRandomModel {
    /// Mean of the distribution (default: 0.0)
    mean: f64,
    /// Standard deviation (default: 0.3)
    std_dev: f64,
    /// Random seed for reproducibility
    seed: Option<u64>,
}

impl GaussianRandomModel {
    /// Create new Gaussian random model
    pub fn new() -> Self {
        Self {
            mean: 0.0,
            std_dev: 0.3,
            seed: None,
        }
    }

    /// Create with custom parameters
    pub fn with_params(mean: f64, std_dev: f64) -> Self {
        Self {
            mean,
            std_dev,
            seed: None,
        }
    }

    /// Create with seed for reproducibility
    pub fn with_seed(seed: u64) -> Self {
        Self {
            mean: 0.0,
            std_dev: 0.3,
            seed: Some(seed),
        }
    }

    /// Generate Gaussian random prediction
    ///
    /// Returns a value from normal distribution N(mean, std_dev^2).
    /// Values are clamped to [-1.0, 1.0] range.
    pub fn predict(&self, _features: &FeatureMatrix) -> f32 {
        use rand_distr::{Distribution, Normal};

        let normal = Normal::new(self.mean, self.std_dev).unwrap();

        let value = if let Some(seed) = self.seed {
            let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
            normal.sample(&mut rng)
        } else {
            let mut rng = rand::thread_rng();
            normal.sample(&mut rng)
        };

        // Clamp to [-1, 1] range
        (value as f32).clamp(-1.0, 1.0)
    }

    /// Generate batch predictions
    pub fn predict_batch(&self, count: usize) -> Vec<f32> {
        use rand_distr::{Distribution, Normal};

        let normal = Normal::new(self.mean, self.std_dev).unwrap();

        if let Some(seed) = self.seed {
            let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
            (0..count)
                .map(|_| (normal.sample(&mut rng) as f32).clamp(-1.0, 1.0))
                .collect()
        } else {
            let mut rng = rand::thread_rng();
            (0..count)
                .map(|_| (normal.sample(&mut rng) as f32).clamp(-1.0, 1.0))
                .collect()
        }
    }

    /// Get model name
    pub fn name(&self) -> &str {
        "GaussianRandomBaseline"
    }

    /// Get model description
    pub fn description(&self) -> String {
        format!(
            "Gaussian random baseline (mean={:.2}, std_dev={:.2})",
            self.mean, self.std_dev
        )
    }
}

impl Default for GaussianRandomModel {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_random_model() {
        let model = RandomModel::new();

        // Generate 1000 predictions
        let predictions = model.predict_batch(1000);

        // Check range
        for pred in &predictions {
            assert!(
                *pred >= -1.0 && *pred <= 1.0,
                "Prediction out of range: {}",
                pred
            );
        }

        // Check distribution (should be roughly uniform)
        let mean: f32 = predictions.iter().sum::<f32>() / predictions.len() as f32;
        assert!(
            mean.abs() < 0.1,
            "Mean should be close to 0 for uniform random (got {})",
            mean
        );

        println!(
            "✅ Random model test passed: {} predictions, mean={:.3}",
            predictions.len(),
            mean
        );
    }

    #[test]
    fn test_gaussian_model() {
        let model = GaussianRandomModel::new();

        // Generate 1000 predictions
        let predictions = model.predict_batch(1000);

        // Check range
        for pred in &predictions {
            assert!(
                *pred >= -1.0 && *pred <= 1.0,
                "Prediction out of range: {}",
                pred
            );
        }

        // Check distribution (should be roughly Gaussian centered at 0)
        let mean: f32 = predictions.iter().sum::<f32>() / predictions.len() as f32;
        assert!(
            mean.abs() < 0.1,
            "Mean should be close to 0 for Gaussian (got {})",
            mean
        );

        // Count how many are close to 0 (should be more than uniform)
        let near_zero = predictions.iter().filter(|&&p| p.abs() < 0.2).count();
        let pct_near_zero = near_zero as f32 / predictions.len() as f32;
        assert!(
            pct_near_zero > 0.3,
            "Gaussian should have more values near 0 (got {:.1}%)",
            pct_near_zero * 100.0
        );

        println!(
            "✅ Gaussian model test passed: {} predictions, mean={:.3}, near_zero={:.1}%",
            predictions.len(),
            mean,
            pct_near_zero * 100.0
        );
    }

    #[test]
    fn test_reproducibility() {
        let model1 = RandomModel::with_seed(42);
        let model2 = RandomModel::with_seed(42);

        let preds1 = model1.predict_batch(100);
        let preds2 = model2.predict_batch(100);

        // Predictions should be identical with same seed
        for (p1, p2) in preds1.iter().zip(preds2.iter()) {
            assert_eq!(*p1, *p2, "Seeded predictions should be identical");
        }

        println!("✅ Reproducibility test passed");
    }
}