use std::mem::{transmute, MaybeUninit};
use std::ops::{Deref, DerefMut};

#[derive(Debug)]
pub struct ArrayVec<Item, const CAPACITY: usize>
{
    items: [MaybeUninit<Item>; CAPACITY],
    len: usize,
}

impl<Item, const CAPACITY: usize> ArrayVec<Item, CAPACITY>
{
    pub fn new() -> Self
    {
        Self::default()
    }

    #[inline]
    #[must_use]
    pub fn len(&self) -> usize
    {
        self.len
    }

    pub fn push(&mut self, item: Item)
    {
        assert!(self.len < CAPACITY);

        self.items[self.len].write(item);

        self.len += 1;
    }

    pub fn insert(&mut self, index: usize, item: Item)
    {
        assert!(index <= self.len);
        assert!(self.len < CAPACITY);

        if index == self.len {
            self.push(item);
            return;
        }

        unsafe {
            std::ptr::copy(
                &self.items[index],
                &mut self.items[index + 1],
                self.len - index,
            );
        }

        self.items[index].write(item);

        self.len += 1;
    }
}

impl<Item, const CAPACITY: usize> Extend<Item> for ArrayVec<Item, CAPACITY>
{
    fn extend<IntoIter: IntoIterator<Item = Item>>(&mut self, iter: IntoIter)
    {
        for item in iter {
            self.push(item);
        }
    }
}

impl<Item, const CAPACITY: usize> AsRef<[Item]> for ArrayVec<Item, CAPACITY>
{
    fn as_ref(&self) -> &[Item]
    {
        unsafe { transmute::<&[MaybeUninit<Item>], &[Item]>(&self.items[..self.len]) }
    }
}

impl<Item, const CAPACITY: usize> AsMut<[Item]> for ArrayVec<Item, CAPACITY>
{
    fn as_mut(&mut self) -> &mut [Item]
    {
        unsafe {
            transmute::<&mut [MaybeUninit<Item>], &mut [Item]>(
                &mut self.items[..self.len],
            )
        }
    }
}

impl<Item, const CAPACITY: usize> Deref for ArrayVec<Item, CAPACITY>
{
    type Target = [Item];

    fn deref(&self) -> &Self::Target
    {
        self.as_ref()
    }
}

impl<Item, const CAPACITY: usize> DerefMut for ArrayVec<Item, CAPACITY>
{
    fn deref_mut(&mut self) -> &mut Self::Target
    {
        self.as_mut()
    }
}

impl<Item, const CAPACITY: usize> Default for ArrayVec<Item, CAPACITY>
{
    fn default() -> Self
    {
        Self {
            items: [const { MaybeUninit::uninit() }; CAPACITY],
            len: 0,
        }
    }
}