pub trait Locatable {
    fn get_xy(&self) -> (usize, usize);
}

#[derive(Clone)]
pub struct LocatableVec<T:Locatable + Copy, const COUNT: usize> {
    arr: [Option<T>; COUNT],
    len: usize,
}

pub struct LocatableVecIter<'a, T:Locatable + Copy, const COUNT: usize> {
    vec : &'a LocatableVec<T, COUNT>,
    idx: usize,
    cnt: usize,
}

impl<T:Locatable + Copy, const COUNT: usize> LocatableVec<T, COUNT> {
    
    pub fn new() -> LocatableVec<T, COUNT> {
        LocatableVec{arr: [None; COUNT], len: 0}
    }
    
    pub fn iter(&self) -> LocatableVecIter<'_, T, COUNT>  {
        LocatableVecIter{vec: self, idx: 0, cnt: 0}
    }
    
    pub fn len(&self) -> usize {
        self.len
    }
    
    pub fn put(&mut self, value : T) {
        let (x,y) = value.get_xy();
        let idx = y * 9 + x;
        if self.arr[idx].is_none() {
            self.len += 1;
        }
        self.arr[idx] = Some(value);
    }
    
    pub fn remove(&mut self, value : &T) -> bool{
        let (x,y) = value.get_xy();
        let idx = y * 9 + x;
        if self.arr[idx].is_some() {
            self.arr[idx] = None;
            self.len -= 1;
            return true;
        }
        false
    }
    
}

impl<'a, T:Locatable + Copy, const COUNT: usize> Iterator for LocatableVecIter<'a, T, COUNT> {
    type Item = &'a T;
    
    fn next(&mut self) -> Option<Self::Item> {
        for i in self.idx..self.vec.arr.len() {
            let pos = &self.vec.arr[i];
            if pos.is_some() {
                self.idx = i + 1;
                self.cnt += 1;
                return pos.as_ref();
            }
        }
        None
    }
    
    fn size_hint(&self) -> (usize, Option<usize>) {
        (self.vec.len - self.cnt, Some(self.vec.arr.len() - self.idx))
    }
}

impl<'a, L:Locatable + Copy, const COUNT: usize> FromIterator<L> for LocatableVec<L, COUNT> {
    fn from_iter<T: IntoIterator<Item = L>>(iter: T) -> Self {

        let mut x = LocatableVec{arr: [None; COUNT], len: 0};
        for p in iter {
            x.put(p);
        }
        x
    }

}

pub struct FsVec<T: Copy + Sized + Default, const COUNT: usize> {
    arr: [T; COUNT],
    len: usize
}

pub struct FsVecIter<'a, T:Copy + Sized + Default, const COUNT: usize> {
    vec : &'a FsVec<T, COUNT>,
    idx: usize,
}


impl<T: Sized + Copy + Default, const COUNT: usize> FsVec<T, COUNT> {
    pub fn new() -> FsVec<T, COUNT> {
        FsVec{arr: [Default::default(); COUNT], len: 0}
    }

    pub fn len(&self) -> usize {
        self.len
    }
    
    pub fn append(&mut self, value : T) {
        self.arr[self.len] = value;
        self.len += 1;
    }
    
    pub fn iter(&self) -> FsVecIter<'_, T, COUNT>  {
        FsVecIter{vec: self, idx: 0}
    }

}

impl<'a, T:Sized + Copy + Default, const COUNT: usize> Iterator for FsVecIter<'a, T, COUNT> {
    type Item = &'a T;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.idx >= self.vec.len {
            return None
        }
        let result = Some(&self.vec.arr[self.idx]);
        self.idx += 1;
        result
    }
    
    fn size_hint(&self) -> (usize, Option<usize>) {
        (self.vec.len() - self.idx, Some(self.vec.len() - self.idx))
    }
}

impl<'a, L:Sized + Copy + Default, const COUNT: usize> FromIterator<L> for FsVec<L, COUNT> {
    fn from_iter<T: IntoIterator<Item = L>>(iter: T) -> Self {

        let mut x = FsVec::new();
        for elem in iter {
            x.append(elem);
        }
        x
    }

}