#ifndef PARSING_UTILS_H
#define PARSING_UTILS_H

// === Macros

#define PEEK_TOKEN()                                                           \
    peek_token();                                                              \
    if (token == NULL)                                                         \
    {                                                                          \
        puts("Internal error: cannot get the following token");                \
        return NULL;                                                           \
    }

#define POP_TOKEN()                                                            \
    pop_token();                                                               \
    if (token == NULL)                                                         \
    {                                                                          \
        puts("Internal error: cannot get the following token");                \
        return NULL;                                                           \
    }

/* @brief Acts as the entry point of the parser, calls parse_list
 */
struct ast* parse_input(void);

/* @brief: parses a list of [and_or] rules separated by semicolons and that
 *         ends by a newline
 *
 * @code input = list '\n'
 *             | list EOF
 *             | '\n'
 *             | EOF
 *             ;
 */
struct ast *parse_list(void);

/* @brief Only parses a pipeline rule for the moment
 *
 * @code and_or = pipeline ;
 */
struct ast* parse_and_or(void);

/* @brief Only parses a command rule for the moment
 *
 * @code pipeline = command ;
 */
struct ast* parse_pipeline(void);

/* @brief Parses a simple command rule or a shell command rule depending on
 *        the first token.
 * @note
 *        TOKEN_WORD => simple_command
 *        TOKEN_IF => shell_command
 *
 * @code command = simple_command
 *               | shell_command
 *               ;
 */
struct ast* parse_command(void);

/* @brief Parses a simple list of words (command and arguments)
 *        ending by a separator
 *
 * @code simple_command = WORD { element } ;
 */
struct ast *parse_simple_command(void);


/* @brief Only parses if rules for the moment
 *
 * @code shell_command = if_rule ;
 */
struct ast *parse_shell_command(void);


/* @brief Parses a if rule (condition, then-clause, elif-clause, else-clause)
 *
 * @code if_rule = 'if' compound_list 'then' compound_list [else_clause] 'fi' ;
 */
struct ast *parse_if_rule(void);


/* @brief parses commands inside if/else clauses and returns the corresponding
 * AST list
 *
 * @code compound_list = {'\n'} and_or { ( ';' | '\n' ) {'\n'} and_or } [';'] {'\n'} ;
 */
struct ast* parse_compound_list(void);

/* @brief
 *
 * @code else_clause = 'else' compound_list
 *                   | 'elif' compound_list 'then' compound_list [else_clause]
 *                   ;
 */
struct ast* parse_else_clause(void);

#endif /* ! PARSING_UTILS_H */