use std::fmt;

#[derive(Debug, thiserror::Error)]
pub enum Parameter {
    #[error("given URI {0:?}")]
    Uri(String),

    #[error("given Alias ID {0:?}")]
    AliasID(String),

    #[error("stored Share ID {0:?}")]
    ShareID(String),

    #[error("stored File ID {0:?}")]
    FileID(String),
}

impl Parameter {
    fn is_fatal(&self) -> bool {
        matches!(self, Self::Uri(_) | Self::AliasID(_))
    }
}

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error(transparent)]
    StdIo(#[from] std::io::Error),

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

    #[error("Invalid {0}")]
    InvalidParameter(Parameter),

    #[error("Mismatch, expected {expected:?} but got {actual:?}")]
    Mismatch { expected: String, actual: String },

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

#[allow(clippy::needless_pass_by_value)]
fn into_string(val: impl ToString) -> String {
    val.to_string()
}

impl Error {
    pub fn res_status_check<T>(actual: T, expected: T) -> Result<()>
    where
        T: PartialEq + fmt::Display + Copy,
    {
        if actual == expected {
            Ok(())
        } else {
            Err(Self::Response(format!(
                "unexpected status: {actual} (expected {expected})"
            )))
        }
    }

    pub fn response(e: impl ToString) -> Self {
        Self::Response(into_string(e))
    }

    pub fn mismatch(expected: impl ToString, actual: impl ToString) -> Self {
        Self::Mismatch {
            expected: into_string(expected),
            actual: into_string(actual),
        }
    }

    #[must_use]
    pub fn is_fatal(&self) -> bool {
        match self {
            Self::InvalidParameter(p) => p.is_fatal(),
            Self::Mismatch { .. } => true,
            Self::Unknown(_) => true,
            _ => false,
        }
    }
}

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