#include <compiler.h>

enum class ValueIntrinsic
{
    align_of,
    byte_size,
    enum_name,
    extend,
    integer_max,
    int_from_enum,
    int_from_pointer,
    pointer_cast,
    select,
    string_to_enum,
    trap,
    truncate,
    va_start,
    va_end,
    va_arg,
    va_copy,
    count,
};

fn Block* scope_to_block(Scope* scope)
{
    assert(scope->kind == ScopeKind::local);
    auto byte_offset = offsetof(Block, scope);
    auto result = (Block*)((u8*)scope - byte_offset);
    return result;
}

fn ValueFunction* scope_to_function(Scope* scope)
{
    assert(scope->kind == ScopeKind::function);
    auto byte_offset = offsetof(ValueFunction, scope);
    auto result = (ValueFunction*)((u8*)scope - byte_offset);
    return result;
}

fn Module* scope_to_module(Scope* scope)
{
    assert(scope->kind == ScopeKind::global);
    auto byte_offset = offsetof(Module, scope);
    auto result = (Module*)((u8*)scope - byte_offset);
    return result;
}

fn Local* new_local(Module* module, Scope* scope)
{
    auto* result = &arena_allocate<Local>(module->arena, 1)[0];

    switch (scope->kind)
    {
        case ScopeKind::local:
            {
                auto block = scope_to_block(scope);
                if (block->last_local)
                {
                    block->last_local->next = result;
                    block->last_local = result;
                }
                else
                {
                    block->first_local = result;
                    block->last_local = result;
                }
            } break;
        default: report_error();
    }

    return result;
}

enum class TokenId
{
    none,
    end_of_statement,
    integer,
    left_brace,
    left_bracket,
    left_parenthesis,
    right_brace,
    right_bracket,
    right_parenthesis,

    plus,
    dash,
    asterisk,
    forward_slash,
    percentage,
    caret,
    bar,
    ampersand,
    exclamation,

    assign_plus,
    assign_dash,
    assign_asterisk,
    assign_forward_slash,
    assign_percentage,
    assign_caret,
    assign_bar,
    assign_ampersand,
    assign_exclamation,

    value_keyword,
    operator_keyword,
    identifier,
    value_intrinsic,

    shift_left,
    shift_right,
    assign_shift_left,
    assign_shift_right,

    compare_less,
    compare_less_equal,
    compare_greater,
    compare_greater_equal,
    compare_equal,

    dot,
    double_dot,
    triple_dot,

    pointer_dereference,
};

enum class TokenIntegerKind
{
    hexadecimal,
    decimal,
    octal,
    binary,
};

struct TokenInteger
{
    u64 value;
    TokenIntegerKind kind;
};

enum class ValueKeyword
{
    undefined,
    unreachable,
    zero,
    count,
};

enum class OperatorKeyword
{
    and_op,
    or_op,
    and_op_shortcircuit,
    or_op_shortcircuit,
    count,
};

struct Token
{
    union
    {
        TokenInteger integer;
        ValueKeyword value_keyword;
        String identifier;
        OperatorKeyword operator_keyword;
        ValueIntrinsic value_intrinsic;
    };
    TokenId id;
};

enum class Precedence
{
    none,
    assignment,
    boolean_or,
    boolean_and,
    comparison,
    bitwise,
    shifting,
    add_like,
    div_like,
    prefix,
    aggregate_initialization,
    postfix,
};

struct ValueBuilder
{
    Token token;
    Value* left;
    Precedence precedence;
    ValueKind kind;
    bool allow_assignment_operators;

    inline ValueBuilder with_precedence(Precedence precedence)
    {
        auto result = *this;
        result.precedence = precedence;
        return result;
    }

    inline ValueBuilder with_token(Token token)
    {
        auto result = *this;
        result.token = token;
        return result;
    }

    inline ValueBuilder with_left(Value* value)
    {
        auto result = *this;
        result.left = value;
        return result;
    }

    inline ValueBuilder with_kind(ValueKind kind)
    {
        auto result = *this;
        result.kind = kind;
        return result;
    }
};

global_variable constexpr u8 left_bracket = '[';
global_variable constexpr u8 right_bracket = ']';
global_variable constexpr u8 left_brace = '{';
global_variable constexpr u8 right_brace = '}';
global_variable constexpr u8 left_parenthesis = '(';
global_variable constexpr u8 right_parenthesis = ')';

fn bool is_space(u8 ch)
{
    return ((ch == ' ') | (ch == '\n')) | ((ch == '\t') | (ch == '\r'));
}

fn bool is_lower(u8 ch)
{
    return ((ch >= 'a') & (ch <= 'z'));
}

fn bool is_upper(u8 ch)
{
    return ((ch >= 'A') & (ch <= 'Z'));
}

fn bool is_decimal(u8 ch)
{
    return ((ch >= '0') & (ch <= '9'));
}

fn bool is_hexadecimal_alpha_lower(u8 ch)
{
    return ((ch >= 'a') & (ch <= 'f'));
}

fn bool is_hexadecimal_alpha_upper(u8 ch)
{
    return ((ch >= 'A') & (ch <= 'F'));
}

fn bool is_hexadecimal_alpha(u8 ch)
{
    return is_hexadecimal_alpha_lower(ch) | is_hexadecimal_alpha_upper(ch);
}

fn bool is_hexadecimal(u8 ch)
{
    return is_decimal(ch) | is_hexadecimal_alpha(ch);
}

fn bool is_identifier_start(u8 ch)
{
    return (is_lower(ch) | is_upper(ch)) | (ch == '_');
}

