use std::{
    cmp::Ordering,
    fmt::{self, Formatter, LowerHex},
    ops::{Add, AddAssign},
};

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct Addr(pub u64);

impl LowerHex for Addr {
    fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
        let Addr(v) = self;
        LowerHex::fmt(v, fmt)
    }
}

impl<T> Add<T> for Addr
where
    T: Add<u64, Output = u64>,
    u64: Add<T, Output = u64>,
{
    type Output = Addr;

    fn add(self, rhs: T) -> Self::Output {
        Addr(self.0 + rhs)
    }
}

macro_rules! impl_add_assign {
    ($ty:ty) => {
        impl AddAssign<$ty> for Addr {
            fn add_assign(&mut self, rhs: $ty) {
                self.0 = self.0 + (rhs as u64);
            }
        }
    }
}

impl_add_assign!(usize);
impl_add_assign!(u64);

macro_rules! impl_cmp {
    ($ty:ty) => {
        impl PartialEq<$ty> for Addr {
            fn eq(&self, other: &$ty) -> bool {
                self.0 == (*other as u64)
            }
        }

        impl PartialOrd<$ty> for Addr {
            fn partial_cmp(&self, other: &$ty) -> Option<Ordering> {
                let other = *other as u64;
                self.0.partial_cmp(&other)
            }
        }
    }
}

impl_cmp!(usize);
impl_cmp!(u64);

macro_rules! impl_from {
    ($ty:ty) => {
        impl From<$ty> for Addr {
            fn from(other: $ty) -> Self {
                Addr(other as u64)
            }
        }
    }
}

impl_from!(usize);
impl_from!(u64);