use std::collections::VecDeque;

pub struct LookAheadIterator<I: Iterator> {
    iter: I,
    pos: usize,
    look_ahead_count: usize,
    is_done: bool,
    look_ahead_items: VecDeque<Option<I::Item>>,
    previous: Option<I::Item>,
}

impl<I: Iterator> LookAheadIterator<I> {
    pub fn new(iter: I) -> LookAheadIterator<I> {
        LookAheadIterator {
            iter,
            pos: 0,
            look_ahead_count: 0,
            is_done: false,
            look_ahead_items: VecDeque::new(),
            previous: None,
        }
    }

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

    fn peek_n(&mut self, n: usize) -> Option<&I::Item> {
        if self.is_done && n >= self.look_ahead_count {
            None.as_ref()
        } else if self.look_ahead_count >= n {
            self.look_ahead_items.get(n - 1).unwrap().as_ref()
        } else {
            let mut item;
            let mut c = self.look_ahead_count;
            while c < n {
                item = self.iter.next();
                c += 1;

                if item.is_none() {
                    self.is_done = true;

                    return None.as_ref();
                } else {
                    self.look_ahead_count += 1;
                    self.look_ahead_items.push_back(item);
                }
            }

            self.peek_n(n)
        }
    }

    pub fn next(&mut self) -> Option<I::Item> {
        /*
        if self.pos > 0 {
            self.previous = *self.peek();
        }*/

        if self.look_ahead_count > 0 {
            self.look_ahead_count -= 1;
            self.pos += 1;
            self.look_ahead_items.pop_front().unwrap()
        } else {
            let item = self.iter.next();

            if item.is_some() {
                self.pos += 1;
            }

            item
        }
    }

    pub fn peek(&mut self) -> Option<&I::Item> {
        self.peek_n(1)
    }

    pub fn peek_next(&mut self) -> Option<&I::Item> {
        self.peek_n(2)
    }
}

fn main() {

}