fn bool is_identifier(u8 ch)
{
    return is_identifier_start(ch) | is_decimal(ch);
}

fn u32 get_line(Module* module)
{
    auto line = module->line_offset + 1;
    assert(line < ~(u32)0);
    return (u32)line;
}

fn u32 get_column(Module* module)
{
    auto column = module->offset - module->line_character_offset + 1;
    assert(column < ~(u32)0);
    return (u32)column;
}

struct Checkpoint
{
    u64 offset;
    u64 line_offset;
    u64 line_character_offset;
};

fn Checkpoint get_checkpoint(Module* module)
{
    return {
        .offset = module->offset,
        .line_offset = module->line_offset,
        .line_character_offset = module->line_character_offset,
    };
}

fn void set_checkpoint(Module* module, Checkpoint checkpoint)
{
    module->offset = checkpoint.offset;
    module->line_offset = checkpoint.line_offset;
    module->line_character_offset = checkpoint.line_character_offset;
}

fn bool consume_character_if_match(Module* module, u8 expected_ch)
{
    bool is_ch = false;
    auto i = module->offset;
    if (i < module->content.length)
    {
        auto ch = module->content[i];
        is_ch = expected_ch == ch;
        module->offset = i + is_ch;
    }

    return is_ch;
}

fn void expect_character(Module* module, u8 expected_ch)
{
    if (!consume_character_if_match(module, expected_ch))
    {
        report_error();
    }
}

fn void skip_space(Module* module)
{
    while (1)
    {
        auto iteration_offset = module->offset;

        while (module->offset < module->content.length)
        {
            auto ch = module->content[module->offset];
            if (!is_space(ch))
            {
                break;
            }

            module->line_offset += ch == '\n';
            module->line_character_offset = ch == '\n' ? module->offset : module->line_character_offset;
            module->offset += 1;
        }

        if (module->offset + 1 < module->content.length)
        {
            auto i = module->offset;
            auto first_ch = module->content[i];
            auto second_ch = module->content[i + 1];
            auto is_comment = first_ch == '/' && second_ch == '/';

            if (is_comment)
            {
                while (module->offset < module->content.length)
                {
                    auto ch = module->content[module->offset];
                    if (ch == '\n')
                    {
                        break;
                    }
                    module->offset += 1;
                }

                if (module->offset < module->content.length)
                {
                    module->line_offset += 1;
                    module->line_character_offset = module->offset;
                    module->offset += 1;
                }
            }
        }

        if (module->offset - iteration_offset == 0)
        {
            break;
        }
    }
}

fn String parse_identifier(Module* module)
{
    auto start = module->offset;

    if (is_identifier_start(module->content[start]))
    {
        module->offset = start + 1;

        while (module->offset < module->content.length)
        {
            auto i = module->offset;
            if (is_identifier(module->content[i]))
            {
                module->offset = i + 1;
            }
            else
            {
                break;
            }
        }
    }

    auto end = module->offset;
    if (end - start == 0)
    {
        report_error();
    }

    return module->content(start, end);
}

fn u64 accumulate_decimal(u64 accumulator, u8 ch)
{
    return (accumulator * 10) + (ch - '0');
}

fn u64 accumulate_hexadecimal(u64 accumulator, u8 ch)
{
    u64 value;

    if (is_decimal(ch))
    {
        value = ch - '0';
    }
    else if (is_hexadecimal_alpha_upper(ch))
    {
        value = ch - 'A' + 10;
    }
    else if (is_hexadecimal_alpha_lower(ch))
    {
        value = ch - 'a' + 10;
    }
    else
    {
        unreachable();
    }

    auto result = (accumulator * 16) + value;
    return result;
}


fn u64 parse_integer_decimal_assume_valid(String string)
{
    u64 value = 0;

    for (u8 ch: string)
    {
        assert(is_decimal(ch));
        value = accumulate_decimal(value, ch);
    }

    return value;
}

fn Type* parse_type(Module* module)
{
    auto start_character = module->content[module->offset];
    if (is_identifier_start(start_character))
    {
        auto identifier = parse_identifier(module);
        if (identifier.equal(str("void")))
        {
            return void_type(module);
        }
        else if (identifier.equal(str("noreturn")))
        {
            return noreturn_type(module);
        }
        else
        {
            auto is_int_type = identifier.length > 1 && (identifier[0] == 's' || identifier[0] == 'u');

            if (is_int_type)
            {
                for (auto ch : identifier(1))
                {
                    is_int_type = is_int_type && is_decimal(ch);
                }
            }

            if (is_int_type)
            {
                bool is_signed;
                switch (identifier[0])
                {
                    case 's': is_signed = true; break;
                    case 'u': is_signed = false; break;
                    default: unreachable();
                }

                auto bit_count = parse_integer_decimal_assume_valid(identifier(1));
                if (bit_count == 0)
                {
                    report_error();
                }
                if (bit_count > 64)
                {
                    if (bit_count != 128)
                    {
                        report_error();
                    }
                }

                auto result = integer_type(module, { .bit_count = (u32)bit_count, .is_signed = is_signed });
                return result;
            }
            else
            {
                trap_raw();
            }
        }
    }
    else if (start_character == '&')
    {
        trap_raw();
    }
    else if (start_character == left_bracket)
    {
        trap_raw();
    }
    else if (start_character == '#')
    {
        trap_raw();
    }
    else
    {
        report_error();
    }
}

