use std::ptr::NonNull;
use std::{
    alloc::{alloc_zeroed, Layout},
    convert::{TryFrom, TryInto},
    fmt,
    fmt::{Debug, Formatter},
    ops::{Deref, DerefMut, Index, IndexMut},
};

/// A dynamically-allocated array of fixed size.
///
/// # Example
///
/// ```
/// use dynamic_array::SmallArray;
///
/// let mut arr = SmallArray::<u32>::zeroed(9);
///
/// assert!(!arr.is_empty());
///
/// // can be freely dereferenced
/// assert_eq!(arr[3], 0);
///
/// arr[7] = 8;
///
/// assert_eq!(arr[7], 8);
///
/// let mut arr2 = arr.clone();
///
/// // can be indexed by the `Len` type
/// assert_ne!(arr2[3u8], 4);
/// arr[2] = 4;
/// arr2[3] = 4;
/// assert_eq!(arr[2], 4);
///
/// // can still be indexed by `usize`, as a slice
/// assert_eq!(arr2.as_slice()[3usize], 4);
///
/// // can also be freely iterated
/// for x in arr.iter_mut() {
///     *x += 1;
/// }
///
/// assert_eq!(arr[2], 5);
///
/// dbg!(arr);
/// ```
#[cfg_attr(feature = "packed", repr(packed))]
pub struct Array<T, Len: Copy + Into<usize> + TryFrom<usize>> {
    ptr: NonNull<T>,
    len: Len,
}

unsafe impl<T: Sync, Len: Copy + Into<usize> + TryFrom<usize>> Sync for Array<T, Len> {}
unsafe impl<T: Send, Len: Copy + Into<usize> + TryFrom<usize>> Send for Array<T, Len> {}

impl<T, Len: Copy + Into<usize> + TryFrom<usize>> Drop for Array<T, Len> {
    fn drop(&mut self) {
        unsafe {
            std::ptr::drop_in_place(self.deref_mut());
            Vec::from_raw_parts(self.ptr.as_ptr(), 0, self.len.into());
        }
    }
}

impl<T, Len: Copy + Into<usize> + TryFrom<usize>> Array<T, Len> {
    /// Creates a zeroed `Array` with length `len`.
    pub fn zeroed(len: Len) -> Self {
        unsafe {
            let layout = Layout::array::<T>(len.into()).unwrap();
            let ptr = alloc_zeroed(layout).cast::<T>();

            Self::from_raw(ptr, len)
        }
    }

    /// Constructs a new `Array` from a raw pointer.
    ///
    /// After calling this function the pointer is owned by the resulting `Array`.
    pub fn from_raw(raw: *mut T, len: Len) -> Self {
        Self {
            ptr: std::ptr::NonNull::new(raw).unwrap(),
            len,
        }
    }

    /// Extracts a slice containing all the elements of `self`.
    pub fn as_slice(&self) -> &[T] {
        self.deref()
    }

    /// Extracts a mutable slice containing all the elements of `self`.
    pub fn as_slice_mut(&mut self) -> &mut [T] {
        self.deref_mut()
    }

    /// Constructs a new `Array` from a given `Vec`.
    ///
    /// # Example
    ///
    /// ```
    /// use dynamic_array::SmallArray;
    ///
    /// let mut v = vec![8,9,10usize];
    /// v.reserve(1000);
    ///
    /// let arr = SmallArray::from_vec(v);
    ///
    /// assert_eq!(arr.len(), 3);
    /// ```
    pub fn from_vec(mut v: Vec<T>) -> Self
    where
        <Len as TryFrom<usize>>::Error: Debug,
    {
        let len = v.len().try_into().unwrap();
        let ptr = v.as_mut_ptr();
        std::mem::forget(v);

        Self::from_raw(ptr, len)
    }

    /// Constructs a `Vec` from `Self`.
    ///
    /// # Example
    ///
    /// ```
    /// use dynamic_array::SmallArray;
    ///
    /// let arr = SmallArray::<usize>::zeroed(5);
    ///
    /// let v: Vec<usize> = arr.into_vec();
    ///
    /// assert_eq!(v.len(), 5);
    /// assert_eq!(v[3], 0);
    /// ```
    pub fn into_vec(self) -> Vec<T> {
        unsafe {
            let size = self.len().try_into().unwrap();
            let v = Vec::from_raw_parts(self.ptr.as_ptr(), size, size);
            std::mem::forget(self);
            v
        }
    }

