use core::{mem::MaybeUninit, ptr};

#[derive(Debug)]
pub struct OutOfSpace;

pub struct BoxVec<T> {
    boxed: Box<[MaybeUninit<T>]>,
    len: usize,
}

impl<T> BoxVec<T> {
    pub fn new(size: usize) -> Self {
        let boxed = (0..size).map(|_| MaybeUninit::uninit()).collect();

        Self { boxed, len: 0 }
    }

    pub fn push(&mut self, elem: T) {
        self.try_push(elem).unwrap()
    }

    pub fn try_push(&mut self, elem: T) -> Result<(), OutOfSpace> {
        if self.len < self.boxed.len() {
            unsafe {
                self.unchecked_push(elem);
                Ok(())
            }
        } else {
            Err(OutOfSpace)
        }
    }

    pub unsafe fn unchecked_push(&mut self, elem: T) {
        let len = self.len;

        let uninit_elem = &mut self.boxed[len];
        ptr::write(uninit_elem.as_mut_ptr(), elem);

        self.set_len(len + 1);
    }

    pub unsafe fn set_len(&mut self, new_len: usize) {
        self.len = new_len;
    }
}