use std::fmt;

pub type QueueResult<T> = Result<T, QueueError>;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum QueueError {
    Config(String),
    Connect(String),
    Publish(String),
    Payload(String),
}

impl QueueError {
    pub fn config(message: impl Into<String>) -> Self {
        Self::Config(message.into())
    }

    pub fn connect(message: impl Into<String>) -> Self {
        Self::Connect(message.into())
    }

    pub fn publish(message: impl Into<String>) -> Self {
        Self::Publish(message.into())
    }

    pub fn payload(message: impl Into<String>) -> Self {
        Self::Payload(message.into())
    }

    pub fn message(&self) -> &str {
        match self {
            Self::Config(message)
            | Self::Connect(message)
            | Self::Publish(message)
            | Self::Payload(message) => message,
        }
    }
}

impl fmt::Display for QueueError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        let label = match self {
            Self::Config(_) => "config",
            Self::Connect(_) => "connect",
            Self::Publish(_) => "publish",
            Self::Payload(_) => "payload",
        };
        write!(formatter, "rocketmq {label}: {}", self.message())
    }
}

impl std::error::Error for QueueError {}

impl From<serde_json::Error> for QueueError {
    fn from(error: serde_json::Error) -> Self {
        Self::Payload(error.to_string())
    }
}