// Error types for the filtering module
//
// Defines error types specific to event filtering operations,
// integrating with the existing error handling patterns.

use thiserror::Error;

/// Errors that can occur during filtering operations
#[derive(Error, Debug)]
pub enum FilterError {
    #[error("Database error: {0}")]
    Database(#[from] sqlx::Error),
    
    #[error("Storage error: {0}")]
    Storage(#[from] crate::storage::errors::StorageError),
    
    #[error("Invalid filter criteria: {0}")]
    InvalidCriteria(String),
    
    #[error("Invalid location parameters: {0}")]
    InvalidLocation(String),
    
    #[error("Invalid date range: {0}")]
    InvalidDateRange(String),
    
    #[error("Pagination error: {0}")]
    InvalidPagination(String),
    
    #[error("Query building error: {0}")]
    QueryBuilder(String),
    
    #[error("Facet calculation error: {0}")]
    FacetCalculation(String),
    
    #[error("Event hydration error: {0}")]
    Hydration(String),
    
    #[error("Cache error: {0}")]
    Cache(String),
    
    #[error("Serialization error: {0}")]
    Serialization(#[from] serde_json::Error),
}

/// Result type for filtering operations
pub type FilterResult<T> = Result<T, FilterError>;

impl FilterError {
    /// Create an invalid criteria error
    pub fn invalid_criteria(msg: impl Into<String>) -> Self {
        FilterError::InvalidCriteria(msg.into())
    }
    
    /// Create an invalid location error
    pub fn invalid_location(msg: impl Into<String>) -> Self {
        FilterError::InvalidLocation(msg.into())
    }
    
    /// Create an invalid date range error
    pub fn invalid_date_range(msg: impl Into<String>) -> Self {
        FilterError::InvalidDateRange(msg.into())
    }
    
    /// Create an invalid pagination error
    pub fn invalid_pagination(msg: impl Into<String>) -> Self {
        FilterError::InvalidPagination(msg.into())
    }
    
    /// Create a cache operation failed error
    pub fn cache_operation_failed(operation: &str, details: &str) -> Self {
        FilterError::Cache(format!("{}: {}", operation, details))
    }
    
    /// Create a serialization error
    pub fn serialization_error(details: &str) -> Self {
        FilterError::Cache(format!("Serialization failed: {}", details))
    }
}