use crate::base::Base;
use crate::pattern::Pattern;
use crate::pattern::PatternItem;
use crate::rna::Rna;
use crate::template::Template;
use crate::template::TemplateItem;
use std::mem;

pub struct Parser<I>
where
    I: Iterator<Item = Base>,
{
    iter: I,
    peeked: Vec<Base>,
    index: usize,
}

impl<I> Parser<I>
where
    I: Iterator<Item = Base>,
{
    pub fn new(iter: I) -> Parser<I> {
        Parser {
            iter: iter,
            peeked: Vec::new(),
            index: 0,
        }
    }

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

    fn peek_to(&mut self, n: usize) {
        while self.peeked.len() < n {
            if let Some(b) = self.iter.next() {
                self.peeked.push(b);
            } else {
                return;
            }
        }
    }

    pub fn next_is(&mut self, next: &[Base]) -> bool {
        self.peek_to(next.len());
        if self.peeked.len() < next.len() {
            return false;
        }
        return &self.peeked[..next.len()] == next;
    }

    pub fn advance(&mut self, n: usize) {
        self.peek_to(n);
        self.index += n;
        self.peeked.drain(..n);
    }

    pub fn nat(&mut self) -> Option<usize> {
        let mut ret = 0;
        let mut bit = 1;
        loop {
            if self.next_is(&[Base::P]) {
                self.advance(1);
                return Some(ret);
            } else if self.next_is(&[Base::I]) || self.next_is(&[Base::F]) {
                self.advance(1);
            } else if self.next_is(&[Base::C]) {
                ret += bit;
                self.advance(1);
            } else {
                return None;
            }

            bit *= 2;
        }
    }

    pub fn consts(&mut self) -> Vec<Base> {
        let mut ret = Vec::new();
        loop {
            if self.next_is(&[Base::C]) {
                self.advance(1);
                ret.push(Base::I);
            } else if self.next_is(&[Base::F]) {
                self.advance(1);
                ret.push(Base::C);
            } else if self.next_is(&[Base::P]) {
                self.advance(1);
                ret.push(Base::F);
            } else if self.next_is(&[Base::I, Base::C]) {
                self.advance(2);
                ret.push(Base::P);
            } else {
                return ret;
            }
        }
    }

    pub fn pattern(&mut self, rna: &mut Vec<Rna>) -> Option<Pattern> {
        let mut ret = Vec::new();
        let mut level = 0;
        loop {
            if self.next_is(&[Base::C]) {
                self.advance(1);
                ret.push(PatternItem::Base(Base::I));
            } else if self.next_is(&[Base::F]) {
                self.advance(1);
                ret.push(PatternItem::Base(Base::C));
            } else if self.next_is(&[Base::P]) {
                self.advance(1);
                ret.push(PatternItem::Base(Base::F));
            } else if self.next_is(&[Base::I, Base::C]) {
                self.advance(2);
                ret.push(PatternItem::Base(Base::P));
            } else if self.next_is(&[Base::I, Base::P]) {
                self.advance(2);
                let n = self.nat()?;
                ret.push(PatternItem::Skip(n));
            } else if self.next_is(&[Base::I, Base::F]) {
                self.advance(3);
                let s = self.consts();
                ret.push(PatternItem::Search(s));
            } else if self.next_is(&[Base::I, Base::I, Base::P]) {
                self.advance(3);
                level += 1;
                ret.push(PatternItem::Open);
            } else if self.next_is(&[Base::I, Base::I, Base::C])
                || self.next_is(&[Base::I, Base::I, Base::F])
            {
                self.advance(3);
                if level == 0 {
                    return Some(Pattern::new(ret));
                }
                level -= 1;
                ret.push(PatternItem::Close);
            } else if self.next_is(&[Base::I, Base::I, Base::I]) {
                self.advance(3);
                self.peek_to(7);
                let mut r = Vec::new();
                mem::swap(&mut r, &mut self.peeked);
                rna.push(r.try_into().unwrap());
                self.index += 7;
            } else {
                return None;
            }
        }
    }

    pub fn template(&mut self, rna: &mut Vec<Rna>) -> Option<Template> {
        let mut ret = Vec::new();
        loop {
            if self.next_is(&[Base::C]) {
                self.advance(1);
                ret.push(TemplateItem::Base(Base::I));
            } else if self.next_is(&[Base::F]) {
                self.advance(1);
                ret.push(TemplateItem::Base(Base::C));
            } else if self.next_is(&[Base::P]) {
                self.advance(1);
                ret.push(TemplateItem::Base(Base::F));
            } else if self.next_is(&[Base::I, Base::C]) {
                self.advance(2);
                ret.push(TemplateItem::Base(Base::P));
            } else if self.next_is(&[Base::I, Base::P]) || self.next_is(&[Base::I, Base::F]) {
                self.advance(2);
                let l = self.nat()?;
                let n = self.nat()?;
                ret.push(TemplateItem::Ref(n, l));
            } else if self.next_is(&[Base::I, Base::I, Base::C])
                || self.next_is(&[Base::I, Base::I, Base::F])
            {
                self.advance(3);
                return Some(Template::new(ret));
            } else if self.next_is(&[Base::I, Base::I, Base::P]) {
                self.advance(3);
                let n = self.nat()?;
                ret.push(TemplateItem::Len(n));
            } else if self.next_is(&[Base::I, Base::I, Base::I]) {
                self.advance(3);
                self.peek_to(7);
                let mut r = Vec::new();
                mem::swap(&mut r, &mut self.peeked);
                rna.push(r.try_into().unwrap());
                self.index += 7;
            } else {
                return None;
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn dna_from_str(s: &str) -> Vec<Base> {
        s.chars().filter_map(|c| Base::from_char(c)).collect()
    }

    #[test]
    fn test_base() {
        let dna = dna_from_str("ICFP").into_iter();
        let mut parser = Parser::new(dna);
        assert!(parser.next_is(&[Base::I]));
        assert!(parser.next_is(&[Base::I, Base::C]));
        assert!(parser.next_is(&[Base::I, Base::C, Base::F]));
        assert!(parser.next_is(&[Base::I, Base::C, Base::F, Base::P]));
    }

    #[test]
    fn test_nat() {
        let dna = dna_from_str("CP").into_iter();
        let mut parser = Parser::new(dna);
        assert_eq!(parser.nat(), Some(1));
        assert_eq!(parser.index, 2);

        let dna = dna_from_str("ICICP").into_iter();
        let mut parser = Parser::new(dna);
        assert_eq!(parser.nat(), Some(10));
        assert_eq!(parser.index, 5);

        let dna = dna_from_str("III").into_iter();
        let mut parser = Parser::new(dna);
        assert_eq!(parser.nat(), None);
        assert_eq!(parser.index, 3);
    }

    #[test]
    fn test_consts() {
        let dna = dna_from_str("CFPICIIC").into_iter();
        let mut parser = Parser::new(dna);
        assert_eq!(parser.consts(), &[Base::I, Base::C, Base::F, Base::P]);
        assert_eq!(parser.index, 5);
    }

    #[test]
    fn test_pattern() {
        let mut rna = Vec::new();

        let dna = dna_from_str("CIIC").into_iter();
        let mut parser = Parser::new(dna);
        assert_eq!(
            parser.pattern(&mut rna),
            Some(Pattern::new(vec![PatternItem::Base(Base::I)]))
        );
        assert_eq!(parser.index, 4);

        let dna = dna_from_str("IIPIPICPIICICIIF").into_iter();
        let mut parser = Parser::new(dna);
        assert_eq!(
            parser.pattern(&mut rna),
            Some(Pattern::new(vec![
                PatternItem::Open,
                PatternItem::Skip(2),
                PatternItem::Close,
                PatternItem::Base(Base::P)
            ]))
        );
        assert_eq!(parser.index, 16);

        let dna = dna_from_str("IIIPFCICFPIIC").into_iter();
        let mut parser = Parser::new(dna);
        assert_eq!(parser.pattern(&mut rna), Some(Pattern::new(vec![])));
        assert_eq!(parser.index, 13);
        assert_eq!(
            rna,
            vec![[
                Base::P,
                Base::F,
                Base::C,
                Base::I,
                Base::C,
                Base::F,
                Base::P
            ]]
        );
    }

    #[test]
    fn test_template() {
        let mut rna = Vec::new();

        let dna = dna_from_str("CFPICIFCPICPIIPIICPIIC").into_iter();
        let mut parser = Parser::new(dna);
        assert_eq!(
            parser.template(&mut rna),
            Some(Template::new(vec![
                TemplateItem::Base(Base::I),
                TemplateItem::Base(Base::C),
                TemplateItem::Base(Base::F),
                TemplateItem::Base(Base::P),
                TemplateItem::Ref(2, 1),
                TemplateItem::Len(4)
            ]))
        );
        assert_eq!(parser.index, 22);

        let dna = dna_from_str("IIIPFCICFPIIC").into_iter();
        let mut parser = Parser::new(dna);
        assert_eq!(parser.template(&mut rna), Some(Template::new(vec![])));
        assert_eq!(parser.index, 13);
        assert_eq!(
            rna,
            vec![[
                Base::P,
                Base::F,
                Base::C,
                Base::I,
                Base::C,
                Base::F,
                Base::P
            ]]
        );
    }
}