pub mod vec {
    use std::{alloc::Layout, fmt::Display};

    pub struct MyVec<T: Display> {
        ptr: *mut T,
        len: usize,
        cap: usize,
    }

    impl<T: Display> MyVec<T> {
        pub fn new() -> MyVec<T> {
            let mut vec = MyVec {
                ptr: std::ptr::null_mut(),
                cap: 1,
                len: 0,
            };
            vec.ptr = Self::alloc(vec.cap);
            vec
        }

        pub fn push(&mut self, value: T) {
            if self.len == self.cap {
                self.realloc()
            }
            unsafe { *self.ptr.add(self.len) = value }
            self.len += 1;
        }

        pub fn pop(&mut self) -> Option<T> {
            if self.len == 0 {
                None
            } else {
                self.len -= 1;
                let res = unsafe { std::ptr::read(self.ptr.add(self.len)) };
                Some(res)
            }
        }

        pub fn get(&self, idx: usize) -> Option<&T> {
            if idx >= self.len {
                None
            } else {
                unsafe { self.ptr.add(idx).as_ref() }
            }
        }

        pub fn len(&self) -> usize {
            self.len
        }

        pub fn cap(&self) -> usize {
            self.cap
        }

        fn alloc(sz: usize) -> *mut T {
            unsafe { std::alloc::alloc(Self::layout(sz)) as *mut T }
        }

        fn memcpy(from: *mut T, to: *mut T, sz: usize) {
            unsafe { from.copy_to_nonoverlapping(to, sz) }
        }

        fn realloc(&mut self) {
            let (old_ptr, old_cap) = (self.ptr, self.cap);
            self.cap = old_cap * 2;
            self.ptr = Self::alloc(self.cap);
            Self::memcpy(old_ptr as *mut T, self.ptr as *mut T, old_cap);
            unsafe { old_ptr.drop_in_place() }
        }

        fn layout(capacity: usize) -> Layout {
            Layout::array::<T>(capacity).unwrap()
        }
    }

    impl<T: Display> Drop for MyVec<T> {
        fn drop(&mut self) {
            unsafe { self.ptr.drop_in_place() }
        }
    }

    impl<T: Display> Display for MyVec<T> {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            f.write_str("[ ")?;
            for i in 0..self.len {
                write!(f, "{},", self.get(i).unwrap())?;
            }
            f.write_str(" ]")?;
            Ok(())
        }
    }
}

fn main() {
    let mut vector = vec::MyVec::new();
    for value in 0..8 {
        vector.push(value);
        println!(
            "Pushed {value}, Vec after: {{l={}, c={}}} {}",
            vector.len(),
            vector.cap(),
            vector
        );
    }
    for _ in 0..8 {
        let value = vector.pop().unwrap();
        println!(
            "Popped {value}, Vec after: {{l={}, c={}}} {}",
            vector.len(),
            vector.cap(),
            vector
        );
    }
    drop(vector)
}

/*
OUTPUT:
Pushed 0, Vec after: {l=1, c=1} [ 0, ]
Pushed 1, Vec after: {l=2, c=2} [ 0,1, ]
Pushed 2, Vec after: {l=3, c=4} [ 0,1,2, ]
Pushed 3, Vec after: {l=4, c=4} [ 0,1,2,3, ]
Pushed 4, Vec after: {l=5, c=8} [ 0,1,2,3,4, ]
Pushed 5, Vec after: {l=6, c=8} [ 0,1,2,3,4,5, ]
Pushed 6, Vec after: {l=7, c=8} [ 0,1,2,3,4,5,6, ]
Pushed 7, Vec after: {l=8, c=8} [ 0,1,2,3,4,5,6,7, ]
Popped 7, Vec after: {l=7, c=8} [ 0,1,2,3,4,5,6, ]
Popped 6, Vec after: {l=6, c=8} [ 0,1,2,3,4,5, ]
Popped 5, Vec after: {l=5, c=8} [ 0,1,2,3,4, ]
Popped 4, Vec after: {l=4, c=8} [ 0,1,2,3, ]
Popped 3, Vec after: {l=3, c=8} [ 0,1,2, ]
Popped 2, Vec after: {l=2, c=8} [ 0,1, ]
Popped 1, Vec after: {l=1, c=8} [ 0, ]
Popped 0, Vec after: {l=0, c=8} [  ]
*/