use super::{CharSeq, ParserResult, Parser, Succ, Fail, Error};

pub struct Many1<'a, T:'a> {
    parser: &'a (Parser<T>+'a)
}

pub fn many1<'a, T>(p: &'a (Parser<T> + 'a)) -> Many1<'a, T> {
    return Many1{parser: p};
}

impl<'a, T> Parser<Vec<T>> for Many1<'a, T> {
    #[allow(unused_variables)]
    fn _parse(&self, cs: &mut CharSeq) -> ParserResult<Vec<T>> {
        let mut succ = true;
        let mut r = Vec::new();
        while succ {
            match self.parser.parse(cs) {
                Succ(c) => r.push(c),
                Fail(m, l) => succ = false,
                Error(m, l) => return Error(m, l)
            }
        }
        if r.len() == 0 {
            return cs.fail("nothing");
        }
        return Succ(r);
    }

}

#[cfg(test)]
#[allow(unused_variables)]
#[allow(unused_imports)]
mod tests {
    use super::many1;
    use super::super::{CharSeq, ParserResult, Parser, Succ, Fail, Error};

    #[test]
    fn test_many1_1() {
        let mut cs = CharSeq::new("aaabbbccc", "<mem>");
        assert!(cs.pos == 0);
        let s = "a";
        let m = many1(&s);
        match cs.accept(&m) {
            Succ(a) => assert!(a == vec!["a", "a", "a"]),
            _ => assert!(false, "bug")
        }
        assert!(cs.pos == 3);
        assert!(cs.view() == "bbbccc");
    }

    #[test]
    fn test_many1_2() {
        let mut cs = CharSeq::new("aaabbbccc", "<mem>");
        assert!(cs.pos == 0);
        let s = "x";
        let m = many1(&s);
        match cs.accept(&m) {
            Fail(m, l) => (),
            Succ(a) => {
                let mut x = String::new();
                for i in a.iter() {
                    x.push_str(i.as_slice());
                    x.push(',');
                }
                assert!(false, format!("bug: succeded: {}", x))
            },
            Error(m, l) => assert!(false, "bug")
        }
        assert!(cs.pos == 0);
        assert!(cs.view() == "aaabbbccc");
    }
}