#![deny(unused_imports)]

use core::{
    clone::Clone,
    cmp::PartialEq,
    fmt,
    iter::{IntoIterator, Iterator},
    marker::Sized,
    ops::Range,
};

use crate::{
    input::{Character, Input, InputIter},
    mode::{Check, Emit, Mode},
};

pub mod input;
pub mod mode;

pub type Span = Range<usize>;

pub type ParserOk<I, O> = (InputIter<I>, O);

pub type ParserResult<I, O, OM = Emit, EM = Emit> =
    Result<ParserOk<I, <OM as Mode>::Output<O>>, <EM as Mode>::Output<InputIter<I>>>;

pub trait Trace<I: Input> {
    fn trace(parser: &str, input: InputIter<I>);
}

pub struct DebugTracer;

impl<I> Trace<I> for DebugTracer
where
    I: Input + fmt::Debug,
{
    fn trace(parser: &str, input: InputIter<I>) {
        eprintln!("{}:{:?}", parser, input)
    }
}

impl<I> Trace<I> for ()
where
    I: Input,
{
    fn trace(_: &str, _: InputIter<I>) {}
}

#[derive(Debug)]
pub enum ParserFinishedError<I: Input> {
    Err(InputIter<I>),
    Unfinished(InputIter<I>),
}

pub trait Parser<I: Input>: Sized {
    type Output;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM>;

    fn parse(&self, it: InputIter<I>) -> ParserResult<I, Self::Output> {
        self.run::<Emit, Emit, ()>(it)
    }

    fn check(&self, it: InputIter<I>) -> ParserResult<I, Self::Output, Check, Emit> {
        self.run::<Check, Emit, ()>(it)
    }

    fn trace<T: Trace<I>>(&self, it: InputIter<I>) -> ParserResult<I, Self::Output> {
        self.run::<Emit, Emit, T>(it)
    }

    fn parse_finished(&self, it: InputIter<I>) -> Result<Self::Output, ParserFinishedError<I>> {
        match self.parse(it) {
            Ok((rest, output)) if rest.is_finished() => Ok(output),
            Ok((rest, _)) => Err(ParserFinishedError::Unfinished(rest)),
            Err(rest) => Err(ParserFinishedError::Err(rest)),
        }
    }

    fn check_finished(&self, it: InputIter<I>) -> Result<(), ParserFinishedError<I>> {
        match self.parse(it) {
            Ok((rest, _)) if rest.is_finished() => Ok(()),
            Ok((rest, _)) => Err(ParserFinishedError::Unfinished(rest)),
            Err(rest) => Err(ParserFinishedError::Err(rest)),
        }
    }

    fn map<F, O>(self, f: F) -> impl Parser<I, Output = O>
    where
        F: Fn(Self::Output) -> O,
    {
        Map { parser: self, f }
    }

    fn and<P>(self, right: P) -> impl Parser<I, Output = (Self::Output, P::Output)>
    where
        P: Parser<I>,
    {
        And { left: self, right }
    }

    fn or<P, O>(self, right: P) -> impl Parser<I, Output = O>
    where
        Self: Parser<I, Output = O>,
        P: Parser<I, Output = O>,
    {
        Or { left: self, right }
    }

    fn and_not<P>(self, not: P) -> impl Parser<I, Output = Self::Output>
    where
        P: Parser<I>,
    {
        AndNot { parser: self, not }
    }

    fn preceded_by<P>(self, preceded: P) -> impl Parser<I, Output = Self::Output>
    where
        P: Parser<I>,
    {
        PrecededBy {
            parser: self,
            preceded,
        }
    }

    fn followed_by<P>(self, followed: P) -> impl Parser<I, Output = Self::Output>
    where
        P: Parser<I>,
    {
        FollowedBy {
            parser: self,
            followed,
        }
    }

    fn delimited_by<P1, P2>(self, left: P1, right: P2) -> impl Parser<I, Output = Self::Output>
    where
        P1: Parser<I>,
        P2: Parser<I>,
    {
        DelimitedBy {
            parser: self,
            left,
            right,
        }
    }

    fn recognize(self) -> impl Parser<I, Output = I> {
        Recognize { parser: self }
    }

    fn verify_input<C>(self, checker: C) -> impl Parser<I, Output = Self::Output>
    where
        C: Parser<I>,
    {
        VerifyInput {
            parser: self,
            checker,
        }
    }

