enum e_node
{
    e_node_invalid,
    e_node_func_call,
    e_node_integer,
    e_node_float,
    e_node_identifier,
    e_node_var_decl,
    e_node_for,
    e_node_compound,
    e_node_plus_equals,
    e_node_minus_equals,
    e_node_times_equals,
    e_node_add,
    e_node_subtract,
    e_node_multiply,
    e_node_divide,
    e_node_mod,
    e_node_assign,
    e_node_if,
    e_node_equals,
    e_node_not_equals,
    e_node_greater_than_or_equal,
    e_node_less_than_or_equal,
    e_node_greater_than,
    e_node_less_than,
    e_node_return,
    e_node_func_decl,
    e_node_func_arg,
    e_node_break,
    e_node_continue,
    e_node_type,
    e_node_possible_type,
    e_node_str,
    e_node_unary,
    e_node_struct,
    e_node_struct_member,
    e_node_member_access,
};

enum e_unary
{
    e_unary_dereference,
    e_unary_address_of,
    e_unary_logical_not,
    e_unary_cast,
};

struct s_node;
struct s_type_check_var
{
    int pointer_level;
    int stack_offset; // @Note(tkap, 28/07/2023): This is relative to the function
    s_node* func_node;
    s_node* type_node;
    s64 id;
    s_str<64> name;
};

struct s_type_instance
{
    int pointer_level;
    s_node* type;
};

struct s_node
{
    int line;
    e_node type;
    s_node* next;

    int stack_offset;
    int pointer_level;
    s_node* type_node;
    s_node* func_node;

    union
    {
        struct
        {
            int arg_count;
            s_node* left;
            s_node* args;
        } func_call;

        struct
        {
            int bytes_used_by_local_variables;
            int bytes_used_by_args;
            s64 id;
            b8 external;
            int arg_count;
            s_str<64> dll_str;
            s_str<64> name;
            s_node* return_type;
            s_node* args;
            s_node* body;
        } func_decl;

        struct
        {
            s64 val;
        } integer;

        struct
        {
            float val;
        } nfloat;

        struct
        {
            int bytes_used_by_members;
            int member_count;
            s_node* members;
            s_str<64> name;
        } nstruct;

        struct
        {
            s_node* type;
            s_str<64> name;
        } struct_member;

        struct
        {
            // @TODO(tkap, 26/07/2023): This needs to be dynamic
            s_str<128> val;
        } str;

        struct
        {
            s_str<64> name;
            s_node* type;
            s_node* val;
        } var_decl;

        struct
        {
            s_str<64> name;
        } identifier;

        struct
        {
            b8 reverse;
            s_str<64> name;
            s_node* expr;
            s_node* body;
        } nfor;

        struct
        {
            s_node* expr;
            s_node* body;
        } nif;

        struct
        {
            int statement_count;
            s_node* statements;
        } compound;

        struct
        {
            s_node* left;
            s_node* right;
        } arithmetic;

        struct
        {
            s_node* expr;
        } nreturn;

        struct
        {
            int size_in_bytes;
            int id;
            s_str<64> name;
        } ntype;

        struct
        {
            int pointer_level;
            s_str<64> name;
        } possible_type;

        struct
        {
            s_node* type;
            s_str<64> name;
        } func_arg;

        struct
        {
            e_unary type;
            s_node* cast_type; // @Note(tkap, 04/08/2023): Only for e_unary_cast
            s_node* expr;
        } unary;

        struct
        {
            int val;
        } nbreak;
    };
};


struct s_parse_result
{
    b8 success;
    s_tokenizer tokenizer;
    s_node node;
};

struct s_error_reporter
{
    b8 has_error;
    b8 has_warning;
    char error_str[1024];

    void warning(int line, char* file, char* str, ...);
    void error(int line, char* file, char* str, ...);
    void fatal(int line, char* file, char* str, ...);
};


func s_node* parse(s_tokenizer tokenizer, char* file);
func s_parse_result parse_expr(s_tokenizer tokenizer, int operator_level, s_error_reporter* reporter, char* file);
func s_parse_result parse_statement(s_tokenizer tokenizer, s_error_reporter* reporter, char* file);
func s_node* make_node(s_node node);
func s_node** node_set_and_advance(s_node** target, s_node node);
func int get_operator_level(char* str);
func void print_parser_expr(s_node* node);
func b8 peek_assignment_token(s_tokenizer tokenizer, e_node* out_type);
func s_parse_result parse_type(s_tokenizer tokenizer, s_error_reporter* reporter, char* file);
func s_parse_result parse_func_decl(s_tokenizer tokenizer, s_error_reporter* reporter, char* file);
func int get_unary_operator_level(char* str);
func b8 token_is_keyword(s_token token);
func s_parse_result parse_struct(s_tokenizer tokenizer, s_error_reporter* reporter, char* file);