use thiserror::Error;

#[derive(Error, Debug)]
pub enum MultimodalError {
    #[error("Tensor error: {0}")]
    Tensor(#[from] rtx_tensor::error::TensorError),

    #[error("Runtime error: {0}")]
    Runtime(#[from] rtx_runtime::error::RuntimeError),

    #[error("Graph error: {0}")]
    Graph(#[from] rtx_polygraph::error::PolygraphError),

    #[error("Invalid input dimensions: expected {expected:?}, got {actual:?}")]
    InvalidDimensions {
        expected: Vec<usize>,
        actual: Vec<usize>,
    },

    #[error("Invalid patch size: {patch_size} for image size {image_size}")]
    InvalidPatchSize {
        patch_size: usize,
        image_size: usize,
    },

    #[error("Invalid sequence length: {seq_len} exceeds maximum {max_len}")]
    InvalidSequenceLength { seq_len: usize, max_len: usize },

    #[error("Mismatched modality: expected {expected}, got {actual}")]
    ModalityMismatch { expected: String, actual: String },

    #[error("Audio processing error: {message}")]
    AudioProcessing { message: String },

    #[error("Video processing error: {message}")]
    VideoProcessing { message: String },

    #[error("Cross-modal fusion error: {message}")]
    FusionError { message: String },

    #[error("Model not initialized")]
    ModelNotInitialized,

    #[error("Configuration error: {0}")]
    Config(String),

    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),

    #[error("Image processing error: {0}")]
    ImageProcessing(#[from] image::ImageError),

    #[error("Processing error: {0}")]
    Processing(String),

    #[error("Transformer error: {0}")]
    Transformer(#[from] rtx_transformers::error::TransformerError),
}

impl MultimodalError {
    /// Create a tensor error
    pub fn tensor(message: String) -> Self {
        Self::Processing(message)
    }

    /// Create a processing error
    pub fn processing(message: String) -> Self {
        Self::Processing(message)
    }
}

pub type Result<T> = std::result::Result<T, MultimodalError>;