//! Error types for the time series forecast demo

use thiserror::Error;

/// Result type for forecaster operations
pub type Result<T> = std::result::Result<T, ForecastError>;

/// Errors that can occur during time series forecasting
#[derive(Debug, Error)]
pub enum ForecastError {
    /// Model not initialized
    #[error("Forecaster not initialized. Fit a model first.")]
    NotInitialized,

    /// Invalid data
    #[error("Invalid data: {0}")]
    InvalidData(String),

    /// Model fitting error
    #[error("Model fitting failed: {0}")]
    FittingError(String),

    /// Forecast generation error
    #[error("Forecast generation failed: {0}")]
    ForecastError(String),

    /// Time series library error
    #[error("Time series error: {0}")]
    TimeSeriesError(String),

    /// Tensor operation error
    #[error("Tensor error: {0}")]
    TensorError(String),

    /// Configuration error
    #[error("Invalid configuration: {0}")]
    ConfigError(String),

    /// Sample data error
    #[error("Sample data error: {0}")]
    SampleDataError(String),
}

impl From<rtx_timeseries::TimeSeriesError> for ForecastError {
    fn from(e: rtx_timeseries::TimeSeriesError) -> Self {
        Self::TimeSeriesError(e.to_string())
    }
}

impl From<rtx_tensor::error::TensorError> for ForecastError {
    fn from(e: rtx_tensor::error::TensorError) -> Self {
        Self::TensorError(e.to_string())
    }
}

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

    #[test]
    fn test_not_initialized_error() {
        let err = ForecastError::NotInitialized;
        assert!(err.to_string().contains("not initialized"));
    }

    #[test]
    fn test_invalid_data_error() {
        let err = ForecastError::InvalidData("empty data".to_string());
        assert!(err.to_string().contains("empty data"));
    }

    #[test]
    fn test_fitting_error() {
        let err = ForecastError::FittingError("convergence failed".to_string());
        assert!(err.to_string().contains("convergence failed"));
    }

    #[test]
    fn test_forecast_error() {
        let err = ForecastError::ForecastError("horizon too large".to_string());
        assert!(err.to_string().contains("horizon too large"));
    }

    #[test]
    fn test_time_series_error() {
        let err = ForecastError::TimeSeriesError("invalid parameters".to_string());
        assert!(err.to_string().contains("invalid parameters"));
    }

    #[test]
    fn test_tensor_error() {
        let err = ForecastError::TensorError("shape mismatch".to_string());
        assert!(err.to_string().contains("shape mismatch"));
    }

    #[test]
    fn test_config_error() {
        let err = ForecastError::ConfigError("invalid model type".to_string());
        assert!(err.to_string().contains("invalid model type"));
    }

    #[test]
    fn test_sample_data_error() {
        let err = ForecastError::SampleDataError("distribution failed".to_string());
        assert!(err.to_string().contains("distribution failed"));
    }

    #[test]
    fn test_error_debug_format() {
        let err = ForecastError::NotInitialized;
        let debug_str = format!("{:?}", err);
        assert!(debug_str.contains("NotInitialized"));
    }

    #[test]
    fn test_result_type() {
        let ok_result: Result<i32> = Ok(42);
        assert!(ok_result.is_ok());

        let err_result: Result<i32> = Err(ForecastError::NotInitialized);
        assert!(err_result.is_err());
    }
}