/// This module contains the Parser and Error types which
/// contain the minimal logic for implementing the atomic
/// parser combinators.

/// Required modules and traits from core
use core::fmt;
use core::ops::Bound::*;
use core::ops::{BitAnd, BitOr, BitXor, Mul, Not, RangeBounds, Rem, Shl, Shr, Sub};

use alloc::string::{String, ToString};
use alloc::sync::Arc;
/// We need alloc!
use alloc::vec::Vec;

/// This struct is the Err result when parsing.
/// It contains a string representing:
/// The actual input received
/// The expected input
/// And the remaining, unparsed input
#[derive(Clone, PartialEq)]
pub struct Error {
    actual: String,
    expected: String,
    remaining_input: String,
}

impl Error {
    pub fn new<T>(
        actual: impl ToString,
        expected: impl ToString,
        remaining_input: impl ToString,
    ) -> Result<T, Self> {
        Err(Self {
            actual: actual.to_string(),
            expected: expected.to_string(),
            remaining_input: remaining_input.to_string(),
        })
    }
}

/// Needed for assertions and general debugging
impl fmt::Debug for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        write!(
            f,
            "Expected `{}` but found `{}` when parsing `{}`",
            self.expected,
            self.actual,
            self.remaining_input.replace("\n", "")
        )
    }
}

/// The Output type represents the output of a parser.
/// Ok(T, String) result represents successfully parsed & lexed input.
/// The T type represents the consumed and lexed input,
/// and the String represents the remaining input.
pub type Output<T> = Result<(T, String), Error>;

/// A Parser has a function that consumes input
/// and returns an object of type Output.
#[derive(Clone)]
pub struct Parser<T> {
    parser: Arc<dyn Fn(&str) -> Output<T>>,
    pub expectation: String,
}