    fn verify_output<F>(self, checker: F) -> impl Parser<I, Output = Self::Output>
    where
        F: Fn(&Self::Output) -> bool,
    {
        VerifyOutput {
            parser: self,
            checker,
        }
    }

    fn ignore(self) -> impl Parser<I, Output = ()> {
        Ignore { parser: self }
    }

    fn opt(self) -> impl Parser<I, Output = Option<Self::Output>> {
        Opt { parser: self }
    }

    fn not(self) -> impl Parser<I, Output = ()> {
        Not { parser: self }
    }

    fn repeated(self) -> impl ParserIter<I, Item = Self::Output> {
        Repeated { parser: self }
    }

    fn separated_by<P>(self, delimiter: P) -> impl ParserIter<I, Item = Self::Output>
    where
        P: Parser<I>,
    {
        SeparatedBy {
            parser: self,
            delimiter,
        }
    }

    fn find(self) -> impl ParserIter<I, Item = Self::Output> {
        Find { parser: self }
    }
}

pub trait ParserIter<I: Input> {
    type Item;

    fn next<OM: Mode, EM: Mode>(
        &self,
        it: InputIter<I>,
    ) -> Option<ParserResult<I, Self::Item, OM, EM>>;

    fn many(self) -> impl Parser<I, Output = Vec<Self::Item>>
    where
        Self: Sized,
    {
        Many { parser: self }
    }

    fn at_least(self, count: usize) -> impl Parser<I, Output = Vec<Self::Item>>
    where
        Self: Sized,
    {
        AtLeast {
            parser: self,
            count,
        }
    }

    fn at_most(self, count: usize) -> impl Parser<I, Output = Vec<Self::Item>>
    where
        Self: Sized,
    {
        AtMost {
            parser: self,
            count,
        }
    }
}

struct Repeated<P> {
    parser: P,
}

impl<I, P> ParserIter<I> for Repeated<P>
where
    I: Input,
    P: Parser<I>,
{
    type Item = P::Output;

    fn next<OM: Mode, EM: Mode>(
        &self,
        it: InputIter<I>,
    ) -> Option<ParserResult<I, Self::Item, OM, EM>> {
        if it.is_finished() {
            None
        } else {
            match self.parser.run::<OM, EM, ()>(it) {
                Ok((rest, output)) => Some(Ok((rest, output))),
                Err(rest) => Some(Err(rest)),
            }
        }
    }
}

struct SeparatedBy<P1, P2> {
    parser: P1,
    delimiter: P2,
}

impl<I, P1, P2> ParserIter<I> for SeparatedBy<P1, P2>
where
    I: Input,
    P1: Parser<I>,
    P2: Parser<I>,
{
    type Item = P1::Output;

    fn next<OM: Mode, EM: Mode>(
        &self,
        it: InputIter<I>,
    ) -> Option<ParserResult<I, Self::Item, OM, EM>> {
        if it.is_finished() {
            None
        } else {
            let (rest, output) = match self.parser.run::<OM, EM, ()>(it) {
                Ok((rest, output)) => (rest, output),
                Err(rest) => return Some(Err(rest)),
            };

            let rest = match self.delimiter.check(rest.clone()) {
                Ok((rest, _)) => rest,
                _ => rest,
            };

            Some(Ok((rest, output)))
        }
    }
}

struct AtLeast<P> {
    parser: P,
    count: usize,
}

impl<I, P> Parser<I> for AtLeast<P>
where
    I: Input,
    P: ParserIter<I>,
{
    type Output = Vec<P::Item>;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        mut it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        let mut outputs = OM::bind(|| Vec::new());
        let mut i = 0;

        while !it.is_finished() {
            it = match self.parser.next::<OM, EM>(it.clone()) {
                Some(Ok((rest, output))) => {
                    outputs = OM::combine(outputs, output, |mut acc, e| {
                        acc.push(e);
                        acc
                    });
                    rest
                }
                Some(Err(_)) if i >= self.count => break,
                Some(Err(rest)) => return Err(rest),
                None if i >= self.count => break,
                None => return Err(EM::bind(|| it)),
            };

            i += 1;
        }

        if i >= self.count {
            Ok((it, outputs))
        } else {
            Err(EM::bind(|| it))
        }
    }
}

