use crate::Trap;
use std::ops::{Index, IndexMut};

mod peek;
mod pop;
mod push;

pub(crate) use self::peek::Peek as StackPeek;
pub(crate) use self::pop::*;
pub(crate) use self::push::*;

pub struct Stack {
    pub data: [u8; 255],
    pub ptr: u8,
}

impl Stack {
    pub fn new() -> Self {
        Self::new_with_ptr(0)
    }

    pub fn new_with_ptr(ptr: u8) -> Self {
        Self {
            data: [0; 255],
            ptr,
        }
    }
}

impl Default for Stack {
    fn default() -> Self {
        Self {
            data: [Default::default(); 255],
            ptr: Default::default(),
        }
    }
}

impl Stack {
    pub(crate) fn push<O>(&mut self, items: O) -> Result<(), Trap>
    where
        O: Push,
    {
        items.push(self)
    }

    pub(crate) fn pop<I>(&mut self) -> Result<I, Trap>
    where
        I: Pop,
    {
        I::pop(self)
    }

    pub(crate) fn peek<I>(&mut self) -> Result<I, Trap>
    where
        I: StackPeek,
    {
        I::peek(self)
    }
}

impl Index<u8> for Stack {
    type Output = u8;

    fn index(&self, addr: u8) -> &Self::Output {
        self.data.index(addr as usize)
    }
}

impl IndexMut<u8> for Stack {
    fn index_mut(&mut self, addr: u8) -> &mut Self::Output {
        self.data.index_mut(addr as usize)
    }
}