impl<T> Parser<T>
where
    T: 'static + Clone,
{
    /// Create a new parser from a function that returns an Output.
    /// This is mainly used to define the atomic combinators
    pub fn new(parser: impl Fn(&str) -> Output<T> + 'static, expectation: impl ToString) -> Self {
        Self {
            parser: Arc::new(parser),
            expectation: expectation.to_string(),
        }
    }

    pub fn expects(mut self, expectation: impl ToString) -> Self {
        self.expectation = expectation.to_string();
        self
    }

    /// This parses a string using this combinator, and returns
    /// a result containing either the successfully lexed and parsed
    /// data, or an error containing info about the failure.
    pub fn parse(&self, input: &str) -> Result<T, Error> {
        match self.parse_internal(input) {
            Ok(t) => Ok(t.0),
            Err(e) => Error::new(e.actual, self.expectation.clone(), e.remaining_input),
        }
    }

    /// This is used by the atomic combinators for things like
    /// control flow and passing the output of one parser into another.
    pub fn parse_internal(&self, input: &str) -> Output<T> {
        (self.parser)(input)
    }

    /// This method takes a function that takes the output of this Parser,
    /// and converts it to the output of another data type.
    /// This allows us to lex our input as we parse it.
    pub fn map<O>(self, map_fn: fn(T) -> O) -> Parser<O>
    where
        O: 'static + Clone,
    {
        let expect = self.expectation.clone();
        Parser::new(
            move |s: &str| match self.parse_internal(s) {
                Ok((first_out, input)) => Ok((map_fn(first_out), input)),
                Err(e) => Err(e),
            },
            expect,
        )
    }

    /// This method takes a function that takes the output of this Parser,
    /// and TRIES to convert it to the output of another data type.
    /// If the given function returns an Err, this parser fails.
    pub fn convert<O, E>(self, convert_fn: fn(T) -> Result<O, E>) -> Parser<O>
    where
        O: 'static + Clone,
        E: 'static,
    {
        let expect = self.expectation.clone();
        Parser::new(
            move |s: &str| match self.parse_internal(s) {
                Ok((first_out, input)) => {
                    let result = match convert_fn(first_out) {
                        Ok(value) => value,
                        Err(_) => return Error::new(s.clone(), "A convertible value", s.clone()),
                    };
                    Ok((result, input))
                }
                Err(e) => Err(e),
            },
            expect,
        )
    }

    /// This parser "prefixes" another.
    /// When the returned parser is used, it will require this parser and
    /// the operand parser to succeed, and return the result of the second.
    pub fn prefixes<O>(self, operand: Parser<O>) -> Parser<O>
    where
        O: 'static + Clone,
    {
        let expect = self.expectation.clone() + " followed by " + &operand.expectation.clone();
        Parser::new(
            move |s: &str| {
                // Get the remaining input from ourselves
                // and discard consumed input
                let (_, remaining) = self.parse_internal(s)?;
                // Get the consumed input and remaining input from operand
                let (consumed, remaining) = operand.parse_internal(&remaining)?;
                // Return result
                Ok((consumed, remaining))
            },
            expect,
        )
    }

    /// This parser will use the operand as a "suffix".
    /// The parser will only succeed if the "suffix" parser succeeds afterwards,
    /// but the input of the "suffix" parser will be discarded.
    pub fn suffix<O>(self, operand: Parser<O>) -> Parser<T>
    where
        O: 'static + Clone,
    {
        let expect = self.expectation.clone() + " followed by " + &operand.expectation.clone();
        Parser::new(
            move |s: &str| {
                // Get consumed input and remaining input from ourselves
                let (consumed, remaining) = self.parse_internal(s)?;
                // Consume the input from the remaining,
                // but discard the consumed result.
                let (_, remaining) = operand.parse_internal(&remaining)?;
                // Return result
                Ok((consumed, remaining))
            },
            expect,
        )
    }

    /// This method returns a parser that does not consume input,
    /// but succeeds if this parser succeeds. This can be used to
    /// make assertions for our input.
    pub fn is(self) -> Parser<()> {
        let expect = self.expectation.clone();
        Parser::new(
            move |s: &str| match self.parse_internal(s) {
                // If this parser succeeds, consume nothing and continue
                Ok(_) => Ok(((), s.to_string())),
                // If this parser fails, throw an error
                Err(_) => Error::new(s, format!("Not {}", s), s),
            },
            expect,
        )
    }

    /// This method returns a parser that does not consume input,
    /// but succeeds if this parser does not succeed. This can be
    /// used to make assertions for our input.
    pub fn isnt(self) -> Parser<()> {
        let expect = self.expectation.clone();
        Parser::new(
            move |s: &str| match self.parse_internal(s) {
                // If this parser succeeds, throw an error
                Ok(_) => Error::new(s, format!("Not {}", self.expectation), s),
                // If this parser fails, consume nothing and continue
                Err(_) => Ok(((), s.to_string())),
            },
            format!("Not {}", expect),
        )
    }

    /// Combine two parsers into one, and combine their consumed
    /// inputs into a tuple.
    /// Parser<A> & Parser<B> -> Parser<A, B>.
    /// The resulting parser will only succeed if BOTH sub-parsers succeed.
    pub fn and<O>(self, operand: Parser<O>) -> Parser<(T, O)>
    where
        O: 'static + Clone,
    {
        let expect = self.expectation.clone() + " and " + &operand.expectation.clone();
        Parser::new(
            move |s: &str| {
                // Get the first consumed and remaining
                let (first_consumed, remaining) = self.parse_internal(s)?;
                // Get the second consumed and remaining
                let (second_consumed, remaining) = operand.parse_internal(&remaining)?;
                // Return a tuple of first and second
                Ok(((first_consumed, second_consumed), remaining))
            },
            expect,
        )
    }

    /// If this parser does not succeed, try this other parser
    pub fn or(self, operand: Self) -> Self {
        let expect = self.expectation.clone() + " or " + &operand.expectation.clone();
        Parser::new(
            move |s: &str| match self.parse_internal(s) {
                // If we succeed, return OUR result
                Ok(t) => Ok(t),
                // If we don't succeed, return the other parser's result
                // We can safely discard OUR error here because we expect failure.
                Err(_) => operand.parse_internal(s),
            },
            expect,
        )
    }

    /// Repeat this parser N..M times
    /// This can also be repeated ..N times, N.. times, or even .. times
    pub fn repeat(self, range: impl RangeBounds<usize>) -> Parser<Vec<T>> {
        // Get the upper bound
        let upper_bound: usize = match range.end_bound() {
            Unbounded => core::usize::MAX,
            Excluded(n) => *n,
            Included(n) => *n,
        };

        // Get the lower bound
        let lower_bound: usize = match range.start_bound() {
            Unbounded => 0,
            Excluded(n) => *n,
            Included(n) => *n,
        };

        let expect = self.expectation.clone()
            + &format!(" {:?}..{:?} times", range.start_bound(), range.end_bound());
        Parser::new(
            move |s: &str| {
                // The string containing the remaining input
                let mut remaining_input = s.to_string();
                // This accumulates all the consumed and lexed outputs
                // from all the successfully parsed inputs
                let mut accum = vec![];

                for n in 0..upper_bound {
                    match self.parse_internal(&remaining_input) {
                        Ok((consumed, unconsumed)) => {
                            accum.push(consumed);
                            remaining_input = unconsumed;
                        }
                        Err(e) => {
                            // If we did not consume enough data, we failed.
                            // If consumed greater than the lower bound, we succeeded!
                            if n < lower_bound {
                                return Err(e);
                            } else {
                                return Ok((accum, remaining_input));
                            }
                        }
                    }
                }
                // Return the vector of consumed inputs
                Ok((accum, remaining_input))
            },
            expect,
        )
    }
}

