use core::{fmt, str};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Error<B> {
    Read(ReadError),
    Write(WriteError<B>),
}

impl<B> From<ReadError> for Error<B> {
    fn from(e: ReadError) -> Self {
        Error::Read(e)
    }
}

impl<B> From<WriteError<B>> for Error<B> {
    fn from(e: WriteError<B>) -> Self {
        Error::Write(e)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ReadError {
    Truncated { offset: usize },
    InvalidSize { offset: usize, size: usize },
    MissingSeparator { offset: usize },
    Utf8Error(str::Utf8Error),
}

impl fmt::Display for ReadError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            &ReadError::Truncated { offset }=>
                write!(f, "truncated record at offset {}", offset),
            &ReadError::InvalidSize { offset, size } =>
                write!(f, "invalid record size {} at offset {}", size, offset),
            &ReadError::MissingSeparator { offset } =>
                write!(f, "missing separator at offset {}", offset),
            &ReadError::Utf8Error(err) =>
                write!(f, "{}", err),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum WriteError<B> {
    SpaceExhausted,
    Backend(B),
}

impl<B: fmt::Display> fmt::Display for WriteError<B> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            &WriteError::SpaceExhausted =>
                write!(f, "space exhausted"),
            &WriteError::Backend(ref e) =>
                e.fmt(f),
        }
    }
}