//! Error types for ML models crate - unified with CommonError

use common::error::CommonError;

/// `Result` type alias for ML models operations - updated to use CommonError
pub type MLResult<T> = Result<T, CommonError>;

/// `Result` type alias for model operations
pub type ModelResult<T> = Result<T, CommonError>;

/// Convert candle error to CommonError
///
/// Cannot implement `From<candle_core::Error>` for CommonError due to orphan rule.
/// Use this function to convert candle errors when needed.
pub fn candle_error_to_common_error(err: candle_core::Error) -> CommonError {
    CommonError::ml(
        "candle_computation",
        format!("Candle computation error: {}", err),
    )
}
/// Create an ML training error
pub fn ml_training_error(message: &str, model: Option<String>) -> CommonError {
    CommonError::ml(
        "training",
        format!("ML training error: {} (model: {:?})", message, model),
    )
}

/// Create an ML inference error
pub fn ml_inference_error(message: &str, model: Option<String>) -> CommonError {
    CommonError::ml(
        "inference",
        format!("ML inference error: {} (model: {:?})", message, model),
    )
}

/// Create an ML validation error
pub fn ml_validation_error(field: &str, message: &str) -> CommonError {
    CommonError::validation(format!(
        "ML validation error in field '{}': {}",
        field, message
    ))
}

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

    #[test]
    fn test_ml_error_creation() {
        let inference_error =
            ml_inference_error("Test inference error", Some("test_model".to_string()));
        let error_str = inference_error.to_string();
        assert!(error_str.contains("Test inference error"));
        assert!(error_str.contains("test_model"));

        let training_error = ml_training_error("Test training error", None);
        let error_str = training_error.to_string();
        assert!(error_str.contains("Test training error"));

        let validation_error = ml_validation_error("input", "Invalid input shape");
        let error_str = validation_error.to_string();
        assert!(error_str.contains("input"));
        assert!(error_str.contains("Invalid input shape"));
    }
}