use crate::{
    representation::{Representation, EBNF},
    ParseResult, Parser, ParserExtension,
};

pub fn sequence<S, I, O, E>(sequence: S) -> impl Parser<I, O, E>
where
    S: Sequence<I, O, E>,
{
    let repr = sequence.repr();

    (move |input| -> ParseResult<I, O, E> { sequence.parse(input) })
        .to_anno()
        .with_repr(repr)
}

pub fn surrounded_by<I, O1, O2, E>(
    main: impl Parser<I, O1, E>,
    surrounding: impl Parser<I, O2, E>,
) -> impl Parser<I, O1, E> {
    let s_prod = surrounding.representation().production();
    let main_prod = main.representation().production();

    (move |input| {
        let (_result1, rest1) = surrounding.parse(input)?;
        let (result2, rest2) = main.parse(rest1)?;
        let (_result3, rest3) = surrounding.parse(rest2)?;
        Ok((result2, rest3))
    })
    .to_anno()
    .with_repr(Representation::new().with_production(EBNF::Sequence(vec![
        s_prod.clone(),
        main_prod,
        s_prod,
    ])))
}

pub fn seq2<I, O1, O2, E>(
    first: impl Parser<I, O1, E>,
    second: impl Parser<I, O2, E>,
) -> impl Parser<I, (O1, O2), E> {
    sequence((first, second))
}

pub trait Sequence<I, O, E> {
    fn parse(&self, input: I) -> ParseResult<I, O, E>;
    fn repr(&self) -> Representation;
}

impl<P1, P2, I, O1, O2, E> Sequence<I, (O1, O2), E> for (P1, P2)
where
    P1: Parser<I, O1, E>,
    P2: Parser<I, O2, E>,
{
    fn parse(&self, input: I) -> ParseResult<I, (O1, O2), E> {
        let p1 = &self.0;
        let p2 = &self.1;
        p1.parse(input).and_then(|(result1, rest)| {
            p2.parse(rest)
                .map(|(result2, rest2)| ((result1, result2), rest2))
        })
    }

    fn repr(&self) -> Representation {
        let p1 = &self.0;
        let p2 = &self.1;
        Representation::new().with_production(EBNF::Sequence(vec![
            p1.representation().production(),
            p2.representation().production(),
        ]))
    }
}

impl<P1, P2, P3, I, O1, O2, O3, E> Sequence<I, (O1, O2, O3), E> for (P1, P2, P3)
where
    P1: Parser<I, O1, E>,
    P2: Parser<I, O2, E>,
    P3: Parser<I, O3, E>,
{
    fn parse(&self, input: I) -> ParseResult<I, (O1, O2, O3), E> {
        let p1 = &self.0;
        let p2 = &self.1;
        let p3 = &self.2;

        let (result1, rest1) = p1.parse(input)?;
        let (result2, rest2) = p2.parse(rest1)?;
        let (result3, rest3) = p3.parse(rest2)?;

        Ok(((result1, result2, result3), rest3))
    }

    fn repr(&self) -> Representation {
        let p1 = &self.0;
        let p2 = &self.1;
        let p3 = &self.2;
        Representation::new().with_production(EBNF::Sequence(vec![
            p1.representation().production(),
            p2.representation().production(),
            p3.representation().production(),
        ]))
    }
}