use super::tokens::{token, Token, TokenKind as tk, TokenSpan};
use super::IResult;
use nom::multi::separated_list0;
use nom::sequence::tuple;
use nom::{
    combinator::{cut, map, opt},
    sequence::{delimited, preceded},
};

#[derive(Debug)]
pub struct StateBlock<'a> {
    pub name: Token<'a>,
    pub variants: Vec<StateVariant<'a>>,
}

#[derive(Debug)]
pub struct StateVariant<'a> {
    pub name: Token<'a>,
    pub params: Option<Vec<Token<'a>>>,
}

fn state_variant(input: TokenSpan) -> IResult<TokenSpan, StateVariant> {
    map(
        tuple((
            token(tk::Ident),
            opt(delimited(
                token(tk::LParen),
                separated_list0(token(tk::Comma), token(tk::Ident)),
                token(tk::RParen),
            )),
        )),
        |(name, param)| StateVariant {
            name,
            params: param,
        },
    )(input)
}

pub fn state(input: TokenSpan) -> IResult<TokenSpan, StateBlock> {
    map(
        preceded(
            token(tk::State),
            cut(tuple((
                token(tk::Ident),
                delimited(
                    token(tk::LBrace),
                    separated_list0(token(tk::Comma), state_variant),
                    token(tk::RBrace),
                ),
            ))),
        ),
        |(name, variants)| StateBlock { name, variants },
    )(input)
}