use std::{
    alloc::{alloc_zeroed, Layout},
    cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd},
    convert::{TryFrom, TryInto},
    fmt,
    fmt::{Debug, Formatter},
    ops::{Deref, DerefMut, Index, IndexMut},
    ptr::NonNull,
    slice::SliceIndex,
};

/// 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();
///
/// assert_ne!(arr2[3], 4);
/// arr[2] = 4;
/// arr[4] = 0xdead;
/// arr2[3] = 4;
/// assert_eq!(arr[2], 4);
///
/// // can be sliced
/// assert_eq!(arr[2..5], [4u32, 0, 0xdead]);
///
/// // can also be freely iterated
/// for x in arr.iter_mut() {
///     *x += 1;
/// }
///
/// assert_eq!(arr[2], 5);
///
/// ```
#[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: NonNull::new(raw).unwrap(),
            len,
        }
    }

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

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

    /// 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>
where
    <Len as TryFrom<usize>>::Error: Debug,
{
    fn clone(&self) -> Self {
        let mut other = Vec::with_capacity(self.len.into());
        for x in self.iter().cloned() {
            other.push(x);
        }

        let boxed = other.into_boxed_slice();
        let vec = Vec::from(boxed);

        Self::from_vec(vec)
    }
}

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> Eq for Array<T, Len>
where
    T: Eq,
    Len: Copy + Into<usize> + TryFrom<usize>,
{
}

impl<T, Len> PartialEq for Array<T, Len>
where
    T: PartialEq<T>,
    Len: Copy + Into<usize> + TryFrom<usize>,
{
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self[..] == other[..]
    }
    #[inline]
    fn ne(&self, other: &Self) -> bool {
        self[..] != other[..]
    }
}

impl<T, Len, U> PartialEq<[U]> for Array<T, Len>
where
    T: PartialEq<U>,
    Len: Copy + Into<usize> + TryFrom<usize>,
{
    #[inline]
    fn eq(&self, other: &[U]) -> bool {
        self[..] == other[..]
    }
    #[inline]
    fn ne(&self, other: &[U]) -> bool {
        self[..] != other[..]
    }
}

impl<T, Len, U, const N: usize> PartialEq<[U; N]> for Array<T, Len>
where
    T: PartialEq<U>,
    Len: Copy + Into<usize> + TryFrom<usize>,
{
    #[inline]
    fn eq(&self, other: &[U; N]) -> bool {
        self[..] == other[..]
    }
    #[inline]
    fn ne(&self, other: &[U; N]) -> bool {
        self[..] != other[..]
    }
}

impl<T, Len> Ord for Array<T, Len>
where
    T: Ord,
    Len: Copy + Into<usize> + TryFrom<usize>,
{
    #[inline]
    fn cmp(&self, other: &Self) -> Ordering {
        Ord::cmp(&**self, &**other)
    }
}

impl<T, Len> PartialOrd for Array<T, Len>
where
    T: Ord,
    Len: Copy + Into<usize> + TryFrom<usize>,
{
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        PartialOrd::partial_cmp(&**self, &**other)
    }
}

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

    #[inline]
    fn index(&self, index: I) -> &Self::Output {
        Index::index(&**self, index)
    }
}

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

/// `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);
    }
}