#ifndef __SCC_PARSER_H__
#define __SCC_PARSER_H__

#include "scc_sema.h"
#include <scc_ast.h>
#include <scc_core_ring.h>
#include <scc_hashtable.h>
#include <scc_lexer_token.h>

/**
 * @brief 解析器状态
 */
typedef struct scc_parser {
    scc_lexer_tok_ring_t *ring;
    usize checkpoint;

    scc_ast_ctx_t *ast_ctx;
    scc_sema_ctx_t *sema_ctx;
    int owned_sema;
    scc_ast_translation_unit_t *translation_unit;
    int errcode;
} scc_parser_t;

// static inline scc_ast_qual_type_t *scc_parser_

/**
 * @brief 初始化解析器
 * @param parser 解析器实例
 * @param lexer 词法分析器实例
 * @param callbacks 语义分析回调(可为 nullptr)
 */
void scc_parser_init(scc_parser_t *parser, scc_lexer_tok_ring_t *tok_ring,
                     scc_ast_ctx_t *ast_ctx, scc_sema_ctx_t *callbacks);

/**
 * @brief 销毁解析器
 * @param parser 解析器实例
 */
void scc_parser_drop(scc_parser_t *parser);

/**
 * @brief 解析整个翻译单元
 * @param parser 解析器实例
 * @return 翻译单元 AST 节点
 */
scc_ast_translation_unit_t *scc_parse_translation_unit(scc_parser_t *parser);

/**
 * @brief 解析声明
 * @param parser 解析器实例
 * @return 声明 AST 节点
 */
scc_ast_decl_t *scc_parse_declaration(scc_parser_t *parser);
scc_ast_expr_t *scc_parse_initializer(scc_parser_t *parser,
                                      scc_ast_expr_t *base);

/**
 * @brief 解析语句
 * @param parser 解析器实例
 * @return 语句 AST 节点
 */
scc_ast_stmt_t *scc_parse_statement(scc_parser_t *parser);
scc_ast_expr_t *scc_parse_assignment_expression(scc_parser_t *parser);
scc_ast_expr_t *scc_parser_constant_expression(scc_parser_t *parser);

/**
 * @brief 解析表达式
 * @param parser 解析器实例
 * @return 表达式 AST 节点
 */
scc_ast_expr_t *scc_parse_expression(scc_parser_t *parser);

/**
 * @brief 解析类型
 * @param parser 解析器实例
 * @return 类型 AST 节点
 */
scc_ast_decl_t *scc_parse_declarator(scc_parser_t *parser,
                                     scc_ast_qual_type_t *type);
scc_ast_qual_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser);
scc_ast_qual_type_t *scc_parse_type_name(scc_parser_t *parser);

static inline void scc_sema_decl(scc_parser_t *parser, scc_ast_node_kind_t kind,
                                 scc_ast_decl_t *decl) {
    parser->sema_ctx->on_decl(parser->sema_ctx, kind, decl);
}

static inline void scc_sema_expr(scc_parser_t *parser, scc_ast_node_kind_t kind,
                                 scc_ast_expr_t *expr) {
    parser->sema_ctx->on_expr(parser->sema_ctx, kind, expr);
}

static inline void scc_sema_stmt(scc_parser_t *parser, scc_ast_node_kind_t kind,
                                 scc_ast_stmt_t *stmt) {
    parser->sema_ctx->on_stmt(parser->sema_ctx, kind, stmt);
}

static inline void scc_sema_type(scc_parser_t *parser, scc_ast_node_kind_t kind,
                                 scc_ast_qual_type_t *type) {
    parser->sema_ctx->on_type(parser->sema_ctx, kind, type);
}

static inline void scc_parse_decl_sema(scc_parser_t *parser,
                                       scc_ast_decl_t *decl) {
    scc_sema_decl(parser, decl ? decl->base.type : SCC_AST_UNKNOWN, decl);
}

static inline void scc_parse_expr_sema(scc_parser_t *parser,
                                       scc_ast_expr_t *expr) {
    scc_sema_expr(parser, expr ? expr->base.type : SCC_AST_UNKNOWN, expr);
}

static inline void scc_parse_stmt_sema(scc_parser_t *parser,
                                       scc_ast_stmt_t *stmt) {
    scc_sema_stmt(parser, stmt ? stmt->base.type : SCC_AST_UNKNOWN, stmt);
}

static inline void scc_parse_type_sema(scc_parser_t *parser,
                                       scc_ast_qual_type_t *type) {
    scc_sema_type(parser, type ? type->base.type : SCC_AST_UNKNOWN, type);
}

static inline const scc_ast_qual_type_t *
scc_parse_got_type(scc_parser_t *parser, const char *name) {
    return parser->sema_ctx->got_type(parser->sema_ctx, name);
}

#endif /* __SCC_PARSER_H__ */