use std::{
    error::Error,
    fmt::{Display, Formatter},
    path::Path,
};

mod for_serde;
mod for_std;

pub type TspResult<T> = Result<T, TspError>;

#[derive(Debug, Clone)]
pub struct TspError {
    kind: Box<TspErrorKind>,
}

#[derive(Debug, Clone)]
pub enum TspErrorKind {
    IoError { file: String, message: String },
    EncodeError { message: String },
    DecodeError { message: String },
}

impl Error for TspError {}

impl Display for TspError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        Display::fmt(&self.kind, f)
    }
}

impl Display for TspErrorKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            TspErrorKind::IoError { file, message } => write!(f, "IO error: {} {}", file, message),
            TspErrorKind::EncodeError { message } => write!(f, "Encode error: {}", message),
            TspErrorKind::DecodeError { message } => write!(f, "Decode error: {}", message),
        }
    }
}

impl TspError {
    pub fn io_error<S, P>(file: P, message: S) -> Self
    where
        S: Into<String>,
        P: AsRef<Path>,
    {
        Self {
            kind: Box::new(TspErrorKind::IoError {
                file: file.as_ref().to_string_lossy().to_string(),
                message: message.into(),
            }),
        }
    }
}