use std::mem::MaybeUninit;

/// This trait is used to write code that may work on matrices that may or may not
/// be initialized.
///
/// This trait is used to describe how a value must be accessed to initialize it or
/// to retrieve a reference or mutable reference. Typically, a function accepting
/// both initialized and uninitialized inputs should have a `Status: InitStatus<T>`
/// type parameter. Then the methods of the `Status` can be used to access the element.
///
/// # Safety
/// This trait must not be implemented outside of this crate.
pub unsafe trait InitStatus<T>: Copy {
    /// The type of the values with the initialization status described by `Self`.
    type Value;

    /// Initialize the given element.
    fn init(out: &mut Self::Value, t: T);

    /// Retrieve a reference to the element, assuming that it is initialized.
    ///
    /// # Safety
    /// This is unsound if the referenced value isn’t initialized.
    unsafe fn assume_init_ref(t: &Self::Value) -> &T;

    /// Retrieve a mutable reference to the element, assuming that it is initialized.
    ///
    /// # Safety
    /// This is unsound if the referenced value isn’t initialized.
    unsafe fn assume_init_mut(t: &mut Self::Value) -> &mut T;
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
/// A type implementing `InitStatus` indicating that the value is completely initialized.
pub struct Init;
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
/// A type implementing `InitStatus` indicating that the value is completely uninitialized.
pub struct Uninit;

unsafe impl<T> InitStatus<T> for Init {
    type Value = T;

    #[inline(always)]
    fn init(out: &mut T, t: T) {
        *out = t;
    }

    #[inline(always)]
    unsafe fn assume_init_ref(t: &T) -> &T {
        t
    }

    #[inline(always)]
    unsafe fn assume_init_mut(t: &mut T) -> &mut T {
        t
    }
}

unsafe impl<T> InitStatus<T> for Uninit {
    type Value = MaybeUninit<T>;

    #[inline(always)]
    fn init(out: &mut MaybeUninit<T>, t: T) {
        *out = MaybeUninit::new(t);
    }

    #[inline(always)]
    unsafe fn assume_init_ref(t: &MaybeUninit<T>) -> &T {
        unsafe {
            &*t.as_ptr() // TODO: use t.assume_init_ref()
        }
    }

    #[inline(always)]
    unsafe fn assume_init_mut(t: &mut MaybeUninit<T>) -> &mut T {
        unsafe {
            &mut *t.as_mut_ptr() // TODO: use t.assume_init_mut()
        }
    }
}
