use core::fmt::Display;
use core::num::ParseIntError;
use std::error::Error;
use std::ffi::OsString;

use crate::{FD_NAMES_VAR, FD_NUMBER_VAR, PID_VAR};

#[allow(clippy::module_name_repetitions)]
#[derive(Debug)]
pub enum ReceiveError {
    /// The environement variable `LISTEN_PID` didn't exists (probably meaning that no file descriptor was passed to us).
    NoListenPID,
    /// The environement variable `LISTEN_PID` (which should be a decimal number) isn't unicode.
    NotUnicodeListenPID(OsString),
    /// The environement variable `LISTEN_PID` couldn't be parsed as a [`u32`] (real [`pid_t`](libc::pid_t) due to [`std::process::id`])
    ListenPIDParse(ParseIntError),
    /// The environement variable `LISTEN_FDS` didn't exists (probably meaning that no file descriptor was passed to us)
    NoListenFD,
    /// The environement variable `LISTEN_FDS` (which should be a decimal number) isn't unicode.
    NotUnicodeListenFD(OsString),
    /// The environement variable `LISTEN_FDS` couldn't be parsed as a [`usize`].
    ListenFDParse(ParseIntError),
    /// Our PID isn't the one expected as per `LISTEN_PID`.
    PidMismatch { expected: u32, found: u32 },
    /// We couldn't get the file descriptors (see [`GetFdsError`])
    GetFds(GetFdsError),
}

impl Display for ReceiveError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Couldn't receive file descriptors :")?;
        match self {
            ReceiveError::NoListenPID => write!(f, "The variable {PID_VAR} doesn't exists."),
            ReceiveError::NotUnicodeListenPID(var) => write!(f, "The variable {PID_VAR} isn't unicode (this should never happen): it is {var:?}"),
            ReceiveError::ListenPIDParse(error) => write!(f, "Couldn't parse {PID_VAR} as a `u32`: {error}"),
            ReceiveError::NoListenFD => write!(f, "The variable {FD_NUMBER_VAR} doesn't exists."),
            ReceiveError::NotUnicodeListenFD(var) => write!(f, "The variable {FD_NUMBER_VAR} isn't unicode (this should never happen): it is {var:?}"),
            ReceiveError::ListenFDParse(error) => write!(f, "Couldn't parse {FD_NUMBER_VAR} as a `u32`: {error}"),
            ReceiveError::PidMismatch{expected, found} => write!(f, "PID mismatch! Was {found} but should have been {expected}."),
            ReceiveError::GetFds(error) => Display::fmt(error, f),
        }
    }
}

impl Error for ReceiveError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            ReceiveError::NoListenPID
            | ReceiveError::NotUnicodeListenPID(_)
            | ReceiveError::NoListenFD
            | ReceiveError::NotUnicodeListenFD(_)
            | ReceiveError::PidMismatch {
                expected: _,
                found: _,
            } => None,
            ReceiveError::ListenPIDParse(error) | ReceiveError::ListenFDParse(error) => Some(error),
            ReceiveError::GetFds(error) => Some(error),
        }
    }
}

#[allow(clippy::module_name_repetitions)]
#[derive(Debug)]
pub enum ReceiveNameError {
    /// The variable `LISTEN_FDNAMES` didn't exists.
    NoListenFDName,
    /// No file descriptors could be received.
    Receive(ReceiveError),
}

impl From<ReceiveError> for ReceiveNameError {
    fn from(value: ReceiveError) -> Self {
        Self::Receive(value)
    }
}

impl Display for ReceiveNameError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ReceiveNameError::NoListenFDName => write!(
                f,
                "Couldn't find FDs name : the variable {FD_NAMES_VAR} doesn't exists."
            ),
            ReceiveNameError::Receive(error) => Display::fmt(error, f),
        }
    }
}

impl Error for ReceiveNameError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            ReceiveNameError::NoListenFDName => None,
            ReceiveNameError::Receive(error) => Some(error),
        }
    }
}

#[allow(clippy::module_name_repetitions)]
#[derive(Debug)]
pub enum GetFdsError {
    TooManyFDs(usize),
}

impl Display for GetFdsError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            GetFdsError::TooManyFDs(size) => write!(f, "Too many file descriptors ({size})"),
        }
    }
}

impl Error for GetFdsError {}