use std::{convert::From, net::AddrParseError, string::ParseError};

use aes::cipher::typenum::IsLessOrEqual;

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

#[derive(Debug)]
pub enum SDLanError {
    IOError(String),
    NormalError(&'static str),
    ConvertError(String),
    SerializeError(String),
    EncryptError(String),
    DBError(String),
}

impl SDLanError {
    pub fn as_str(&self) -> &str {
        match *self {
            Self::IOError(ref e) => e,
            Self::NormalError(ref s) => s,
            Self::ConvertError(ref e) => e,
            Self::SerializeError(ref e) => e,
            Self::EncryptError(ref e) => e,
            Self::DBError(ref e) => e,
        }
    }
}

impl From<std::io::Error> for SDLanError {
    fn from(value: std::io::Error) -> Self {
        Self::IOError(value.to_string())
    }
}

impl From<&'static str> for SDLanError {
    fn from(value: &'static str) -> Self {
        Self::NormalError(value)
    }
}

impl From<serde_json::Error> for SDLanError {
    fn from(value: serde_json::Error) -> Self {
        Self::SerializeError(value.to_string())
    }
}

impl From<sqlx::Error> for SDLanError {
    fn from(value: sqlx::Error) -> Self {
        Self::DBError(value.to_string())
    }
}

impl From<ParseError> for SDLanError {
    fn from(value: ParseError) -> Self {
        Self::ConvertError(value.to_string())
    }
}

impl From<AddrParseError> for SDLanError {
    fn from(value: AddrParseError) -> Self {
        Self::ConvertError(value.to_string())
    }
}