    /// The length of the array
    ///
    /// # Example
    ///
    /// ```
    /// use dynamic_array::SmallArray;
    /// let arr = SmallArray::<()>::zeroed(42);
    ///
    /// assert_eq!(arr.len(), 42);
    /// ```
    pub fn len(&self) -> Len {
        self.len
    }

    pub fn is_empty(&self) -> bool {
        self.len().into() == 0
    }
}

/**********************************************************************/
// Trait implementations

impl<T: Clone, Len: Copy + Into<usize> + TryFrom<usize>> Clone for Array<T, Len> {
    fn clone(&self) -> Self {
        unsafe {
            let other = Self::zeroed(self.len);
            other
                .ptr
                .as_ptr()
                .copy_from_nonoverlapping(self.ptr.as_ptr(), self.len.into());
            other
        }
    }
}

impl<T, Len: Copy + Into<usize> + TryFrom<usize>> Deref for Array<T, Len> {
    type Target = [T];

    fn deref(&self) -> &[T] {
        unsafe { std::slice::from_raw_parts(self.ptr.as_ptr(), self.len.into()) }
    }
}

impl<T, Len: Copy + Into<usize> + TryFrom<usize>> DerefMut for Array<T, Len> {
    fn deref_mut(&mut self) -> &mut [T] {
        unsafe { std::slice::from_raw_parts_mut(self.ptr.as_ptr(), self.len.into()) }
    }
}

impl<T: Debug, Len: Copy + Into<usize> + TryFrom<usize>> Debug for Array<T, Len> {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(self.as_slice(), f)
    }
}

impl<T, Len: Copy + Into<usize> + TryFrom<usize>> IntoIterator for Array<T, Len> {
    type Item = T;
    type IntoIter = std::vec::IntoIter<T>;

    fn into_iter(self) -> Self::IntoIter {
        self.into_vec().into_iter()
    }
}

impl<'t, T, Len: Copy + Into<usize> + TryFrom<usize>> IntoIterator for &'t Array<T, Len> {
    type Item = &'t T;
    type IntoIter = std::slice::Iter<'t, T>;

    fn into_iter(self) -> std::slice::Iter<'t, T> {
        self.iter()
    }
}

impl<'t, T, Len: Copy + Into<usize> + TryFrom<usize>> IntoIterator for &'t mut Array<T, Len> {
    type Item = &'t mut T;
    type IntoIter = std::slice::IterMut<'t, T>;

    fn into_iter(self) -> std::slice::IterMut<'t, T> {
        self.iter_mut()
    }
}

impl<T, Len: Copy + Into<usize> + TryFrom<usize>> Index<Len> for Array<T, Len> {
    type Output = T;

    fn index(&self, index: Len) -> &Self::Output {
        &self.deref()[index.into()]
    }
}

impl<T, Len: Copy + Into<usize> + TryFrom<usize>> IndexMut<Len> for Array<T, Len> {
    fn index_mut(&mut self, index: Len) -> &mut Self::Output {
        &mut self.deref_mut()[index.into()]
    }
}

/// `Default` does not always make sense for `Array`. This is an opt-in feature in case it is needed.
///
/// The resulting `Array` is rather unusable, as its length is 0.
#[cfg(feature = "default-derive")]
impl<T: Default, Len: Copy + Into<usize> + TryFrom<usize>> Default for Array<T, Len>
where
    <Len as TryFrom<usize>>::Error: Debug,
{
    fn default() -> Self {
        Self {
            ptr: NonNull::dangling(),
            len: 0.try_into().unwrap(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::Array;

    #[cfg(feature = "packed")]
    #[test]
    fn packed() {
        assert_eq!(std::mem::size_of::<Array<usize, u8>>(), 9);
    }

    #[cfg(not(feature = "packed"))]
    #[test]
    fn not_packed() {
        assert_eq!(std::mem::size_of::<Array<usize, u8>>(), 16);
    }

    #[cfg(feature = "default-derive")]
    #[test]
    fn default() {
        let arr = Array::<u8, u8>::default();
        assert_eq!(arr.len(), 0);
    }
}