use core::cmp::Ordering;
use core::mem::MaybeUninit;
use crate::cast_traits::As;

/// Converts reference of struct to binary slice
#[inline(always)]
pub fn slicify<T>(value: &T) -> &[u8] {
    let ptr = value as *const T as *const u8;
    unsafe { core::slice::from_raw_parts(ptr, core::mem::size_of::<T>()) }
}

/// Converts reference of struct to binary slice
#[inline(always)]
pub unsafe fn slicify_mut<T>(value: &mut T) -> &mut [u8] {
    let ptr = value as *mut T as *mut u8;
    core::slice::from_raw_parts_mut(ptr, core::mem::size_of::<T>())
}


/// converts a non mutable reference into a mutable one
#[inline(always)]
pub unsafe fn mutify<T>(nr: &T) -> &mut T {
    #[allow(invalid_reference_casting)]
    &mut *(nr as *const T as *mut T)
}

/// converts a reference of any lifetime to 'static
#[inline(always)]
pub unsafe fn statify<'a, T>(nr: &'a T) -> &'static T {
    &*(nr as *const T)
}

/// converts mutable a reference of any lifetime to 'static
#[inline(always)]
pub unsafe fn statify_mut<'a, T>(nr: &'a mut T) -> &'static mut T {
    &mut *(nr as *mut T)
}

/// gets the distance between two references
pub fn distance(p1: impl As<usize>, p2: impl As<usize>) -> usize {
    let (p1, p2) = (p1.cast(), p2.cast());
    match p1.cmp(&p2) {
        Ordering::Less => p2 - p1,
        Ordering::Greater => p1 - p2,
        Ordering::Equal => 0,
    }
}

pub unsafe trait Zeroed: Sized {
    #[inline(always)]
    fn zeroed() -> Self { unsafe { core::mem::zeroed() } }
}