use super::tokens::{token, TokenKind as tk, TokenSpan};
use super::{IResult, Span};
use nom::{
    branch::alt,
    combinator::map,
    multi::separated_list0,
    sequence::{delimited, preceded, separated_pair, tuple},
};

#[derive(Debug, Clone)]
pub enum Operation<'a> {
    And {
        a: Expression<'a>,
        b: Expression<'a>,
    },
    Or {
        a: Expression<'a>,
        b: Expression<'a>,
    },
    Xor {
        a: Expression<'a>,
        b: Expression<'a>,
    },
    Not(Expression<'a>),
}

pub fn operation(input: TokenSpan) -> IResult<TokenSpan, Operation> {
    // temporarily given up on before I learn the shunting yard algorithm
    alt((
        map(
            separated_pair(expression_nonrecurse, token(tk::BitAnd), expression),
            |(a, b)| Operation::And { a, b },
        ),
        map(
            separated_pair(expression_nonrecurse, token(tk::BitOr), expression),
            |(a, b)| Operation::Or { a, b },
        ),
        map(
            separated_pair(expression_nonrecurse, token(tk::BitXor), expression),
            |(a, b)| Operation::Xor { a, b },
        ),
        map(preceded(token(tk::BitNot), expression), Operation::Not),
    ))(input)
}

#[derive(Debug, Clone)]
pub struct Call<'a> {
    pub name: Span<'a>,
    pub args: Vec<Expression<'a>>,
}

pub fn call_item(input: TokenSpan) -> IResult<TokenSpan, Call> {
    map(
        tuple((
            token(tk::Ident),
            delimited(
                token(tk::LParen),
                separated_list0(token(tk::Comma), expression),
                token(tk::RParen),
            ),
        )),
        |(name, args)| Call {
            name: name.span(),
            args,
        },
    )(input)
}

#[derive(Debug, Clone)]
pub enum Expression<'a> {
    Ident(&'a str),
    Literal(u64),
    Call(Box<Call<'a>>),
    Operation(Box<Operation<'a>>),
}

/// parser combinators can not parse left-recursive grammars. To work around this, we split
/// expressions into a recursive and non-recursive portion.
/// Parsers reachable from this point must call expression_nonrecurse instead
pub fn expression(input: TokenSpan) -> IResult<TokenSpan, Expression> {
    alt((
        map(operation, |op| Expression::Operation(Box::new(op))),
        expression_nonrecurse,
    ))(input)
}

/// the portion of the expression grammar that can be parsed without left recursion
fn expression_nonrecurse(input: TokenSpan) -> IResult<TokenSpan, Expression> {
    alt((
        map(token(tk::Number), |_| Expression::Literal(42)),
        map(call_item, |call| Expression::Call(Box::new(call))),
        map(token(tk::Ident), |ident| {
            Expression::Ident(*ident.span().fragment())
        }),
        delimited(token(tk::LParen), expression, token(tk::RParen)),
    ))(input)
}