struct AtMost<P> {
    parser: P,
    count: usize,
}

impl<I, P> Parser<I> for AtMost<P>
where
    I: Input,
    P: ParserIter<I>,
{
    type Output = Vec<P::Item>;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        mut it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        let mut outputs = OM::bind(|| Vec::new());

        for _ in 0..self.count {
            it = match self.parser.next::<OM, EM>(it.clone()) {
                Some(Ok((rest, output))) => {
                    outputs = OM::combine(outputs, output, |mut acc, e| {
                        acc.push(e);
                        acc
                    });
                    rest
                }
                _ => break,
            }
        }

        Ok((it, outputs))
    }
}

struct Many<P> {
    parser: P,
}

impl<I, P> Parser<I> for Many<P>
where
    I: Input,
    P: ParserIter<I>,
{
    type Output = Vec<P::Item>;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        mut it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        let mut outputs = OM::bind(|| Vec::new());

        while !it.is_finished() {
            it = match self.parser.next::<OM, EM>(it.clone()) {
                Some(Ok((rest, output))) => {
                    outputs = OM::combine(outputs, output, |mut acc, e| {
                        acc.push(e);
                        acc
                    });
                    rest
                }
                _ => break,
            };
        }

        Ok((it, outputs))
    }
}

impl<I, O, F> Parser<I> for F
where
    I: Input,
    F: Fn(InputIter<I>) -> Result<ParserOk<I, O>, InputIter<I>>,
{
    type Output = O;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        Tracer::trace("fn", it.clone());

        match self(it) {
            Ok((rest, output)) => Ok((rest, OM::bind(|| output))),
            Err(rest) => Err(EM::bind(|| rest)),
        }
    }
}

struct Map<P, F> {
    parser: P,
    f: F,
}

impl<I, P, F, O> Parser<I> for Map<P, F>
where
    I: Input,
    P: Parser<I>,
    F: Fn(P::Output) -> O,
{
    type Output = O;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        match self.parser.run::<OM, EM, Tracer>(it) {
            Ok((rest, output)) => Ok((rest, OM::map(output, |o| (self.f)(o)))),
            Err(rest) => Err(rest),
        }
    }
}

struct And<P1, P2> {
    left: P1,
    right: P2,
}

impl<I, P1, P2> Parser<I> for And<P1, P2>
where
    I: Input,
    P1: Parser<I>,
    P2: Parser<I>,
{
    type Output = (P1::Output, P2::Output);

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        Tracer::trace("and", it.clone());

        let (rest, o1) = match self.left.run::<OM, EM, Tracer>(it) {
            Ok((rest, output)) => (rest, output),
            Err(rest) => return Err(rest),
        };

        let (rest, o2) = match self.right.run::<OM, EM, Tracer>(rest) {
            Ok((rest, output)) => (rest, output),
            Err(rest) => return Err(rest),
        };

        Ok((rest, OM::combine(o1, o2, |o1, o2| (o1, o2))))
    }
}

struct AndNot<P1, P2> {
    parser: P1,
    not: P2,
}

impl<I, P1, P2> Parser<I> for AndNot<P1, P2>
where
    I: Input,
    P1: Parser<I>,
    P2: Parser<I>,
{
    type Output = P1::Output;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        Tracer::trace("andnot", it.clone());

        match self.not.run::<Check, Check, Tracer>(it.clone()) {
            Ok(_) => return Err(EM::bind(|| it.clone())),
            _ => (),
        };

        self.parser.run::<OM, EM, Tracer>(it)
    }
}

struct Or<P1, P2> {
    left: P1,
    right: P2,
}

impl<I, P1, P2, O> Parser<I> for Or<P1, P2>
where
    I: Input,
    P1: Parser<I, Output = O>,
    P2: Parser<I, Output = O>,
{
    type Output = O;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        Tracer::trace("or", it.clone());

        if let Ok((rest, output)) = self.left.run::<OM, EM, Tracer>(it.clone()) {
            return Ok((rest, output));
        };

        if let Ok((rest, output)) = self.right.run::<OM, EM, Tracer>(it.clone()) {
            return Ok((rest, output));
        };

        Err(EM::bind(|| it))
    }
}

pub struct Take {
    amt: usize,
}