fn u64 parse_hexadecimal(Module* module)
{
    u64 value = 0;

    while (true)
    {
        auto ch = module->content[module->offset];
        if (!is_hexadecimal(ch))
        {
            break;
        }

        module->offset += 1;
        value = accumulate_hexadecimal(value, ch);
    }

    return value;
}

fn u64 parse_decimal(Module* module)
{
    u64 value = 0;

    while (true)
    {
        auto ch = module->content[module->offset];
        if (!is_decimal(ch))
        {
            break;
        }

        module->offset += 1;
        value = accumulate_decimal(value, ch);
    }

    return value;
}

fn Token tokenize(Module* module)
{
    skip_space(module);

    auto start_index = module->offset;
    if (start_index == module->content.length)
    {
        report_error();
    }

    auto start_character = module->content[start_index];

    Token token;

    switch (start_character)
    {
        case ';':
            {
                module->offset += 1;
                token = {
                    .id = TokenId::end_of_statement,
                };
            } break;
        case right_brace:
            {
                module->offset += 1;
                token = {
                    .id = TokenId::right_brace,
                };
            } break;
        case right_parenthesis:
            {
                module->offset += 1;
                token = {
                    .id = TokenId::right_parenthesis,
                };
            } break;
        case right_bracket:
            {
                module->offset += 1;
                token = {
                    .id = TokenId::right_bracket,
                };
            } break;
        case '#':
            {
                module->offset += 1;
                if (is_identifier_start(module->content[module->offset]))
                {
                    auto identifier = parse_identifier(module);

                    String value_intrinsics[] = {
                        str("align_of"),
                        str("byte_size"),
                        str("enum_name"),
                        str("extend"),
                        str("integer_max"),
                        str("int_from_enum"),
                        str("int_from_pointer"),
                        str("pointer_cast"),
                        str("select"),
                        str("string_to_enum"),
                        str("trap"),
                        str("truncate"),
                        str("va_start"),
                        str("va_end"),
                        str("va_arg"),
                        str("va_copy"),
                    };

                    backing_type(ValueIntrinsic) i;
                    for (i = 0; i < (backing_type(ValueIntrinsic))(ValueIntrinsic::count); i += 1)
                    {
                        String candidate = value_intrinsics[i];
                        if (identifier.equal(candidate))
                        {
                            break;
                        }
                    }

                    auto intrinsic = (ValueIntrinsic)i;
                    if (intrinsic == ValueIntrinsic::count)
                    {
                        report_error();
                    }

                    token = {
                        .value_intrinsic = intrinsic,
                        .id = TokenId::value_intrinsic,
                    };
                }
                else
                {
                    trap_raw();
                }
            } break;
        case '<':
            {
                auto next_ch = module->content[start_index + 1];
                TokenId id;
                switch (next_ch)
                {
                    case '<':
                        switch (module->content[start_index + 2])
                        {
                            case '=': id = TokenId::assign_shift_left; break;
                            default: id = TokenId::shift_left; break;
                        } break;
                    case '=': id = TokenId::compare_less_equal; break;
                    default: id = TokenId::compare_less; break;
                }

                u64 add;
                switch (id)
                {
                    case TokenId::assign_shift_left: add = 3; break;
                    case TokenId::shift_left:
                    case TokenId::compare_less_equal: add = 2; break;
                    case TokenId::compare_less: add = 1; break;
                    default: unreachable();
                }

                module->offset += add;
                token = {
                    .id = id,
                };
            } break;
        case '>':
            {
                auto next_ch = module->content[start_index + 1];
                TokenId id;
                switch (next_ch)
                {
                    case '>':
                        switch (module->content[start_index + 2])
                        {
                            case '=': id = TokenId::assign_shift_right; break;
                            default: id = TokenId::shift_right; break;
                        } break;
                    case '=': id = TokenId::compare_greater_equal; break;
                    default: id = TokenId::compare_greater; break;
                }

                u64 add;
                switch (id)
                {
                    case TokenId::assign_shift_right: add = 3; break;
                    case TokenId::shift_right:
                    case TokenId::compare_greater_equal: add = 2; break;
                    case TokenId::compare_greater: add = 1; break;
                    default: unreachable();
                }

                module->offset += add;
                token = {
                    .id = id,
                };
            } break;
        case '=':
            {
                trap_raw();
            } break;
        case '.':
            {
                auto next_ch = module->content[start_index + 1];
                TokenId id;
                switch (next_ch)
                {
                    default: id = TokenId::dot; break;
                    case '&': id = TokenId::pointer_dereference; break;
                    case '.':
                        switch (module->content[start_index + 2])
                        {
                            case '.': id = TokenId::triple_dot; break;
                            default: id = TokenId::double_dot; break;
                        } break;
                }

                u64 add;
                switch (id)
                {
                    case TokenId::dot: add = 1; break;
                    case TokenId::double_dot: add = 2; break;
                    case TokenId::triple_dot: add = 3; break;
                    case TokenId::pointer_dereference: add = 2; break;
                    default: unreachable();
                }
                module->offset += add;

                token = {
                    .id = id,
                };
            } break;
        case '"':
            {
                trap_raw();
            } break;
        case '\'':
            {
                trap_raw();
            } break;
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            {
                auto next_ch = module->content[start_index + 1];
                TokenIntegerKind token_integer_kind = TokenIntegerKind::decimal;
                if (start_character == '0')
                {
                    switch (next_ch)
                    {
                        case 'x': token_integer_kind = TokenIntegerKind::hexadecimal; break;
                        case 'd': token_integer_kind = TokenIntegerKind::decimal; break;
                        case 'o': token_integer_kind = TokenIntegerKind::octal; break;
                        case 'b': token_integer_kind = TokenIntegerKind::octal; break;
                        default: token_integer_kind = TokenIntegerKind::decimal; break;
                    }
                    auto inferred_decimal = token_integer_kind == TokenIntegerKind::decimal && next_ch != 'd';
                    module->offset += 2 * (token_integer_kind != TokenIntegerKind::decimal || !inferred_decimal);
                }

                u64 value;
                switch (token_integer_kind)
                {
                    case TokenIntegerKind::hexadecimal: value = parse_hexadecimal(module); break;
                    case TokenIntegerKind::decimal: value = parse_decimal(module); break;
                    case TokenIntegerKind::octal:
                        {
                            trap_raw();
                        } break;
                    case TokenIntegerKind::binary:
                        {
                            trap_raw();
                        } break;
                }

                token = {
                    .integer = {
                        .value = value,
                        .kind = token_integer_kind,
                    },
                    .id = TokenId::integer,
                };
            } break;
        case '+':
        case '-':
        case '*':
        case '/':
        case '%':
        case '&':
        case '|':
        case '^':
        case '!':
            {
                auto next_ch = module->content[start_index + 1];
                TokenId id;
                if (next_ch == '=')
                {
                    switch (start_character)
                    {
                        case '+': id = TokenId::assign_plus; break;
                        case '-': id = TokenId::assign_dash; break;
                        case '*': id = TokenId::assign_asterisk; break;
                        case '/': id = TokenId::assign_forward_slash; break;
                        case '%': id = TokenId::assign_percentage; break;
                        case '&': id = TokenId::assign_ampersand; break;
                        case '|': id = TokenId::assign_bar; break;
                        case '^': id = TokenId::assign_caret; break;
                        case '!': id = TokenId::assign_exclamation; break;
                        default: unreachable();
                    }
                }
                else
                {
                    switch (start_character)
                    {
                        case '+': id = TokenId::plus; break;
                        case '-': id = TokenId::dash; break;
                        case '*': id = TokenId::asterisk; break;
                        case '/': id = TokenId::forward_slash; break;
                        case '%': id = TokenId::percentage; break;
                        case '&': id = TokenId::ampersand; break;
                        case '|': id = TokenId::bar; break;
                        case '^': id = TokenId::caret; break;
                        case '!': id = TokenId::exclamation; break;
                        default: unreachable();
                    }
                }

                token.id = id;

                module->offset += 1 + (next_ch == '=');
            } break;
        default:
            {
                if (is_identifier_start(start_character))
                {
                    auto identifier = parse_identifier(module);

                    String value_keywords[] = {
                        str("undefined"),
                        str("unreachable"),
                        str("zero"),
                    };
                    static_assert(array_length(value_keywords) == (u64)ValueKeyword::count);

                    backing_type(ValueKeyword) i;
                    for (i = 0; i < (backing_type(ValueKeyword))ValueKeyword::count; i += 1)
                    {
                        String candidate = value_keywords[i];
                        if (candidate.equal(identifier))
                        {
                            break;
                        }
                    }

                    auto value_keyword = (ValueKeyword)i;

                    if (value_keyword == ValueKeyword::count)
                    {
                        String operators[] = {
                            str("and"),
                            str("or"),
                            str("and?"),
                            str("or?"),
                        };
                        static_assert(array_length(operators) == (u64)OperatorKeyword::count);

                        backing_type(OperatorKeyword) i;
                        for (i = 0; i < (backing_type(OperatorKeyword))OperatorKeyword::count; i += 1)
                        {
                            auto candidate = operators[i];
                            if (candidate.equal(identifier))
                            {
                                break;
                            }
                        }

                        auto operator_keyword = (OperatorKeyword)i;
                        if (operator_keyword == OperatorKeyword::count)
                        {
                            token = {
                                .identifier = identifier,
                                .id = TokenId::identifier,
                            };
                        }
                        else
                        {
                            token = {
                                .operator_keyword = operator_keyword,
                                .id = TokenId::operator_keyword,
                            };
                        }
                    }
                    else
                    {
                        token = {
                            .value_keyword = value_keyword,
                            .id = TokenId::value_keyword,
                        };
                    }
                }
                else
                {
                    report_error();
                }
            } break;
    }

    assert(start_index != module->offset);
    return token;
}

