#![cfg_attr(not(feature = "std"), no_std)]

/// Data structure variants with run-time sanity checks for debugging
pub mod checked {
    use core::{
        cell::UnsafeCell,
        mem::MaybeUninit,
        ptr,
        sync::atomic::{AtomicBool, Ordering},
    };

    /// Equivalent to an `UnsafeCell<MaybeUninit<T>>`, this cell may hold uninitialized data.
    pub struct Maybe<T> {
        data: UnsafeCell<MaybeUninit<T>>,
        loaded: AtomicBool,
    }

    impl<T> Maybe<T> {
        /// Create a new, empty `Maybe<T>`.
        #[inline]
        pub const fn empty() -> Self {
            Self {
                data: UnsafeCell::new(MaybeUninit::uninit()),
                loaded: AtomicBool::new(false),
            }
        }

        /// Create a new, populated `Maybe<T>`.
        #[inline]
        pub const fn new(data: T) -> Self {
            Self {
                data: UnsafeCell::new(MaybeUninit::new(data)),
                loaded: AtomicBool::new(true),
            }
        }

        /// Access the contained value as a constant pointer.
        #[inline]
        pub fn as_ptr(&self) -> *const T {
            unsafe {
                assert_eq!(
                    self.loaded.load(Ordering::Relaxed),
                    true,
                    "as_ptr for uninitialized cell"
                );

                (&*self.data.get()).as_ptr()
            }
        }

        /// Access the contained value as a mutable pointer.
        #[inline]
        pub fn as_mut_ptr(&mut self) -> *mut T {
            unsafe {
                assert_eq!(
                    self.loaded.load(Ordering::Relaxed),
                    true,
                    "as_mut_ptr for uninitialized cell"
                );

                (&mut *self.data.get()).as_mut_ptr()
            }
        }

        /// Obtain a reference to the contained value. This method is `unsafe` because
        /// the value may not have been initialized.
        #[inline]
        pub unsafe fn as_ref(&self) -> &T {
            assert_eq!(
                self.loaded.load(Ordering::Relaxed),
                true,
                "as_ref for uninitialized cell"
            );

            &*(&*self.data.get()).as_ptr()
        }

        /// Override the `loaded` flag of the cell. This method is a no-op when using the
        /// unchecked implementation. It may be used when a value is inserted manually,
        /// for example by assigning to the dereferenced pointer.
        #[inline]
        pub fn set_loaded(&self, loaded: bool) {
            self.loaded.store(loaded, Ordering::Relaxed);
        }

        /// Drop the contained value in place.
        #[inline]
        pub fn clear(&self) {
            unsafe {
                assert_eq!(
                    self.loaded.swap(false, Ordering::Relaxed),
                    true,
                    "cleared uninitialized cell"
                );

                ptr::drop_in_place((&mut *self.data.get()).as_mut_ptr())
            }
        }

        /// Load the contained value.
        #[inline]
        pub fn load(&self) -> T {
            unsafe {
                assert_eq!(
                    self.loaded.swap(false, Ordering::Relaxed),
                    true,
                    "duplicate load"
                );

                ptr::read(self.data.get()).assume_init()
            }
        }

        /// Store a new value in the cell.
        #[inline]
        pub fn store(&self, value: T) {
            unsafe {
                assert_eq!(
                    self.loaded.swap(true, Ordering::Relaxed),
                    false,
                    "duplicate store"
                );

                self.data.get().write(MaybeUninit::new(value))
            }
        }
    }

    impl<T> Drop for Maybe<T> {
        fn drop(&mut self) {
            assert_eq!(
                self.loaded.load(Ordering::Relaxed),
                false,
                "cell not cleared before drop"
            );
        }
    }

    /// Equivalent to an `UnsafeCell<MaybeUninit<T>>`, this cell may hold uninitialized data.
    /// Unlike `Maybe<T>` this structure is suited for data types with no `Drop` implementation.
    pub struct MaybeCopy<T> {
        data: UnsafeCell<MaybeUninit<T>>,
        loaded: AtomicBool,
    }

    // FIXME require Copy when const_fn is stable
    impl<T> MaybeCopy<T> {
        /// Create a new, empty `MaybeCopy<T>`.
        #[inline]
        pub const fn empty() -> Self {
            Self {
                data: UnsafeCell::new(MaybeUninit::uninit()),
                loaded: AtomicBool::new(false),
            }
        }

        /// Create a new, populated `MaybeCopy<T>`.
        #[inline]
        pub const fn new(data: T) -> Self {
            Self {
                data: UnsafeCell::new(MaybeUninit::new(data)),
                loaded: AtomicBool::new(true),
            }
        }
    }

    impl<T: Copy> MaybeCopy<T> {
        /// Access the contained value as a constant pointer.
        #[inline]
        pub fn as_ptr(&self) -> *const T {
            unsafe {
                assert_eq!(
                    self.loaded.load(Ordering::Relaxed),
                    true,
                    "as_ptr for uninitialized cell"
                );

                (&*self.data.get()).as_ptr()
            }
        }

        /// Access the contained value as a mutable pointer.
        #[inline]
        pub fn as_mut_ptr(&mut self) -> *mut T {
            unsafe {
                assert_eq!(
                    self.loaded.load(Ordering::Relaxed),
                    true,
                    "as_mut_ptr for uninitialized cell"
                );

                (&mut *self.data.get()).as_mut_ptr()
            }
        }

        /// Obtain a reference to the contained value. This method is `unsafe` because
        /// the value may not have been initialized.
        #[inline]
        pub unsafe fn as_ref(&self) -> &T {
            assert_eq!(
                self.loaded.load(Ordering::Relaxed),
                true,
                "as_ref for uninitialized cell"
            );

            &*(&*self.data.get()).as_ptr()
        }