impl<I> Parser<I> for Take
where
    I: Input,
{
    type Output = I;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        mut it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        Tracer::trace("take", it.clone());

        let start = it.clone();

        for _ in 0..self.amt {
            match it.next() {
                Some(_) => continue,
                None => return Err(EM::bind(|| it)),
            }
        }

        Ok((
            it.clone(),
            OM::bind(|| it.input.slice(start.position()..it.position())),
        ))
    }
}

pub fn take<I>(amt: usize) -> impl Parser<I, Output = I>
where
    I: Input,
{
    Take { amt }
}

pub struct OneOf<It> {
    it: It,
}

impl<I, It> Parser<I> for OneOf<It>
where
    I: Input,
    I::Item: PartialEq<It::Item>,
    It: IntoIterator + Clone,
{
    type Output = I::Item;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        mut it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        Tracer::trace("oneof", it.clone());

        let start = it.clone();

        match it.next() {
            Some((_, item)) if self.it.clone().into_iter().any(|i| item == i) => {
                Ok((it, OM::bind(|| item)))
            }
            _ => Err(EM::bind(|| start)),
        }
    }
}

pub fn one_of<I, It>(it: It) -> impl Parser<I, Output = I::Item>
where
    I: Input,
    I::Item: PartialEq<It::Item>,
    It: IntoIterator + Clone,
{
    OneOf { it }
}

pub struct If<F> {
    f: F,
}

impl<I, F> Parser<I> for If<F>
where
    I: Input,
    F: Fn(&I::Item) -> bool,
{
    type Output = I::Item;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        mut it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        Tracer::trace("if", it.clone());

        match it.next() {
            Some((_, output)) if (self.f)(&output) => Ok((it, OM::bind(|| output))),
            _ => Err(EM::bind(|| it)),
        }
    }
}

pub fn r#if<I, F>(f: F) -> impl Parser<I, Output = I::Item>
where
    I: Input,
    F: Fn(&I::Item) -> bool,
{
    If { f }
}

struct PrecededBy<P1, P2> {
    parser: P1,
    preceded: P2,
}

impl<I, P1, P2> Parser<I> for PrecededBy<P1, P2>
where
    I: Input,
    P1: Parser<I>,
    P2: Parser<I>,
{
    type Output = P1::Output;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        Tracer::trace("preceded by", it.clone());

        let rest = match self.preceded.check(it.clone()) {
            Ok((rest, _)) => rest,
            Err(_) => return Err(EM::bind(|| it)),
        };

        self.parser.run::<OM, EM, Tracer>(rest)
    }
}

pub struct FollowedBy<P1, P2> {
    parser: P1,
    followed: P2,
}

impl<I, P1, P2> Parser<I> for FollowedBy<P1, P2>
where
    I: Input,
    P1: Parser<I>,
    P2: Parser<I>,
{
    type Output = P1::Output;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        Tracer::trace("followed by", it.clone());

        let (rest, output) = match self.parser.run::<OM, EM, Tracer>(it) {
            Ok((rest, output)) => (rest, output),
            Err(rest) => return Err(rest),
        };

        let Ok((rest, _)) = self.followed.check(rest.clone()) else {
            return Err(EM::bind(|| rest.clone()));
        };

        Ok((rest, output))
    }
}

struct DelimitedBy<P1, P2, P3> {
    parser: P1,
    left: P2,
    right: P3,
}

impl<I, P1, P2, P3> Parser<I> for DelimitedBy<P1, P2, P3>
where
    I: Input,
    P1: Parser<I>,
    P2: Parser<I>,
    P3: Parser<I>,
{
    type Output = P1::Output;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        Tracer::trace("delimited by", it.clone());

        let rest = match self.left.check(it.clone()) {
            Ok((rest, _)) => rest,
            Err(_) => return Err(EM::bind(|| it)),
        };

        let (rest, output) = match self.parser.run::<OM, EM, Tracer>(rest.clone()) {
            Ok((rest, output)) => (rest, output),
            Err(rest) => return Err(rest),
        };

        let Ok((rest, _)) = self.right.check(rest.clone()) else {
            return Err(EM::bind(|| rest));
        };

        Ok((rest, output))
    }
}

struct Recognize<P> {
    parser: P,
}

