mod error_kind;

use backtrace::Backtrace;

use indoc::indoc;

pub use error_kind::ErrorKind;

/// Used as an [Error type](std::error::Error) throughout this library.
///
/// # Fields
///
/// `kind` -- [kind](ErrorKind) of error.
///
/// `message` -- optional additional information about the error.
///
/// `backtrace` -- stack backtrace of error, created via [backtrace].
pub struct Error {
    kind: ErrorKind,
    message: Option<String>,
    backtrace: Backtrace,
}

impl std::fmt::Debug for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Self::output(self, f)
    }
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Self::output(self, f)
    }
}

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

impl Error {
    /// Method used to construct a new [Error].
    ///
    /// Also creates a [`backtrace`](Backtrace).
    ///
    /// # Arguments
    /// `kind` -- [kind](ErrorKind) of error.
    ///
    /// `message` -- optional additional information about the error.
    ///
    /// # Examples
    ///
    /// ```
    /// # use nardol::error::Error;
    /// # use nardol::error::ErrorKind;
    /// use std::fs::File;
    /// # fn _doctest_fn() -> Result<(), Error> {
    /// match File::open("does_not_exist.rs") {
    ///     Ok(file) => {
    ///     // Do something with the file.
    /// #       Ok(())
    ///     }
    ///     Err(e) => {
    ///         return Err(
    ///             Error::new(
    ///                ErrorKind::OpeningFileFailed,
    ///                // Additional information can be provided.
    ///                Some("Failed to open a file.".to_string())
    ///         ))
    ///     }   
    /// }
    /// # }
    /// ```
    pub fn new(kind: ErrorKind, message: Option<String>) -> Self {
        let backtrace = Backtrace::new();

        Error {
            kind,
            message,
            backtrace,
        }
    }

    /// Method used to format the output of the error.
    fn output(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self.kind {
            ErrorKind::TooBigPacket => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Too Big Packet):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Too Big Packet)\n{:?}", self.backtrace),
            },
            ErrorKind::InvalidPacketKind => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Invalid Packet Kind):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Invalid Packet Kind)\n{:?}", self.backtrace),
            },
            ErrorKind::UnknownPacketKind => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Unknown Packet Kind):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Unknown Packet Kind)\n{:?}", self.backtrace),
            },
            ErrorKind::SerializingFailed => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Serializing Failed):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Serializing Failed)\n{:?}", self.backtrace),
            },
            ErrorKind::DeserializingFailed => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Deserializing Failed):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Deserializing Failed)\n{:?}", self.backtrace),
            },
            ErrorKind::InvalidBufferSize => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Invalid Buffer Size):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Invalid Buffer Size)\n{:?}", self.backtrace),
            },
            ErrorKind::WritingToStreamFailed => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Writing To Stream Failed):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Writing To Stream Failed)\n{:?}", self.backtrace),
            },
            ErrorKind::ReadingFromStreamFailed => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Reading From Stream Failed):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Reading From Stream Failed)\n{:?}", self.backtrace),
            },
            ErrorKind::SendingToAddressFailed => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Sending To Address Failed):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Sending To Address Failed)\n{:?}", self.backtrace),
            },
            ErrorKind::ReceivingFromAddressFailed => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Receiving From Address Failed):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(
                    f,
                    "Error(Receiving From Address Failed)\n{:?}",
                    self.backtrace
                ),
            },
            ErrorKind::CreatingDirFailed => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                    \n
                    Error(Creating Dir Failed):\n
                    {}\n
                    source:\n
                    {:?}
                    "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Creating Dir Failed)\n{:?}", self.backtrace),
            },
            ErrorKind::CreatingFileFailed => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                    \n
                    Error(Creating File Failed):\n
                    {}\n
                    source:\n
                    {:?}
                    "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Creating File Failed)\n{:?}", self.backtrace),
            },
            ErrorKind::OpeningFileFailed => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Opening File Failed):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Opening File Failed)\n{:?}", self.backtrace),
            },
            ErrorKind::WritingToFileFailed => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Writing To File Failed):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Writing To File Failed)\n{:?}", self.backtrace),
            },
            ErrorKind::ReadingFromFileFailed => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Reading From File Failed):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Reading From File Failed)\n{:?}", self.backtrace),
            },
            ErrorKind::ParsingFailed => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Parsing Failed):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Parsing Failed)\n{:?}", self.backtrace),
            },
            ErrorKind::OtherSource(_) => match &self.message {
                Some(message) => write!(
                    f,
                    indoc! {
                    "
                        \n
                        Error(Other Source):\n
                        {}\n
                        source:\n
                        {:?}
                        "
                    },
                    message, self.backtrace
                ),
                None => write!(f, "Error(Other Source)\n{:?}", self.backtrace),
            },
        }
    }
}