fn Value* reference_identifier(Module* module, Scope* current_scope, String identifier, ValueKind kind)
{
    assert(!identifier.equal(str("")));
    assert(!identifier.equal(str("_")));

    Variable* variable = 0;

    for (Scope* scope = current_scope; scope; scope = scope->parent)
    {
        switch (scope->kind)
        {
            case ScopeKind::global:
                {
                    assert(module == scope_to_module(scope));
                    trap_raw();
                } break;
            case ScopeKind::function:
                {
                    assert(scope->parent);
                    auto function = scope_to_function(scope);
                    for (auto argument: function->arguments)
                    {
                        if (identifier.equal(argument->variable.name))
                        {
                            variable = &argument->variable;
                            break;
                        }
                    }
                } break;
            case ScopeKind::local:
                {
                    assert(scope->parent);
                    assert(scope->parent->kind != ScopeKind::global);

                    auto block = scope_to_block(scope);
                    for (Local* local = block->first_local; local; local = local->next)
                    {
                        if (identifier.equal(local->variable.name))
                        {
                            variable = &local->variable;
                            break;
                        }
                    }
                } break;
            case ScopeKind::for_each:
                {
                    trap_raw();
                } break;
            case ScopeKind::macro_declaration:
                {
                    trap_raw();
                } break;
            case ScopeKind::macro_instantiation:
                {
                    trap_raw();
                } break;
        }

        if (variable)
        {
            break;
        }
    }

    if (variable)
    {
        auto result = new_value(module);
        *result = {
            .variable_reference = variable,
            .id = ValueId::variable_reference,
            .kind = kind,
        };
        return result;
    }
    else
    {
        report_error();
    }
}
fn Value* parse_value(Module* module, Scope* scope, ValueBuilder builder);