impl<I, P> Parser<I> for Recognize<P>
where
    I: Input,
    P: Parser<I>,
{
    type Output = I;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        Tracer::trace("recognize", it.clone());

        let start = it.clone();

        let rest = match self.parser.check(it.clone()) {
            Ok((rest, _)) => rest,
            Err(_) => return Err(EM::bind(|| it)),
        };

        Ok((
            rest.clone(),
            OM::bind(|| it.input.slice(start.position()..rest.position())),
        ))
    }
}

struct Tag<T>(T);

impl<I, T> Parser<I> for Tag<T>
where
    I: Input + PartialEq<T>,
    T: Input,
{
    type Output = I;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        Tracer::trace("tag", it.clone());

        match take(self.0.len()).parse(it.clone()) {
            Ok((rest, output)) if output == self.0 => Ok((rest, OM::bind(|| output))),
            Ok(_) => return Err(EM::bind(|| it)),
            Err(rest) => return Err(EM::bind(|| rest)),
        }
    }
}

pub fn tag<I, T>(tag: T) -> impl Parser<I, Output = I>
where
    I: Input + PartialEq<T>,
    T: Input,
{
    Tag(tag)
}

struct Not<P> {
    parser: P,
}

impl<I, P> Parser<I> for Not<P>
where
    I: Input,
    P: Parser<I>,
{
    type Output = ();

    fn run<OM: Mode, EM: Mode, T: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        match self.parser.check(it.clone()) {
            Ok(_) => Err(EM::bind(|| it)),
            Err(_) => Ok((it, OM::bind(|| ()))),
        }
    }
}

struct Opt<P> {
    parser: P,
}

impl<I, P> Parser<I> for Opt<P>
where
    I: Input,
    P: Parser<I>,
{
    type Output = Option<P::Output>;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        match self.parser.run::<OM, EM, Tracer>(it.clone()) {
            Ok((rest, output)) => Ok((rest, OM::map(output, |o| Some(o)))),
            Err(_) => Ok((it, OM::bind(|| None))),
        }
    }
}

struct VerifyInput<P, C> {
    parser: P,
    checker: C,
}

impl<I, P, C> Parser<I> for VerifyInput<P, C>
where
    I: Input,
    P: Parser<I>,
    C: Parser<I>,
{
    type Output = P::Output;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        match self.parser.run::<Emit, Emit, Tracer>(it.clone()) {
            Ok((rest, output)) if self.checker.check(it.clone()).is_ok() => {
                Ok((rest, OM::bind(|| output)))
            }
            Err(rest) => Err(EM::bind(|| rest)),
            _ => Err(EM::bind(|| it)),
        }
    }
}

struct VerifyOutput<P, F> {
    parser: P,
    checker: F,
}

impl<I, P, F> Parser<I> for VerifyOutput<P, F>
where
    I: Input,
    P: Parser<I>,
    F: Fn(&P::Output) -> bool,
{
    type Output = P::Output;

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        match self.parser.parse(it.clone()) {
            Ok((rest, output)) if (self.checker)(&output) => Ok((rest, OM::bind(|| output))),
            Ok(_) => Err(EM::bind(|| it)),
            Err(rest) => Err(EM::bind(|| rest)),
        }
    }
}

struct Ignore<P> {
    parser: P,
}

impl<I, P> Parser<I> for Ignore<P>
where
    I: Input,
    P: Parser<I>,
{
    type Output = ();

    fn run<OM: Mode, EM: Mode, T: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        match self.parser.check(it) {
            Ok((rest, _)) => Ok((rest, OM::bind(|| ()))),
            Err(rest) => Err(EM::bind(|| rest)),
        }
    }
}

struct Eof;

impl<I> Parser<I> for Eof
where
    I: Input,
{
    type Output = ();

    fn run<OM: Mode, EM: Mode, Tracer: Trace<I>>(
        &self,
        it: InputIter<I>,
    ) -> ParserResult<I, Self::Output, OM, EM> {
        if it.is_finished() {
            Ok((it, OM::bind(|| ())))
        } else {
            Err(EM::bind(|| it))
        }
    }
}

struct Find<P> {
    parser: P,
}

