//! Parsers constructor from regular functions

use crate::{
    error::{ParseResult, StdParseResult},
    lib::marker::PhantomData,
    stream::Stream,
    Parser,
};

impl<'a, Input: Stream, O> Parser<Input>
    for dyn FnMut(&mut Input) -> StdParseResult<O, Input> + 'a
{
    type Output = O;
    type PartialState = ();

    #[inline]
    fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<O, Input::Error> {
        self(input).into()
    }
}

#[derive(Copy, Clone)]
pub struct FnParser<Input, F>(F, PhantomData<fn(Input) -> Input>);

/// Wraps a function, turning it into a parser.
///
/// Mainly needed to turn closures into parsers as function types can be casted to function pointers
/// to make them usable as a parser.
///
/// ```
/// extern crate combine;
/// # use combine::*;
/// # use combine::parser::char::digit;
/// # use combine::error::{Commit, StreamError};
/// # use combine::stream::easy;
/// # fn main() {
/// let mut even_digit = parser(|input| {
///     // Help type inference out
///     let _: &mut easy::Stream<&str> = input;
///     let position = input.position();
///     let (char_digit, committed) = digit().parse_stream(input).into_result()?;
///     let d = (char_digit as i32) - ('0' as i32);
///     if d % 2 == 0 {
///         Ok((d, committed))
///     }
///     else {
///         //Return an empty error since we only tested the first token of the stream
///         let errors = easy::Errors::new(
///             position,
///             StreamError::expected("even number")
///         );
///         Err(Commit::Peek(errors.into()))
///     }
/// });
/// let result = even_digit
///     .easy_parse("8")
///     .map(|x| x.0);
/// assert_eq!(result, Ok(8));
/// # }
/// ```
pub fn parser<Input, O, F>(f: F) -> FnParser<Input, F>
where
    Input: Stream,
    F: FnMut(&mut Input) -> StdParseResult<O, Input>,
{
    FnParser(f, PhantomData)
}

impl<Input, O, F> Parser<Input> for FnParser<Input, F>
where
    Input: Stream,
    F: FnMut(&mut Input) -> StdParseResult<O, Input>,
{
    type Output = O;
    type PartialState = ();

    #[inline]
    fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<O, Input::Error> {
        (self.0)(input).into()
    }
}

impl<Input, O> Parser<Input> for fn(&mut Input) -> StdParseResult<O, Input>
where
    Input: Stream,
{
    type Output = O;
    type PartialState = ();

    #[inline]
    fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<O, Input::Error> {
        self(input).into()
    }
}

#[derive(Copy)]
pub struct EnvParser<E, Input, T>
where
    Input: Stream,
{
    env: E,
    parser: fn(E, &mut Input) -> StdParseResult<T, Input>,
}

impl<E, Input, T> Clone for EnvParser<E, Input, T>
where
    Input: Stream,
    E: Clone,
{
    fn clone(&self) -> Self {
        EnvParser {
            env: self.env.clone(),
            parser: self.parser,
        }
    }
}

impl<Input, E, O> Parser<Input> for EnvParser<E, Input, O>
where
    E: Clone,
    Input: Stream,
{
    type Output = O;
    type PartialState = ();

    #[inline]
    fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<O, Input::Error> {
        (self.parser)(self.env.clone(), input).into()
    }
}

/// Constructs a parser out of an environment and a function which needs the given environment to
/// do the parsing. This is commonly useful to allow multiple parsers to share some environment
/// while still allowing the parsers to be written in separate functions.
///
/// ```
/// # extern crate combine;
/// # use std::collections::HashMap;
/// # use combine::*;
/// # use combine::parser::function::env_parser;
/// # use combine::parser::char::letter;
/// # fn main() {
/// struct Interner(HashMap<String, u32>);
/// impl Interner {
///     fn string<Input>(&self, input: &mut Input) -> StdParseResult<u32, Input>
///         where Input: Stream<Token = char>,
///     {
///         many(letter())
///             .map(|s: String| self.0.get(&s).cloned().unwrap_or(0))
///             .parse_stream(input)
///             .into_result()
///     }
/// }
///
/// let mut map = HashMap::new();
/// map.insert("hello".into(), 1);
/// map.insert("test".into(), 2);
///
/// let env = Interner(map);
/// let mut parser = env_parser(&env, Interner::string);
///
/// let result = parser.parse("hello");
/// assert_eq!(result, Ok((1, "")));
///
/// let result = parser.parse("world");
/// assert_eq!(result, Ok((0, "")));
/// # }
/// ```
pub fn env_parser<E, Input, O>(
    env: E,
    parser: fn(E, &mut Input) -> StdParseResult<O, Input>,
) -> EnvParser<E, Input, O>
where
    E: Clone,
    Input: Stream,
{
    EnvParser { env, parser }
}