use crate::rstd::inlining::*;

use super::*;

impl Serializable for u64 {
    fn serialize(&self, serializer: &mut dyn Serializer) {
        serializer.write(&self.to_le_bytes());
    }
}

#[derive(Debug, PartialEq)]
pub enum IntParseError {
    Eof,
    ExtraData(usize),
}

impl Display for IntParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Eof => write!(f, "encountered EOF write parsing an integer."),
            Self::ExtraData(length) => write!(
                f,
                "encountered extra data of length {length} while parsing an integer.",
            ),
        }
    }
}

impl Error for IntParseError {}

impl From<&[u8]> for IntParseError {
    fn from(_value: &[u8]) -> Self {
        Self::Eof
    }
}

impl Atomic for u64 {
    type AParseError = IntParseError;

    fn a_deserialize(deserializer: &mut dyn Deserializer) -> Result<Self, Self::AParseError> {
        Ok(u64::from_le_bytes(deserializer.read_n_const::<8>()?))
    }

    fn a_extend(self, tail: &[u8]) -> Result<Self, Self::AParseError> {
        Err(IntParseError::ExtraData(tail.len()))
    }
}

impl ConstSizeAtomic for u64 {
    const SIZE: usize = 8;
}