/// The | operator can be used as an alternative to the `.or` method
impl<T: 'static + Clone, S: ToString> Rem<S> for Parser<T> {
    type Output = Self;
    fn rem(self, rhs: S) -> Self::Output {
        self.expects(rhs)
    }
}

/// The | operator can be used as an alternative to the `.or` method
impl<T: 'static + Clone> BitOr for Parser<T> {
    type Output = Parser<T>;
    fn bitor(self, rhs: Self) -> Self::Output {
        self.or(rhs)
    }
}

/// The & operator can be used as an alternative to the `.and` method
impl<A: 'static + Clone, B: 'static + Clone> BitAnd<Parser<B>> for Parser<A> {
    type Output = Parser<(A, B)>;
    fn bitand(self, rhs: Parser<B>) -> Self::Output {
        self.and(rhs)
    }
}

/// The ! operator can be used as an alternative to the `.not` method
impl<T: 'static + Clone> Not for Parser<T> {
    type Output = Parser<()>;
    fn not(self) -> Self::Output {
        self.isnt()
    }
}

/// Discard the consumed data of the RHS
impl<A: 'static + Clone, B: 'static + Clone> Shl<Parser<B>> for Parser<A> {
    type Output = Parser<A>;
    fn shl(self, rhs: Parser<B>) -> Self::Output {
        self.suffix(rhs)
    }
}

/// Discard the consumed data of the LHS
impl<A: 'static + Clone, B: 'static + Clone> Shr<Parser<B>> for Parser<A> {
    type Output = Parser<B>;
    fn shr(self, rhs: Parser<B>) -> Self::Output {
        self.prefixes(rhs)
    }
}

/// A parser can be multiplied by a range as an alternative to `.repeat`.
/// Here's an example: `sym('a') * (..7)`
impl<T: 'static + Clone, R: RangeBounds<usize>> Mul<R> for Parser<T> {
    type Output = Parser<Vec<T>>;
    fn mul(self, rhs: R) -> Self::Output {
        self.repeat(rhs)
    }
}

/// The - operator is used as an alternative to the `.map` method.
impl<O, T> Sub<fn(T) -> O> for Parser<T>
where
    O: 'static + Clone,
    T: 'static + Clone,
{
    type Output = Parser<O>;
    fn sub(self, rhs: fn(T) -> O) -> Self::Output {
        self.map(rhs)
    }
}

/// The ^ operator is used as an alternative to the `.convert` method.
impl<O, T, E> BitXor<fn(T) -> Result<O, E>> for Parser<T>
where
    O: 'static + Clone,
    T: 'static + Clone,
    E: 'static,
{
    type Output = Parser<O>;
    fn bitxor(self, rhs: fn(T) -> Result<O, E>) -> Self::Output {
        self.convert(rhs)
    }
}