impl<I, P> ParserIter<I> for Find<P>
where
    I: Input,
    P: Parser<I>,
{
    type Item = P::Output;

    fn next<OM: Mode, EM: Mode>(
        &self,
        mut it: InputIter<I>,
    ) -> Option<ParserResult<I, Self::Item, OM, EM>> {
        while !it.is_finished() {
            it = match self.parser.run::<OM, EM, ()>(it.clone()) {
                Ok((rest, output)) => return Some(Ok((rest, output))),
                Err(_) => match take(1).check(it.clone()) {
                    Ok((rest, _)) => rest,
                    Err(_) => return None,
                },
            };
        }

        None
    }
}

pub fn eof<I>() -> impl Parser<I, Output = ()>
where
    I: Input,
{
    Eof
}

pub fn alpha<I>() -> impl Parser<I, Output = I::Item>
where
    I: Input,
    I::Item: Character,
{
    r#if(|c: &I::Item| c.is_alphabetic())
}

pub fn alpha1<I>() -> impl Parser<I, Output = I>
where
    I: Input,
    I::Item: Character,
{
    r#if(|c: &I::Item| c.is_alphabetic())
        .repeated()
        .at_least(1)
        .recognize()
}

pub fn numeric<I>() -> impl Parser<I, Output = I::Item>
where
    I: Input,
    I::Item: Character,
{
    r#if(|c: &I::Item| c.is_numeric())
}

pub fn numeric1<I>() -> impl Parser<I, Output = I>
where
    I: Input,
    I::Item: Character,
{
    r#if(|c: &I::Item| c.is_numeric())
        .repeated()
        .at_least(1)
        .recognize()
}

pub fn alphanumeric<I>() -> impl Parser<I, Output = I::Item>
where
    I: Input,
    I::Item: Character,
{
    r#if(|c: &I::Item| c.is_alphanumeric())
}

pub fn alphanumeric1<I>() -> impl Parser<I, Output = I>
where
    I: Input,
    I::Item: Character,
{
    r#if(|c: &I::Item| c.is_alphanumeric())
        .repeated()
        .at_least(1)
        .recognize()
}

pub fn whitespace<I>() -> impl Parser<I, Output = I::Item>
where
    I: Input,
    I::Item: Character,
{
    r#if(|c: &I::Item| c.is_whitespace())
}

pub fn whitespace1<I>() -> impl Parser<I, Output = I>
where
    I: Input,
    I::Item: Character,
{
    r#if(|c: &I::Item| c.is_whitespace())
        .repeated()
        .at_least(1)
        .recognize()
}

pub fn any<I>() -> impl Parser<I, Output = I::Item>
where
    I: Input,
{
    r#if(|_| true)
}

#[cfg(feature = "regex")]
pub mod str {

    use super::*;

    struct Regex<'a>(&'a regex::Regex);

    impl<'src, 'regex> Parser<&'src str> for Regex<'regex> {
        type Output = &'src str;

        fn run<OM: Mode, EM: Mode, Tracer: Trace<&'src str>>(
            &self,
            it: InputIter<&'src str>,
        ) -> ParserResult<&'src str, Self::Output, OM, EM> {
            match self.0.find(it.rest()) {
                Some(m) => {
                    let output = OM::bind(|| it.rest().slice(m.range()));
                    let (rest, _) = take(m.end()).parse(it).unwrap();
                    Ok((rest, output))
                }
                None => return Err(EM::bind(|| it.clone())),
            }
        }
    }

    pub fn regex<'a>(regexp: &'a regex::Regex) -> impl Parser<&'a str, Output = &'a str> {
        Regex(regexp)
    }
}

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

    #[test]
    fn test_separated_list() {
        let input = "a b c";
        let it = InputIter::new(input);

        alpha()
            .separated_by(whitespace())
            .at_least(1)
            .check_finished(it)
            .unwrap();
    }

    #[test]
    fn test_find() {
        let input = "hello world";
        let it = InputIter::new(input);

        assert_eq!(
            alpha1().find().at_least(1).parse_finished(it).unwrap(),
            vec!["hello", "world"]
        );
    }

    #[test]
    #[cfg(feature = "regex")]
    fn test_regex_parser() {
        let it = InputIter::new("abc 123");

        match crate::str::regex(&regex::Regex::new("[a-z]+").unwrap()).parse(it) {
            Ok((rest, output)) => {
                assert_eq!(output, "abc");
                assert_eq!(rest.rest(), " 123");
            }
            _ => panic!(),
        }
    }
}