fn Value* parse_precedence(Module* module, Scope* scope, ValueBuilder builder);
fn Value* parse_left(Module* module, Scope* scope, ValueBuilder builder)
{
    Token token = builder.token;
    Value* result;
    switch (token.id)
    {
        case TokenId::integer:
            {
                auto integer_value = token.integer.value;
                result = new_value(module);
                *result = {
                    .constant_integer = {
                        .value = integer_value,
                        .is_signed = false,
                    },
                    .id = ValueId::constant_integer,
                    .kind = ValueKind::right,
                };
            } break;
        case TokenId::dash:
        case TokenId::ampersand:
            // Unary
            {
                assert(!builder.left);
                UnaryId id;
                switch (token.id)
                {
                    case TokenId::dash: id = UnaryId::minus; break;
                    case TokenId::ampersand: id = UnaryId::ampersand; break;
                    default: unreachable();
                }

                auto unary_value = parse_precedence(module, scope, builder.with_precedence(Precedence::prefix).with_token({}).with_kind(token.id == TokenId::ampersand ? ValueKind::left : builder.kind));

                result = new_value(module);
                *result = {
                    .unary = {
                        .value = unary_value,
                        .id = id,
                    },
                    .id = ValueId::unary,
                    .kind = ValueKind::right,
                };
            } break;
        case TokenId::identifier:
            {
                result = reference_identifier(module, scope, token.identifier, builder.kind);
            } break;
        case TokenId::value_intrinsic:
            {
                ValueIntrinsic intrinsic = token.value_intrinsic;
                switch (intrinsic)
                {
                    case ValueIntrinsic::align_of:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::byte_size:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::enum_name:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::extend:
                    case ValueIntrinsic::truncate:
                        {
                            skip_space(module);
                            expect_character(module, left_parenthesis);
                            skip_space(module);
                            auto argument = parse_value(module, scope, {});
                            expect_character(module, right_parenthesis);
                            result = new_value(module);

                            UnaryId id;
                            switch (intrinsic)
                            {
                                case ValueIntrinsic::extend: id = UnaryId::extend; break;
                                case ValueIntrinsic::truncate: id = UnaryId::truncate; break;
                                default: unreachable();
                            }

                            *result = {
                                .unary = {
                                    .value = argument,
                                    .id = id,
                                },
                                .id = ValueId::unary,
                            };
                        } break;
                    case ValueIntrinsic::integer_max:
                        {
                            skip_space(module);
                            expect_character(module, left_parenthesis);
                            skip_space(module);
                            auto type = parse_type(module);
                            expect_character(module, right_parenthesis);
                            result = new_value(module);
                            *result = {
                                .unary_type = {
                                    .type = type,
                                    .id = UnaryTypeId::integer_max,
                                },
                                .id = ValueId::unary_type,
                            };
                        } break;
                    case ValueIntrinsic::int_from_enum:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::int_from_pointer:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::pointer_cast:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::select:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::string_to_enum:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::trap:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::va_start:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::va_end:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::va_arg:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::va_copy:
                        {
                            trap_raw();
                        } break;
                    case ValueIntrinsic::count: unreachable();
                }
            } break;
        default: report_error();
    }

    return result;
}

fn Precedence get_token_precedence(TokenId id)
{
    Precedence precedence;

    switch (id)
    {
        case TokenId::none: unreachable();
        case TokenId::end_of_statement:
        case TokenId::right_brace:
        case TokenId::right_bracket:
        case TokenId::right_parenthesis:
            precedence = Precedence::none;
            break;
        case TokenId::ampersand:
        case TokenId::bar:
        case TokenId::caret:
            precedence = Precedence::bitwise;
            break;
        case TokenId::shift_left:
        case TokenId::shift_right:
            precedence = Precedence::shifting;
            break;
        case TokenId::plus:
        case TokenId::dash:
            precedence = Precedence::add_like;
            break;
        case TokenId::asterisk:
        case TokenId::forward_slash:
        case TokenId::percentage:
            precedence = Precedence::div_like;
            break;
        case TokenId::pointer_dereference:
            precedence = Precedence::postfix;
            break;
        default: trap_raw();
    }

    return precedence;
}