        /// Override the `loaded` flag of the cell. This method is a no-op when using the
        /// unchecked implementation. It may be used when a value is inserted manually,
        /// for example by assigning to the dereferenced pointer.
        #[inline]
        pub fn set_loaded(&self, loaded: bool) {
            self.loaded.store(loaded, Ordering::Relaxed);
        }

        /// Load the contained value.
        #[inline]
        pub fn load(&self) -> T {
            unsafe {
                assert_eq!(
                    self.loaded.load(Ordering::Relaxed),
                    true,
                    "load of uninitialized cell"
                );

                ptr::read(self.data.get()).assume_init()
            }
        }

        /// Store a new value in the cell.
        #[inline]
        pub fn store(&self, value: T) {
            unsafe {
                self.loaded.store(true, Ordering::Relaxed);

                self.data.get().write(MaybeUninit::new(value))
            }
        }
    }
}

/// Data structure variants without run-time checks
pub mod unchecked {
    use core::{cell::UnsafeCell, mem::MaybeUninit, ptr};

    /// Equivalent to an `UnsafeCell<MaybeUninit<T>>`, this cell may hold uninitialized data.
    #[repr(transparent)]
    pub struct Maybe<T> {
        data: UnsafeCell<MaybeUninit<T>>,
    }

    impl<T> Maybe<T> {
        /// Create a new, empty `Maybe<T>`.
        #[inline(always)]
        pub const fn empty() -> Self {
            Self {
                data: UnsafeCell::new(MaybeUninit::uninit()),
            }
        }

        /// Create a new, populated `Maybe<T>`.
        #[inline(always)]
        pub const fn new(data: T) -> Self {
            Self {
                data: UnsafeCell::new(MaybeUninit::new(data)),
            }
        }

        /// Access the contained value as a constant pointer.
        #[inline(always)]
        pub fn as_ptr(&self) -> *const T {
            unsafe { (&*self.data.get()).as_ptr() }
        }

        /// Access the contained value as a mutable pointer.
        #[inline(always)]
        pub fn as_mut_ptr(&mut self) -> *mut T {
            unsafe { (&mut *self.data.get()).as_mut_ptr() }
        }

        /// Obtain a reference to the contained value. This method is `unsafe` because
        /// the value may not have been initialized.
        #[inline(always)]
        pub unsafe fn as_ref(&self) -> &T {
            &*(&*self.data.get()).as_ptr()
        }

        /// Override the `loaded` flag of the cell. This method is a no-op when using the
        /// unchecked implementation. It may be used when a value is inserted manually,
        /// for example by assigning to the dereferenced pointer.
        #[inline]
        pub fn set_loaded(&self, _loaded: bool) {}

        /// Drop the contained value in place.
        #[inline(always)]
        pub fn clear(&self) {
            unsafe { ptr::drop_in_place((&mut *self.data.get()).as_mut_ptr()) }
        }

        /// Load the contained value.
        #[inline(always)]
        pub fn load(&self) -> T {
            unsafe { ptr::read(self.data.get()).assume_init() }
        }

        /// Store a new value in the cell.
        #[inline(always)]
        pub fn store(&self, value: T) {
            unsafe { self.data.get().write(MaybeUninit::new(value)) }
        }
    }

    /// Equivalent to an `UnsafeCell<MaybeUninit<T>>`, this cell may hold uninitialized data.
    /// Unlike `Maybe<T>` this structure is suited for data types with no `Drop` implementation.
    #[repr(transparent)]
    pub struct MaybeCopy<T> {
        data: UnsafeCell<MaybeUninit<T>>,
    }

    // FIXME require Copy when const_fn is stable
    impl<T> MaybeCopy<T> {
        /// Create a new, empty `MaybeCopy<T>`.
        #[inline]
        pub const fn empty() -> Self {
            Self {
                data: UnsafeCell::new(MaybeUninit::uninit()),
            }
        }

        /// Create a new, populated `MaybeCopy<T>`.
        #[inline]
        pub const fn new(data: T) -> Self {
            Self {
                data: UnsafeCell::new(MaybeUninit::new(data)),
            }
        }
    }

    impl<T: Copy> MaybeCopy<T> {
        /// Access the contained value as a constant pointer.
        #[inline(always)]
        pub fn as_ptr(&self) -> *const T {
            unsafe { (&*self.data.get()).as_ptr() }
        }

        /// Access the contained value as a mutable pointer.
        #[inline(always)]
        pub fn as_mut_ptr(&mut self) -> *mut T {
            unsafe { (&mut *self.data.get()).as_mut_ptr() }
        }

        /// Obtain a reference to the contained value. This method is `unsafe` because
        /// the value may not have been initialized.
        #[inline(always)]
        pub unsafe fn as_ref(&self) -> &T {
            &*(&*self.data.get()).as_ptr()
        }

        /// Override the `loaded` flag of the cell. This method is a no-op when using the
        /// unchecked implementation. It may be used when a value is inserted manually,
        /// for example by assigning to the dereferenced pointer.
        #[inline]
        pub fn set_loaded(&self, _loaded: bool) {}

        /// Load the contained value.
        #[inline(always)]
        pub fn load(&self) -> T {
            unsafe { ptr::read(self.data.get()).assume_init() }
        }

        /// Store a new value in the cell.
        #[inline(always)]
        pub fn store(&self, value: T) {
            unsafe { self.data.get().write(MaybeUninit::new(value)) }
        }
    }
}