//! Model Factory for Testing
//!
//! This module provides factory functions for creating model instances
//! primarily for testing purposes.

use std::sync::Arc;
use crate::{MLModel, MLResult, ModelType, ModelMetadata, Features, ModelPrediction};

/// Simple `DQN` wrapper for testing
#[derive(Debug)]
pub struct DQNWrapper {
    model_id: String,
}

impl DQNWrapper {
    /// Create a new `DQN` wrapper
    pub fn new(model_id: String) -> Self {
        Self { model_id }
    }
}

#[async_trait::async_trait]
impl MLModel for DQNWrapper {
    fn name(&self) -> &str {
        &self.model_id
    }

    fn model_type(&self) -> ModelType {
        ModelType::DQN
    }

    async fn predict(&self, _features: &Features) -> MLResult<ModelPrediction> {
        // Simple stub implementation for testing
        Ok(ModelPrediction::new(
            self.model_id.clone(),
            0.5,  // prediction value
            0.8,  // confidence
        ))
    }

    fn get_confidence(&self) -> f64 {
        0.8
    }

    fn get_metadata(&self) -> ModelMetadata {
        ModelMetadata::new(
            ModelType::DQN,
            "1.0.0".to_string(),
            10,    // features_used
            128.0, // memory_usage_mb
        )
    }
}

/// Create a `DQN` wrapper for testing
pub fn create_dqn_wrapper() -> MLResult<Arc<dyn MLModel>> {
    Ok(Arc::new(DQNWrapper::new("test_dqn".to_string())))
}

/// Create a `DQN` wrapper with specific model ID
pub fn create_dqn_wrapper_with_id(model_id: String) -> MLResult<Arc<dyn MLModel>> {
    Ok(Arc::new(DQNWrapper::new(model_id)))
}

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

    #[tokio::test]
    async fn test_create_dqn_wrapper() {
        let model = create_dqn_wrapper().unwrap();
        assert_eq!(model.name(), "test_dqn");
        assert_eq!(model.model_type(), ModelType::DQN);
        assert!(model.is_ready());
    }

    #[tokio::test]
    async fn test_dqn_wrapper_prediction() {
        let model = create_dqn_wrapper().unwrap();
        let features = Features::new(vec![1.0, 2.0, 3.0], vec!["f1".to_string(), "f2".to_string(), "f3".to_string()]);

        let prediction = model.predict(&features).await.unwrap();
        assert_eq!(prediction.value, 0.5);
        assert_eq!(prediction.confidence, 0.8);
    }
}