//! Choice combinators

#[cfg(test)]
mod tests;

use core::marker::PhantomData;

use crate::error::ErrorKind;
use crate::error::ParseError;
use crate::internal::{Err, Mode, Parser};

/// Tests a list of parsers one by one until one succeeds.
///
/// It takes as argument a tuple of parsers. There is a maximum of 21
/// parsers. If you need more, it is possible to nest them in other `alt` calls,
/// like this: `alt(parser_a, alt(parser_b, parser_c))`
///
/// ```rust
/// # use nom::error_position;
/// # use nom::{Err,error::ErrorKind, Needed, IResult, Parser};
/// use nom::character::complete::{alpha1, digit1};
/// use nom::branch::alt;
/// # fn main() {
/// fn parser(input: &str) -> IResult<&str, &str> {
///   alt((alpha1, digit1)).parse(input)
/// };
///
/// // the first parser, alpha1, recognizes the input
/// assert_eq!(parser("abc"), Ok(("", "abc")));
///
/// // the first parser returns an error, so alt tries the second one
/// assert_eq!(parser("123456"), Ok(("", "123456")));
///
/// // both parsers failed, and with the default error type, alt will return the last error
/// assert_eq!(parser(" "), Err(Err::Error(error_position!(" ", ErrorKind::Digit))));
/// # }
/// ```
///
/// With a custom error type, it is possible to have alt return the error of the parser
/// that went the farthest in the input data
pub fn alt<List>(l: List) -> Choice<List> {
  Choice { parser: l }
}

/// Applies a list of parsers in any order.
///
/// Permutation will succeed if all of the child parsers succeeded.
/// It takes as argument a tuple of parsers, and returns a
/// tuple of the parser results.
///
/// ```rust
/// # use nom::{Err,error::{Error, ErrorKind}, Needed, IResult, Parser};
/// use nom::character::complete::{alpha1, digit1};
/// use nom::branch::permutation;
/// # fn main() {
/// fn parser(input: &str) -> IResult<&str, (&str, &str)> {
///   permutation((alpha1, digit1)).parse(input)
/// }
///
/// // permutation recognizes alphabetic characters then digit
/// assert_eq!(parser("abc123"), Ok(("", ("abc", "123"))));
///
/// // but also in inverse order
/// assert_eq!(parser("123abc"), Ok(("", ("abc", "123"))));
///
/// // it will fail if one of the parsers failed
/// assert_eq!(parser("abc;"), Err(Err::Error(Error::new(";", ErrorKind::Digit))));
/// # }
/// ```
///
/// The parsers are applied greedily: if there are multiple unapplied parsers
/// that could parse the next slice of input, the first one is used.
/// ```rust
/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Parser};
/// use nom::branch::permutation;
/// use nom::character::complete::{anychar, char};
///
/// fn parser(input: &str) -> IResult<&str, (char, char)> {
///   permutation((anychar, char('a'))).parse(input)
/// }
///
/// // anychar parses 'b', then char('a') parses 'a'
/// assert_eq!(parser("ba"), Ok(("", ('b', 'a'))));
///
/// // anychar parses 'a', then char('a') fails on 'b',
/// // even though char('a') followed by anychar would succeed
/// assert_eq!(parser("ab"), Err(Err::Error(Error::new("b", ErrorKind::Char))));
/// ```
///
pub fn permutation<I: Clone, E: ParseError<I>, List>(list: List) -> Permutation<List, E> {
  Permutation {
    parser: list,
    e: PhantomData,
  }
}

macro_rules! alt_trait(
  ($first:ident $second:ident $($id: ident)+) => (
    alt_trait!(__impl $first $second; $($id)+);
  );
  (__impl $($current:ident)*; $head:ident $($id: ident)+) => (
    alt_trait_impl!($($current)*);

    alt_trait!(__impl $($current)* $head; $($id)+);
  );
  (__impl $($current:ident)*; $head:ident) => (
    alt_trait_impl!($($current)*);
    alt_trait_impl!($($current)* $head);
  );
);

/// Wrapping structure for the [alt()] combinator implementation
pub struct Choice<T> {
  parser: T,
}

macro_rules! alt_trait_impl(
  ($($id:ident)+) => (
    impl<
      Input: Clone, Output, Error: ParseError<Input>,
      $($id: Parser<Input, Output = Output, Error = Error>),+
    > Parser<Input> for Choice< ( $($id),+ )> {
      type Output = Output;
      type Error = Error;

      #[inline(always)]
      fn process<OM: crate::OutputMode>(
        &mut self,
        input: Input,
      ) -> crate::PResult<OM, Input, Self::Output, Self::Error> {
        match self.parser.0.process::<OM>(input.clone()) {
          Ok(res) => Ok(res),
          Err(Err::Failure(e))=> Err(Err::Failure(e)),
          Err(Err::Incomplete(i))=> Err(Err::Incomplete(i)),
          Err(Err::Error(e)) => alt_trait_inner!(1, self, input, e, $($id)+),
        }
      }
    }
  );
);