fn Value* parse_right(Module* module, Scope* scope, ValueBuilder builder)
{
    auto* left = builder.left;
    assert(left);

    Token token = builder.token;
    Value* result = 0;

    switch (token.id)
    {
        case TokenId::plus:
        case TokenId::dash:
        case TokenId::asterisk:
        case TokenId::forward_slash:
        case TokenId::percentage:
        case TokenId::ampersand:
        case TokenId::bar:
        case TokenId::caret:
        case TokenId::shift_left:
        case TokenId::shift_right:
            // Binary
            {
                auto precedence = get_token_precedence(token.id);
                assert(precedence != Precedence::assignment);

                BinaryId id;
                switch (token.id)
                {
                    case TokenId::plus: id = BinaryId::add; break;
                    case TokenId::dash: id = BinaryId::sub; break;
                    case TokenId::asterisk: id = BinaryId::mul; break;
                    case TokenId::forward_slash: id = BinaryId::div; break;
                    case TokenId::percentage: id = BinaryId::rem; break;
                    case TokenId::ampersand: id = BinaryId::bitwise_and; break;
                    case TokenId::bar: id = BinaryId::bitwise_or; break;
                    case TokenId::caret: id = BinaryId::bitwise_xor; break;
                    case TokenId::shift_left: id = BinaryId::shift_left; break;
                    case TokenId::shift_right: id = BinaryId::shift_right; break;

                    default: unreachable();
                }

                auto right_precedence = (Precedence)((backing_type(Precedence))precedence + (precedence != Precedence::assignment));
                auto right = parse_precedence(module, scope, builder.with_precedence(right_precedence).with_token({}).with_left(0));

                result = new_value(module);
                *result = {
                    .binary = {
                        .left = left,
                        .right = right,
                        .id = id,
                    },
                    .id = ValueId::binary,
                    .kind = ValueKind::right,
                };
            } break;
        case TokenId::pointer_dereference:
            {
                result = new_value(module);
                *result = {
                    .dereference = left,
                    .id = ValueId::dereference,
                    .kind = ValueKind::right,
                };
            } break;
        default: report_error();
    }

    return result;
}

fn Value* parse_precedence_left(Module* module, Scope* scope, ValueBuilder builder)
{
    auto result = builder.left;
    auto precedence = builder.precedence;

    while (1)
    {
        auto checkpoint = get_checkpoint(module);
        auto token = tokenize(module);
        auto token_precedence = get_token_precedence(token.id);
        if (token_precedence == Precedence::assignment)
        {
            token_precedence = builder.allow_assignment_operators ? Precedence::assignment : Precedence::none;
        }

        if ((backing_type(Precedence))precedence > (backing_type(Precedence))token_precedence)
        {
            set_checkpoint(module, checkpoint);
            break;
        }

        auto left = result;
        auto right = parse_right(module, scope, builder.with_token(token).with_precedence(Precedence::none).with_left(left));
        result = right;
    }

    return result;
}

fn Value* parse_precedence(Module* module, Scope* scope, ValueBuilder builder)
{
    assert(builder.token.id == TokenId::none);
    auto token = tokenize(module);
    auto left = parse_left(module, scope, builder.with_token(token));
    auto result = parse_precedence_left(module, scope, builder.with_left(left));
    return result;
}

fn Value* parse_value(Module* module, Scope* scope, ValueBuilder builder)
{
    assert(builder.precedence == Precedence::none);
    assert(!builder.left);
    auto value = parse_precedence(module, scope, builder.with_precedence(Precedence::assignment));
    return value;
}

global_variable constexpr auto invalid_argument_index = ~(u32)0;

fn Statement* parse_statement(Module* module, Scope* scope)
{
    bool require_semicolon = true;

    auto statement_line = get_line(module);
    auto statement_column = get_column(module);

    auto* statement = &arena_allocate<Statement>(module->arena, 1)[0];
    *statement = Statement{
        .line = statement_line,
        .column = statement_column,
    };

    auto statement_start_character = module->content[module->offset];
    switch (statement_start_character)
    {
        case '>':
            {
                module->offset += 1;
                skip_space(module);

                auto local_name = parse_identifier(module);
                skip_space(module);

                Type* local_type = 0;
                if (consume_character_if_match(module, ':'))
                {
                    skip_space(module);
                    local_type = parse_type(module);
                    skip_space(module);
                }
                expect_character(module, '=');
                auto initial_value = parse_value(module, scope, {});

                auto local = new_local(module, scope);
                *local = {
                    .variable = {
                        .storage = 0,
                        .initial_value = initial_value,
                        .type = local_type,
                        .scope = scope,
                        .name = local_name,
                        .line = statement_line,
                        .column = statement_column,
                    },
                    .argument_index = invalid_argument_index,
                };
                statement->local = local;
                statement->id = StatementId::local;
            } break;
        case '#':
            {
                trap_raw();
            } break;
        case left_brace:
            {
                trap_raw();
            } break;
        default:
            {
                if (is_identifier_start(statement_start_character))
                {
                    auto checkpoint = get_checkpoint(module);
                    auto statement_start_identifier = parse_identifier(module);
                    skip_space(module);

                    enum class StatementStartKeyword
                    {
                        underscore_st,
                        return_st,
                        if_st,
                        // TODO: make `unreachable` a statement start keyword?
                        for_st,
                        while_st,
                        switch_st,
                        break_st,
                        continue_st,
                        count,
                    };

                    String statement_start_keywords[] = {
                        str("_"),
                        str("return"),
                        str("if"),
                        str("for"),
                        str("while"),
                        str("switch"),
                        str("break"),
                        str("continue"),
                    };

                    static_assert(array_length(statement_start_keywords) == (u64)StatementStartKeyword::count);

                    backing_type(StatementStartKeyword) i;
                    for (i = 0; i < (backing_type(StatementStartKeyword))StatementStartKeyword::count; i += 1)
                    {
                        auto statement_start_keyword = statement_start_keywords[i];
                        if (statement_start_keyword.equal(statement_start_identifier))
                        {
                            break;
                        }
                    }

                    auto statement_start_keyword = (StatementStartKeyword)i;
                    switch (statement_start_keyword)
                    {
                        case StatementStartKeyword::underscore_st:
                            {
                                trap_raw();
                            } break;
                        case StatementStartKeyword::return_st:
                            {
                                auto return_value = parse_value(module, scope, {});
                                statement->return_st = return_value;
                                statement->id = StatementId::return_st;
                            } break;
                        case StatementStartKeyword::if_st:
                            {
                                trap_raw();
                            } break;
                        case StatementStartKeyword::for_st:
                            {
                                trap_raw();
                            } break;
                        case StatementStartKeyword::while_st:
                            {
                                trap_raw();
                            } break;
                        case StatementStartKeyword::switch_st:
                            {
                                trap_raw();
                            } break;
                        case StatementStartKeyword::break_st:
                            {
                                trap_raw();
                            } break;
                        case StatementStartKeyword::continue_st:
                            {
                                trap_raw();
                            } break;
                        case StatementStartKeyword::count:
                            {
                                trap_raw();
                            } break;
                    }
                }
                else
                {
                    trap_raw();
                }
            } break;
    }

    if (require_semicolon)
    {
        expect_character(module, ';');
    }

    return statement;
}

