use crate::bnf::Bnf;
use std::rc::Rc;

pub type ParseResult<I, O, E> = Result<(O, I), E>;

pub trait Parser<I, O, E> {
    fn parse(&self, input: I) -> ParseResult<I, O, E>;
    fn bnf(&self) -> Option<Bnf> {
        None
    }

    fn map<'a, F, O2>(self, map_fn: F) -> BoxedParser<'a, I, O2, E>
    where
        Self: Sized + 'a,
        I: 'a,
        E: 'a,
        O: 'a,
        O2: 'a,
        F: Fn(O) -> O2 + 'a,
    {
        BoxedParser::new(crate::combinators::map(self, map_fn))
    }

    fn to<'a, O2>(self, item: O2) -> BoxedParser<'a, I, O2, E>
    where
        Self: Sized + 'a,
        I: 'a,
        O: 'a,
        O2: Clone + 'a,
        E: 'a,
    {
        self.map(move |_| item.clone())
    }

    fn then<'a, P, O2>(self, next_parser: P) -> BoxedParser<'a, I, (O, O2), E>
    where
        Self: Sized + 'a,
        I: 'a,
        O: 'a,
        O2: 'a,
        E: 'a,
        P: Parser<I, O2, E> + 'a,
    {
        BoxedParser::new(crate::sequence::tuple2(self, next_parser))
    }

    fn ignore_then<'a, P, O2>(self, next_parser: P) -> BoxedParser<'a, I, O2, E>
    where
        Self: Sized + 'a,
        I: 'a,
        O: 'a,
        O2: 'a,
        E: 'a,
        P: Parser<I, O2, E> + 'a,
    {
        BoxedParser::new(crate::sequence::tuple2(self, next_parser))
            .map(|(_, next_output)| next_output)
    }

    fn then_ignore<'a, P, O2>(self, next_parser: P) -> BoxedParser<'a, I, O, E>
    where
        Self: Sized + 'a,
        I: 'a,
        O: 'a,
        O2: 'a,
        E: 'a,
        P: Parser<I, O, E> + 'a,
    {
        BoxedParser::new(crate::sequence::tuple2(self, next_parser))
            .map(|(this_output, _)| this_output)
    }

    fn optional<'a>(self) -> BoxedParser<'a, I, Option<O>, E>
    where
        I: Clone + 'a,
        O: 'a,
        E: 'a,
        Self: Sized + 'a,
    {
        BoxedParser::new(crate::combinators::optional(self))
    }
}

pub struct BoxedParser<'a, I, O, E> {
    inner: Box<dyn Parser<I, O, E> + 'a>,
}

impl<'a, I, O, E> BoxedParser<'a, I, O, E> {
    pub(crate) fn new<P>(inner: P) -> Self
    where
        P: Parser<I, O, E> + 'a,
    {
        BoxedParser {
            inner: Box::new(inner),
        }
    }
}

impl<'a, I, O, E> Parser<I, O, E> for BoxedParser<'a, I, O, E> {
    fn parse(&self, input: I) -> ParseResult<I, O, E> {
        self.inner.parse(input)
    }
}

impl<I, O, E, F> Parser<I, O, E> for F
where
    F: Fn(I) -> ParseResult<I, O, E>,
{
    fn parse(&self, input: I) -> ParseResult<I, O, E> {
        self(input)
    }
}

impl<I, O, E, T> Parser<I, O, E> for Rc<T>
where
    T: Parser<I, O, E>,
{
    fn parse(&self, input: I) -> ParseResult<I, O, E> {
        self.as_ref().parse(input)
    }
}