macro_rules! alt_trait_inner(
  ($it:tt, $self:expr, $input:expr, $err:expr, $head:ident $($id:ident)+) => (
    match $self.parser.$it.process::<OM>($input.clone()) {
      Ok(res) => Ok(res),
      Err(Err::Failure(e))=>Err(Err::Failure(e)),
      Err(Err::Incomplete(i))=> Err(Err::Incomplete(i)),
      Err(Err::Error(e)) => {
        succ!($it, alt_trait_inner!($self, $input, <OM::Error as crate::Mode>::combine($err, e, |e1, e2| e1.or(e2)), $($id)+))
      }
    }
  );
  ($it:tt, $self:expr, $input:expr, $err:expr, $head:ident) => (
    Err(Err::Error(<OM::Error as crate::Mode>::map($err, |err| Error::append($input, ErrorKind::Alt, err))))
  );
);

alt_trait!(A B C D E F G H I J K L M N O P Q R S T U);

// Manually implement Alt for (A,), the 1-tuple type
impl<Input, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>>
  Parser<Input> for Choice<(A,)>
{
  type Output = Output;
  type Error = Error;

  #[inline]
  fn process<OM: crate::OutputMode>(
    &mut self,
    input: Input,
  ) -> crate::PResult<OM, Input, Self::Output, Self::Error> {
    self.parser.0.process::<OM>(input)
  }
}

macro_rules! permutation_trait(
  (
    $name1:ident $ty1:ident $item1:ident
    $name2:ident $ty2:ident $item2:ident
    $($name3:ident $ty3:ident $item3:ident)*
  ) => (
    permutation_trait!(__impl $name1 $ty1 $item1, $name2 $ty2 $item2; $($name3 $ty3 $item3)*);
  );
  (
    __impl $($name:ident $ty:ident $item:ident),+;
    $name1:ident $ty1:ident $item1:ident $($name2:ident $ty2:ident $item2:ident)*
  ) => (
    permutation_trait_impl!($($name $ty $item),+);
    permutation_trait!(__impl $($name $ty $item),+ , $name1 $ty1 $item1; $($name2 $ty2 $item2)*);
  );
  (__impl $($name:ident $ty:ident $item:ident),+;) => (
    permutation_trait_impl!($($name $ty $item),+);
  );
);

/// Wrapping structure for the [permutation] combinator implementation
pub struct Permutation<T, Error> {
  parser: T,
  e: PhantomData<Error>,
}

macro_rules! permutation_trait_impl(
  ($($name:ident $ty:ident $item:ident),+) => (
    impl<
      Input, Error, $($ty),+ , $($name),+
    > Parser<Input> for Permutation< ( $($name),+ ), Error>
    where
    Input: Clone,
    Error: ParseError<Input>,
    $($name: Parser<Input, Output = $ty, Error = Error>),+
    {
      type Output = ( $($ty),+ );
      type Error = Error;

      #[inline(always)]
      fn process<OM: crate::OutputMode>(
        &mut self,
        mut input: Input,
      ) -> crate::PResult<OM, Input, Self::Output, Self::Error> {
        let mut res = OM::Output::bind(|| ($(Option::<$ty>::None),+));
        $(let mut $item = false;)+

        loop {
          let mut err: Option<<OM::Error as Mode>::Output<Error>> = None;
          permutation_trait_inner!(0, self, input, res,  err, $($item)+);

          // If we reach here, every iterator has either been applied before,
          // or errored on the remaining input
          if let Some(err) = err {
            // There are remaining parsers, and all errored on the remaining input
            return Err(Err::Error(OM::Error::map(err, |err| Error::append(input, ErrorKind::Permutation, err))));
          }

          return Ok((input,OM::Output::map(res, |res| {
            // All parsers were applied
            match res {
              ($(Some($item)),+) =>  ($($item),+),
              _ => unreachable!(),
            }
          })))
        }
      }

    }
  );
);

macro_rules! permutation_trait_inner(
  ($it:tt, $self:expr, $input:ident, $res:expr,  $err:expr, $head:ident $($item:ident)*) => (
    if !$head {

      match $self.parser.$it.process::<OM>($input.clone()) {
        Ok((i, o)) => {
          $input = i;
          $res = OM::Output::combine($res, o, |mut res, o | {res.$it = Some(o);res });
          $head = true;
          continue;
        }
        Err(Err::Error(e)) => {
          $err = Some(match $err {
            None => e,
            Some(err) => OM::Error::combine(err, e, |err, e| err.or(e))
          });
        }
        Err(e) => return Err(e),
      };
    }
    succ!($it, permutation_trait_inner!($self, $input, $res, $err, $($item)*));
  );
  ($it:tt, $self:expr, $input:ident, $res:expr, $err:expr,) => ();
);

permutation_trait!(
  FnA A a
  FnB B b
  FnC C c
  FnD D d
  FnE E e
  FnF F f
  FnG G g
  FnH H h
  FnI I i
  FnJ J j
  FnK K k
  FnL L l
  FnM M m
  FnN N n
  FnO O o
  FnP P p
  FnQ Q q
  FnR R r
  FnS S s
  FnT T t
  FnU U u
);