fn Block* parse_block(Module* module, Scope* parent_scope)
{
    auto* block = &arena_allocate<Block>(module->arena, 1)[0];
    *block = {
        .scope = {
            .parent = parent_scope,
            .line = get_line(module),
            .column = get_column(module),
            .kind = ScopeKind::local,
        },
    };
    auto* scope = &block->scope;

    expect_character(module, left_brace);

    Statement* current_statement = 0;

    while (true)
    {
        skip_space(module);

        if (module->offset == module->content.length)
        {
            break;
        }

        if (consume_character_if_match(module, right_brace))
        {
            break;
        }

        auto* statement = parse_statement(module, scope);

        if (current_statement)
        {
            current_statement->next = statement;
        }

        current_statement = statement;
    }

    return block;
}

void parse(Module* module)
{
    while (1)
    {
        skip_space(module);

        if (module->offset == module->content.length)
        {
            break;
        }

        bool is_export = false;
        bool is_extern = false;

        auto global_line = get_line(module);
        auto global_column = get_column(module);

        if (consume_character_if_match(module, left_bracket))
        {
            while (module->offset < module->content.length)
            {
                auto global_keyword_string = parse_identifier(module);
                enum class GlobalKeyword
                {
                    export_keyword,
                    extern_keyword,
                    count,
                };
                String global_keyword_strings[] = {
                    str("export"),
                    str("extern"),
                };
                static_assert(array_length(global_keyword_strings) == (u64)GlobalKeyword::count);

                u32 i;
                for (i = 0; i < array_length(global_keyword_strings); i += 1)
                {
                    String keyword = global_keyword_strings[i];
                    if (keyword.equal(global_keyword_string))
                    {
                        break;
                    }
                }

                auto global_keyword = (GlobalKeyword)i;
                switch (global_keyword)
                {
                    case GlobalKeyword::export_keyword:
                        {
                            is_export = true;
                        } break;
                    case GlobalKeyword::extern_keyword:
                        {
                            is_extern = true;
                        } break;
                    case GlobalKeyword::count:
                        {
                            report_error();
                        }
                }

                if (consume_character_if_match(module, right_bracket))
                {
                    break;
                }
                else
                {
                    report_error();
                }
            }

            skip_space(module);
        }

        auto global_name = parse_identifier(module);

        Global* last_global = module->first_global;
        while (last_global)
        {
            if (global_name.equal(last_global->variable.name))
            {
                report_error();
            }

            if (!last_global->next)
            {
                break;
            }

            last_global = last_global->next;
        }

        Type* type_it = module->first_type;
        Type* forward_declaration = 0;
        while (type_it)
        {
            if (global_name.equal(type_it->name))
            {
                if (type_it->id == TypeId::forward_declaration)
                {
                    forward_declaration = type_it;
                    break;
                }
                else
                {
                    report_error();
                }
            }

            if (!type_it->next)
            {
                break;
            }

            type_it = type_it->next;
        }

        skip_space(module);

        Type* global_type = 0;

        if (consume_character_if_match(module, ':'))
        {
            skip_space(module);

            global_type = parse_type(module);

            skip_space(module);
        }

        expect_character(module, '=');

        skip_space(module);

        bool is_global_keyword = false;

        enum class GlobalKeyword
        {
            bits,
            enumerator,
            function,
            macro,
            structure,
            typealias,
            union_type,
            count,
        };

        auto i = (backing_type(GlobalKeyword))GlobalKeyword::count;

        if (is_identifier_start(module->content[module->offset]))
        {
            auto checkpoint = get_checkpoint(module);
            auto global_string = parse_identifier(module);
            skip_space(module);

            String global_keywords[] = {
                str("bits"),
                str("enum"),
                str("fn"),
                str("macro"),
                str("struct"),
                str("typealias"),
                str("union"),
            };
            static_assert(array_length(global_keywords) == (u64)GlobalKeyword::count);

            for (i = 0; i < (backing_type(GlobalKeyword))GlobalKeyword::count; i += 1)
            {
                String global_keyword = global_keywords[i];
                if (global_string.equal(global_keyword))
                {
                    break;
                }
            }

            auto global_keyword = (GlobalKeyword)i;
            switch (global_keyword)
            {
                case GlobalKeyword::bits:
                    {
                        trap_raw();
                    } break;
                case GlobalKeyword::enumerator:
                    {
                        trap_raw();
                    } break;
                case GlobalKeyword::function:
                    {
                        auto calling_convention = CallingConvention::c;
                        auto function_attributes = FunctionAttributes{};
                        bool is_variable_arguments = false;

                        if (consume_character_if_match(module, left_bracket))
                        {
                            while (module->offset < module->content.length)
                            {
                                auto function_identifier = parse_identifier(module);

                                enum class FunctionKeyword
                                {
                                    cc,
                                    count,
                                };

                                String function_keywords[] = {
                                    str("cc"),
                                };
                                static_assert(array_length(function_keywords) == (u64)FunctionKeyword::count);

                                backing_type(FunctionKeyword) i;
                                for (i = 0; i < (backing_type(FunctionKeyword))(FunctionKeyword::count); i += 1)
                                {
                                    auto function_keyword = function_keywords[i];
                                    if (function_keyword.equal(function_identifier))
                                    {
                                        break;
                                    }
                                }

                                auto function_keyword = (FunctionKeyword)i;
                                skip_space(module);

                                switch (function_keyword)
                                {
                                    case FunctionKeyword::cc:
                                        {
                                            expect_character(module, left_parenthesis);
                                            skip_space(module);
                                            auto calling_convention_string = parse_identifier(module);
                                            String calling_conventions[] = {
                                                str("c"),
                                            };
                                            static_assert(array_length(calling_conventions) == (u64)CallingConvention::count);

                                            backing_type(CallingConvention) i;
                                            for (i = 0; i < (backing_type(CallingConvention))CallingConvention::count; i += 1)
                                            {
                                                auto calling_convention = calling_conventions[i];
                                                if (calling_convention.equal(calling_convention_string))
                                                {
                                                    break;
                                                }
                                            }

                                            auto candidate_calling_convention = (CallingConvention)i;
                                            if (candidate_calling_convention == CallingConvention::count)
                                            {
                                                report_error();
                                            }

                                            calling_convention = candidate_calling_convention;

                                            skip_space(module);
                                            expect_character(module, right_parenthesis);
                                        } break;
                                    case FunctionKeyword::count:
                                        {
                                            report_error();
                                        } break;
                                }

                                skip_space(module);

                                if (consume_character_if_match(module, right_bracket))
                                {
                                    break;
                                }
                                else
                                {
                                    report_error();
                                }
                            }
                        }

                        skip_space(module);

                        expect_character(module, left_parenthesis);

                        Type* semantic_argument_type_buffer[64];
                        String semantic_argument_name_buffer[64];
                        u64 semantic_argument_count = 0;

                        while (module->offset < module->content.length)
                        {
                            skip_space(module);

                            if (consume_character_if_match(module, '.'))
                            {
                                expect_character(module, '.');
                                expect_character(module, '.');
                                skip_space(module);
                                expect_character(module, right_parenthesis);
                                is_variable_arguments = true;
                                break;
                            }

                            if (consume_character_if_match(module, right_parenthesis))
                            {
                                break;
                            }

                            auto argument_name = parse_identifier(module);
                            semantic_argument_name_buffer[semantic_argument_count] = argument_name;

                            skip_space(module);

                            expect_character(module, ':');

                            skip_space(module);

                            auto argument_type = parse_type(module);
                            semantic_argument_type_buffer[semantic_argument_count] = argument_type;

                            skip_space(module);

                            unused(consume_character_if_match(module, ','));

                            semantic_argument_count += 1;
                        }

                        skip_space(module);

                        auto return_type = parse_type(module);

                        skip_space(module);

                        Slice<Type*> argument_types = {};
                        if (semantic_argument_count != 0)
                        {
                            trap_raw();
                        }

                        auto is_declaration = consume_character_if_match(module, ';');

                        auto function_type = type_allocate_init(module, {
                            .function = {
                                .semantic_return_type = return_type,
                                .semantic_argument_types = argument_types,
                                .calling_convention = calling_convention,
                                .is_variable_arguments = is_variable_arguments,
                            },
                            .id = TypeId::function,
                            .name = str(""),
                        });

                        auto storage = new_value(module);
                        *storage = {
                            .type = get_pointer_type(module, function_type),
                            .id = ValueId::external_function,
                            // TODO? .kind = ValueKind::left,
                        };
                        auto global = new_global(module);
                        *global = {
                            .variable = {
                                .storage = storage,
                                .initial_value = 0,
                                .type = function_type,
                                .scope = &module->scope,
                                .name = global_name,
                                .line = global_line,
                                .column = global_column,
                            },
                            .linkage = (is_export | is_extern) ? Linkage::external : Linkage::internal,
                        };
                        module->current_function = global;

                        if (!is_declaration)
                        {
                            storage->function = {
                                .arguments = {},
                                .scope = {
                                    .parent = &module->scope,
                                    .line = global_line,
                                    .column = global_column,
                                    .kind = ScopeKind::function,
                                },
                                .block = 0,
                                .attributes = function_attributes,
                            };
                            storage->id = ValueId::function;

                            if (semantic_argument_count != 0)
                            {
                                trap_raw();
                            }

                            storage->function.block = parse_block(module, &storage->function.scope);
                        }
                    } break;
                case GlobalKeyword::macro:
                    {
                        trap_raw();
                    } break;
                case GlobalKeyword::structure:
                    {
                        trap_raw();
                    } break;
                case GlobalKeyword::typealias:
                    {
                        trap_raw();
                    } break;
                case GlobalKeyword::union_type:
                    {
                        trap_raw();
                    } break;
                case GlobalKeyword::count:
                    {
                        set_checkpoint(module, checkpoint);
                    } break;
            }
        }

        if (i == (backing_type(GlobalKeyword))GlobalKeyword::count)
        {
            trap_raw();
        }
    }
}