// @todo @cleanup
// :PrinterCleanup
// Instead of relying on global state, this probably should
// use a String_Builder or some kind of Builder context + macros
#define gen(...) pctx->gen.addf(__VA_ARGS__)
#define genln(...)        \
    do {                  \
        gen("\n");        \
        gen_indent();     \
        gen(__VA_ARGS__); \
    } while (0)
global S32 global_indent;
global S32 is_inside_struct;
/*@language_refactor: Add context to typechecking and codegen, use arrays to construct stacks
  instead of passing arguments to functions you use the context stacks
*/

CORE_Static void gen_ast(Ast *ast);
CORE_Static bool gen_expr(Ast_Expr *ast);

CORE_Static void
gen_indent() {
    for (S32 i = 0; i < global_indent; i++) gen("  ");
}

global Intern_String last_filename;
global int last_line;
CORE_Static void
gen_line(Ast *node) {
    if (pctx->emit_line_directives) {
        last_line = node->pos->line + 1;
        genln("#line %d", last_line);
        if (node->pos->file != last_filename) {
            last_filename = node->pos->file;
            gen(" \"%Q\"", last_filename);
        }
    }
}

CORE_Static void
gen_last_line() {
    if (pctx->emit_line_directives) {
        genln("#line %d", last_line);
    }
}

CORE_Static const char *
get_ctype_name_for_type(Ast_Type *type) {
    switch (type->kind) {
        case TYPE_VOID: return "void";
        case TYPE_BOOL: return "bool";
        case TYPE_STRING: return "String";
        case TYPE_F32: return "float";
        case TYPE_F64: return "double";

        case TYPE_CHAR: return "char";
        case TYPE_UCHAR: return "unsigned char";
        case TYPE_INT: return "int";
        case TYPE_UINT: return "unsigned int";
        case TYPE_LONG: return "long";
        case TYPE_ULONG: return "unsigned long";
        case TYPE_LLONG: return "long long";
        case TYPE_ULLONG: return "unsigned long long";
        case TYPE_SHORT: return "short";
        case TYPE_USHORT: return "unsigned short";

        case TYPE_S8: return "int8_t";
        case TYPE_S16: return "int16_t";
        case TYPE_S32: return "int32_t";
        case TYPE_S64: return "int64_t";
        case TYPE_U8: return "uint8_t";
        case TYPE_U16: return "uint16_t";
        case TYPE_U32: return "uint32_t";
        case TYPE_U64: return "uint64_t";
        case TYPE_TYPE: return "int64_t";

        case TYPE_INCOMPLETE: {
            // This happens in case where we have a procedure in an away module.
            // Meaning that it's not resolved fully on purpose (treeshaking).
            // And that procedure takes a pointer from a struct that is never
            // used elsewhere. In that case this seems fine.
            return "void";
        }
            invalid_default_case;
    }
    return "<unknown_type>";
}

CORE_Static String
string_simple_decl_prefix(Ast_Type *ast) {
    switch (ast->kind) {
        case TYPE_POINTER: {
            String string = string_simple_decl_prefix(ast->base);
            string = pctx->fmt("%Q*", string);
            return string;
        } break;
        case TYPE_LAMBDA: return {}; break;
        case TYPE_ENUM:
        case TYPE_ARRAY: {
            return string_simple_decl_prefix(ast->base);
        } break;
        case TYPE_SLICE: {
            String string = string_simple_decl_prefix(ast->base);
            string = pctx->fmt("Slice%llu ", ast->type_id);
            return string;
        } break;
        case TYPE_UNION:
        case TYPE_STRUCT: {
            auto constant = (Ast_Decl *)ast->ast;
            auto name = constant->unique_name;
            String string = pctx->fmt("%Q ", name);
            String sc = {};
            return pctx->fmt("%Q%Q", sc, string);
        } break;
        default: {
            String string = pctx->fmt("%s ", get_ctype_name_for_type(ast));
            return string;
        }
    }
    return {};
}

CORE_Static String
string_simple_decl_postfix(Ast_Type *ast) {
    switch (ast->kind) {
        case TYPE_POINTER:
            return string_simple_decl_postfix(ast->base);
            break;
        case TYPE_ARRAY: {
            String result = string_simple_decl_postfix(ast->arr.base);
            String string = pctx->fmt("[%d]%Q", ast->arr.size, result);
            return string;
        } break;
        case TYPE_LAMBDA: break;
        case TYPE_SLICE:
        case TYPE_ENUM:
        case TYPE_STRUCT: break;
        default:
            break;
            // default: return string_from_cstring((char *)name(ast));
    }
    return {};
}

CORE_Static String
string_simple_decl(Ast_Type *ast, Intern_String name = {}) {
    if (ast->kind == TYPE_LAMBDA) {
        String prefix = string_simple_decl_prefix(ast->func.ret);
        String string = pctx->fmt("%Q(*%Q)(", prefix, name);
        For(ast->func.args) {
            String prefix_arg = string_simple_decl_prefix(it);
            string = pctx->fmt("%Q%Q", string, prefix_arg);
            if (&it != ast->func.args.end() - 1)
                string = pctx->fmt("%Q, ", string);
        }
        string = pctx->fmt("%Q)", string);
        return string;
    }
    else {
        String string = string_simple_decl_prefix(ast);
        if (name.len) {
            string = pctx->fmt("%Q%Q", string, name);
        }
        String postfix = string_simple_decl_postfix(ast);
        string = pctx->fmt("%Q%Q", string, postfix);
        return string;
    }
}

CORE_Static void
gen_simple_decl(Ast_Type *ast, Intern_String name = {}) {
    String string = string_simple_decl(ast, name);
    gen("%Q", string);
}

CORE_Static String
get_type_postfix(Ast_Type *type) {
    switch (type->kind) {
        case TYPE_F32: return "f"_s; break;
        case TYPE_ULLONG:
        case TYPE_U64: return "ULL"_s; break;
        case TYPE_LLONG:
        case TYPE_S64: return "LL"_s; break;
        case TYPE_U8:
        case TYPE_UCHAR:
        case TYPE_U16:
        case TYPE_UINT:
        case TYPE_U32: return "U"_s; break;

        case TYPE_SHORT:
        case TYPE_LONG:
        case TYPE_F64:
        case TYPE_S8:
        case TYPE_S16:
        case TYPE_S32:
        case TYPE_INT:
        case TYPE_CHAR:
            return ""_s;
            break;
            invalid_default_case;
    }
    assert(!"Unhandled case or error");
    return ""_s;
}

CORE_Static B32
gen_value(Token *pos, Value a) {
    if (is_untyped(a.type)) compiler_error(pos, "Internal compiler error: Untyped got propagated to the codegen stage");

    B32 result = true;
    Ast_Type *type = a.type;
    if (is_enum(a.type)) {
        type = a.type->base;
    }

    switch (type->kind) {
    CASE_INT : {
        Scoped_Arena scratch(pctx->scratch);
        String postfix = get_type_postfix(type);
        const char *string = bigint_to_error_string(scratch.arena, &a.big_int_val, 10);
        gen("%s%Q", string, postfix);
    } break;
    case TYPE_POINTER: {
        if (a.type == pctx->type_pointer_to_char) {
            gen("\"%Q\"", a.intern_val);
        }
        else {
            U64 pointer_value = bigint_as_unsigned(&a.big_int_val);
            gen("0x%llx", pointer_value);
        }
    } break;
    CASE_BOOL : {
        a.bool_val ? gen("true") : gen("false");
    } break;
    CASE_FLOAT : {
        String postfix = get_type_postfix(type);
        gen("%f%Q", a.f64_val, postfix);
    } break;
    case TYPE_TYPE: {
        gen("%d", a.type_val->type_id);
    } break;
    default: {
        if (is_string(type)) {
            int length = 0;
            gen("CORE_ConditionalCompound(String){(uint8_t *)\"");
            for (int i = 0; i < a.intern_val.len; i++) {
                if (a.intern_val.str[i] == '\n') {
                    length += 2;
                    gen("\\n");
                }
                else if (a.intern_val.str[i] == '\r') {
                    length += 2;
                    gen("\\r");
                }
                else {
                    length += 1;
                    gen("%c", a.intern_val.str[i]);
                }
            }
            gen("\", %d}", length);
        }
        else result = false;
    }
    }
    return result;
}

CORE_Static void
gen_stmt_scope(Ast_Scope *scope, B32 switch_case_gen_break = 0) {
    gen("{");
    global_indent++;
    For(scope->stmts) {
        gen_line(it);
        genln("");
        gen_ast(it);
    }
    if (switch_case_gen_break == 1) genln("break;");
    global_indent--;
    gen_last_line();
    genln("}");
}

enum {
    ALWAYS_EMIT_VALUE = 0,
    DONT_EMIT_VALUE = 1,
};

CORE_Static void
gen_pointer(Ast_Expr *expr) {
    gen("&");
    if (is_flag_set(expr->flags, AST_IS_LVALUE)) {
        gen_expr(expr);
    }
    else {
        gen("(");
        gen_simple_decl(expr->resolved_type);
        gen(")");
        gen("{");
        gen_expr(expr);
        gen("}");
    }
}

CORE_Static void gen_try_any_or_slice(Ast_Expr *expr, Ast_Type *decl_type);
CORE_Static void
gen_compound(Ast *ast, bool generate_compound_decl = true) {
    assert(ast->kind == AST_COMPOUND);
    auto node = (Ast_Call *)ast;

    bool generated_anything = false;
    bool is_global_variable = node->parent_scope->kind == AST_FILE;
    if (!is_global_variable && generate_compound_decl) {
        gen("(");
        gen_simple_decl(node->resolved_type);
        gen(")");
    }
    gen("{");

    // We need to double wrap it because Any is a pointer
    // We need to pass it a compound array
    if (is_slice(node->resolved_type)) {
        generated_anything = true;
        gen(".len = %d, ", node->exprs.len);
        gen(".data = (");
        gen_simple_decl(node->resolved_type->base);
        gen("[]");
        gen(")");
        gen("{");
    }

    For(node->exprs) {
        generated_anything = true;
        if (is_struct(node->resolved_type) || is_union(node->resolved_type))
            gen(".%Q = ", it->resolved_name);
        else if (is_array(node->resolved_type))
            gen("[%d] = ", (int)it->resolved_index);
        gen_try_any_or_slice(it->item, it->resolved_type);

        if (!node->exprs.is_last(it)) gen(", ");
    }

    if (is_slice(node->resolved_type)) gen("}");
    if (!generated_anything) gen("0");
    gen("}");
}

CORE_Static void
gen_try_any_or_slice(Ast_Expr *expr, Ast_Type *decl_type) {
    // We want normal values to get boxed as Any pointers
    // but other then that we shouldn't box other Any values
    if (expr->kind != AST_COMPOUND && is_any(decl_type) && !is_any(expr->resolved_type)) {
        gen("(Any){");
        gen_pointer(expr);
        gen(", %d}", expr->resolved_type->type_id);
    }
    else if (expr->kind == AST_IDENT && is_slice(decl_type)) {
        Ast_Atom *atom = (Ast_Atom *)expr;
        gen("(");
        gen_simple_decl(decl_type);
        gen(")");
        gen("{%d, ", atom->resolved_type->arr.size);
        gen_expr(expr);
        gen("}");
    }
    else gen_expr(expr);
}

CORE_Static void
gen_var(Ast_Decl *decl, B32 emit_value, B32 scope_names) {
    if (is_flag_set(decl->flags, AST_FOREIGN)) gen("extern ");
    gen_simple_decl(decl->type, decl->unique_name);
    if (is_flag_set(decl->flags, AST_FOREIGN)) return;

    if (emit_value == DONT_EMIT_VALUE) {
        return;
    }

    if (decl->expr) {
        if (is_array(decl->type)) {
            gen_compound((Ast_Call *)decl->expr, false);
        }
        else {
            gen(" = ");
            gen_try_any_or_slice(decl->expr, decl->type);
        }
    }
    else { // Default zero
        if (is_numeric(decl->type)) {
            gen(" = 0");
        }
        else {
            gen(" = {0}");
        }
    }
}

CORE_Static void
gen_lambda(Intern_String name, Ast_Lambda *lambda, B32 generate_block = true) {
    gen_simple_decl(lambda->resolved_type->func.ret, name);
    gen("(");
    if (lambda->args.len == 0) gen("void");
    For(lambda->args) {
        if (it->name == pctx->intern("..."_s)) {
            gen("...");
            continue;
        }
        gen_var(it, DONT_EMIT_VALUE, true);
        if (&it != (lambda->args.end() - 1))
            gen(", ");
    }
    gen(")");

    if (generate_block && lambda->scope) {
        gen_stmt_scope(lambda->scope);
    }
    else gen(";");
}

CORE_Static bool
gen_expr(Ast_Expr *ast) {
    switch (ast->kind) {
        CASE(IDENT, Atom) {
            if (node->resolved_decl->kind == AST_NAMESPACE)
                return false;

            bool is_global_variable = is_flag_set(node->resolved_decl->flags, AST_GLOBAL);
            if (is_global_variable) {
                gen("%Q", node->resolved_decl->unique_name);
            }

            else {
                gen("%Q", node->intern_val);
            }

            BREAK();
        }

        CASE(VALUE, Atom) {
            B32 written = gen_value(node->pos, node->value);
            if (!written) {
                gen("%Q", node->value.intern_val);
            }
            BREAK();
        }

        CASE(ARRAY, Array) {
            gen("%d", node->resolved_type->type_id);
            BREAK();
        }

        CASE(INDEX, Index) {
            gen("(");
            gen_expr(node->expr);
            if (node->index_original_type == pctx->type_string || node->index_original_type == pctx->untyped_string) {
                gen(".data");
            }
            else if (is_slice(node->index_original_type)) {
                gen(".data");
            }
            gen("[");
            gen_expr(node->index);
            gen("]");
            gen(")");
            BREAK();
        }

        CASE(LAMBDA_EXPR, Lambda) {
            gen_lambda({}, node);
            BREAK();
        }

        CASE(BINARY, Binary) {
            if (node->op == TK_Dot) {
                if (gen_expr(node->left)) {
                    if (node->dot_access_step_resolution && node->dot_access_step_resolution->kind == TYPE_POINTER) gen("->");
                    else gen(".");
                }
                gen_expr(node->right);
                return true;
            }

            else if (node->op == TK_Arrow) {
                gen("(");
                gen("(");
                gen_simple_decl(node->resolved_type);
                gen(")");
                gen_expr(node->left);
                gen(")");
                return true;
            }

            else if (node->resolved_operator_overload) {
                gen("%Q(", node->resolved_operator_overload->unique_name);
                gen_expr(node->left);
                gen(", ");
                gen_expr(node->right);
                gen(")");
            }

            else {
                if (!token_is_assign(node->op)) gen("(");
                gen_expr(node->left);
                gen("%s", name(node->op));
                gen_expr(node->right);
                if (!token_is_assign(node->op)) gen(")");
            }

            BREAK();
        }

        CASE(UNARY, Unary) {
            if (node->resolved_operator_overload) {
                gen("%Q(", node->resolved_operator_overload->unique_name);
                gen_expr(node->expr);
                gen(")");
            }

            else {
                gen("(");
                if (node->op != TK_PostIncrement && node->op != TK_PostDecrement) gen("%s", name(node->op));
                gen_expr(node->expr);
                if (node->op == TK_PostIncrement || node->op == TK_PostDecrement) gen("%s", name(node->op));
                gen(")");
            }
            BREAK();
        }

        CASE(VAR, Decl) {
            gen_ast(node);
            BREAK();
        }

        CASE(LENGTH_OF, Call) {
            Ast_Expr *expr = unpack_ast_call_expr_for_builtin(node);
            gen_expr(expr);
            if (is_pointer(expr->resolved_type))
                gen("->len");
            else gen(".len");
            BREAK();
        }

        CASE(CALL, Call) {
            gen("%Q(", node->resolved_decl->unique_name);
            For(node->exprs) {
                gen_try_any_or_slice(it->item, it->resolved_type);
                if (!node->exprs.is_last(it)) gen(", ");
            }
            gen(")");
            BREAK();
        }

        CASE(COMPOUND, Call) {
            gen_compound(node);
            BREAK();
        }

        invalid_default_case;
    }
    return true;
}

/*
- [ ] Assigning arrays to arrays doesn't work in C. Being able to do that seems like a good idea though

*/

CORE_Static void
gen_ast(Ast *ast) {
    switch (ast->kind) {

        CASE(RUNTIME_ASSERT, Builtin) {
            if (node->assert_message.len == 0) gen("Assert");
            else gen("AssertMessage");
            gen("(");
            gen_expr(node->expr);
            if (node->assert_message.len) {
                gen(", \"%Q\"", node->assert_message);
            }
            gen(");");
            BREAK();
        }

        CASE(RETURN, Return) {
            gen("return ");
            if (node->expr) gen_expr(node->expr);
            gen(";");
            BREAK();
        }

        CASE(VAR, Decl) {
            gen_var(node, is_inside_struct ? DONT_EMIT_VALUE : ALWAYS_EMIT_VALUE, true);
            if (!is_flag_set(ast->flags, AST_EXPR)) gen(";");
            BREAK();
        }

        CASE(IF, If) {
            For(node->ifs) {
                gen_line(it);
                genln("");
                if (it->init) {
                    gen_expr(it->init);
                    gen(";");
                    genln("");
                }
                if (node->ifs.is_first(it)) {
                    gen("if(");
                    gen_expr(it->expr);
                    gen(")");
                    gen_stmt_scope(it->scope);
                }
                else {
                    gen("else");
                    if (it->expr) {
                        gen(" if(");
                        gen_expr(it->expr);
                        gen(")");
                    }
                    gen_stmt_scope(it->scope);
                }
            }
            BREAK();
        }

        CASE(CONTINUE, Pass) {
            unused(node);
            gen("continue;");
            BREAK();
        }
        CASE(BREAK, Break) {
            unused(node);
            gen("break;");
            BREAK();
        }

        CASE(COMPILER_BREAKPOINT_STMT, Break) {
            unused(node);
            __debugbreak();
            BREAK();
        }

        CASE(PASS, Pass) {
            unused(node);
            gen("//pass");
            BREAK();
        }

        CASE(BINARY, Binary) {
            gen_expr(node);
            gen(";");
            BREAK();
        }

        CASE(FOR, For) {
            // Array iter
            if (node->is_array_traversal) {
                gen("for(int64_t _i%d = 0; _i%d < ", node->pos->line, node->pos->line);
                if (is_array(node->cond->resolved_type)) {
                    gen("BufferSize(");
                    gen_expr(node->cond);
                    gen(")");
                }
                else {
                    assert(is_slice(node->cond->resolved_type));
                    gen_expr(node->cond);
                    gen(".len");
                }

                gen("; _i%d+=1)", node->pos->line);
                gen("{");
                global_indent++;
                genln("");
                gen_simple_decl(node->array_traversal_var->type, node->array_traversal_var->name);
                gen(" = ");
                gen_expr(node->cond);
                if (node->is_also_slice_traversal) gen(".data");
                gen(" + _i%d;", node->pos->line);
                For(node->scope->stmts) {
                    gen_line(it);
                    genln("");
                    gen_ast(it);
                }
                global_indent--;
                gen_last_line();
                genln("}");
            }

            // Normal for loop
            else {
                gen("for(");
                if (node->init) gen_expr(node->init);
                gen(";");
                if (node->cond) gen_expr(node->cond);
                gen(";");
                if (node->iter) gen_expr(node->iter);
                gen(")");
                gen_stmt_scope(node->scope);
            }

            BREAK();
        }

        CASE(LAMBDA, Decl) {
            gen_line(node);
            genln("");

            if (is_flag_set(node->expr->flags, AST_FOREIGN)) {
                gen("/*foreign*/");
            }
            gen_lambda(node->unique_name, node->lambda);
            BREAK();
        }

        case AST_UNION:
            CASE(STRUCT, Decl) {
                gen("%s ", node->kind == AST_STRUCT ? "struct" : "union");
                gen("%Q{", node->unique_name);
                global_indent++;
                is_inside_struct++;
                For(node->scope->decls) {
                    genln("");
                    gen_ast(it);
                }

                is_inside_struct--;
                global_indent--;
                genln("};");
                BREAK();
            }

            CASE(ENUM, Decl) {
                gen("/*enum %Q{", node->unique_name);
                // @todo add typespec
                global_indent++;
                For(node->scope->decls) {
                    genln("%Q", it->unique_name);
                    gen(" = ");
                    gen_value(it->pos, it->value);
                    gen(",");
                }
                global_indent--;
                genln("};*/");
                BREAK();
            }

        case AST_TYPE:
            CASE(CONST, Decl) {
                unused(node);
                BREAK();
            }

            CASE(SWITCH, Switch) {
                gen("switch(");
                gen_expr(node->value);
                gen("){");
                global_indent++;

                For(node->cases) {
                    For2(it->labels, label) {
                        gen_line(it);
                        genln("");
                        gen("case ");
                        gen_expr(label);
                        gen(":");
                    }

                    gen_stmt_scope(it->scope, it->fallthrough ? false : true);
                }

                if (node->default_scope) {
                    genln("default: ");
                    gen_stmt_scope(node->default_scope);
                }

                global_indent--;
                gen_last_line();
                genln("}");

                BREAK();
            }

            CASE(VAR_UNPACK, Var_Unpack) {
                Ast_Type *t = node->resolved_type;
                For(node->vars) {
                    gen_ast(it);
                }

                Intern_String var_name = get_unique_name();
                gen_simple_decl(node->resolved_type, var_name);
                gen(" = ");
                gen_expr(node->expr);
                gen(";");

                int i = 0;
                For(node->vars) {
                    Ast_Resolved_Member &m = t->agg.members[i];
                    char *p = "&";
                    if (is_array(m.type)) p = "";

                    gen("MemoryCopy((void *)%s%Q, (void *)%s%Q.%Q, sizeof(%Q));", p, it->name, p, var_name, m.name, it->name);
                    i = +1;
                }
                BREAK();
            }

        case AST_CONSTANT_ASSERT:
        case AST_NAMESPACE: break;

        default: {
            assert(is_flag_set(ast->flags, AST_EXPR));
            gen_expr((Ast_Expr *)ast);
            gen(";");
        }
    }
}

CORE_Static String
compile_to_c_code() {
    pctx->time.code_generation = os_time();

    if (pctx->single_header_library_mode) {
        gen(R"(
/*
 Do this:
    #define %Q_IMPLEMENTATION
 before you include this file in *one* C or C++ file to create the implementation.

 // i.e. it should look like this:
 #include ...
 #include ...
 #include ...
 #define %Q_IMPLEMENTATION
 #include "%Q.h"

 You can #define Assert(x) to avoid using default assert
 You can #define AssertMessage(x) to get more comprehensive error info
 You can #define MemoryCopy(x) to avoid using default memory copy
*/
    )",
            pctx->single_header_library_name, pctx->single_header_library_name, pctx->single_header_library_name);
        genln("#ifndef %Q_LIBRARY_HEADER ", pctx->single_header_library_name);
        genln("#define %Q_LIBRARY_HEADER ", pctx->single_header_library_name);
    }

    gen(R"(

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>

int printf(const char *format, ...);
#ifndef Assert
  #define Assert(x) do{ \
    if(!(x)) { \
        printf("Assertion failed! %%s(%%d): %%s\n", __FILE__, __LINE__, #x); \
        *(volatile int *)0 = 0; \
    } \
  }while(0)
#endif

#ifndef AssertMessage
  #define AssertMessage(x,...) Assert(x)
#endif

#ifndef MemoryCopy
  #define MemoryCopy MemoryCopy_

  static void
  MemoryCopy_(void *dst, void *src, size_t size){
    uint8_t *d = (uint8_t*)dst;
    uint8_t *s = (uint8_t*)src;
    for(size_t i = 0; i < size; i++){
      d[i] = s[i];
    }
  }
#endif

#define BufferSize(x) ((int)(sizeof(x)/sizeof((x)[0])))

#ifdef __clang__
  #define CORE_ConditionalCompound(x) (x)
#elif _MSC_VER
  #define CORE_ConditionalCompound(x)
#else
  #define CORE_ConditionalCompound(x) (x)
#endif

)");

    // Generate struct forward decls
    For(pctx->ordered_decls) {
        if (it->kind == AST_STRUCT) {
            genln("typedef struct %Q %Q;", it->unique_name, it->unique_name);
        }
        else if (it->kind == AST_UNION) {
            genln("typedef union %Q %Q;", it->unique_name, it->unique_name);
        }
    }

    // Generate slice types
    For2(pctx->all_types, type) {
        if (type->kind == TYPE_SLICE) {
            genln("typedef struct Slice%llu{", type->type_id);
            global_indent++;
            genln("int64_t len;");
            genln("");
            gen_simple_decl(type_pointer(type->base), pctx->intern("data"_s));
            gen(";");
            global_indent--;
            genln("} Slice%llu;", type->type_id);
        }
    }

    Intern_String intern_main = pctx->intern("main"_s);
    Intern_String intern_win_main = pctx->intern("WinMain"_s);

    Ast_Decl *main = 0;
    Ast_Decl *win_main = 0;

    // Generate lambda forward decls
    For(pctx->ordered_decls) {
        if (it->kind == AST_LAMBDA) {
            if (it->name == intern_main) {
                main = it;
                it->unique_name = it->name;
            }

            if (it->name == intern_win_main) {
                win_main = it;
                it->unique_name = it->name;
            }

            genln("");

            gen_lambda(it->unique_name, it->lambda, false);
        }
    }

    if (!main && !win_main) {
        compiler_error(0, "Entry point is not defined! Try main or WinMain");
    }

    if (pctx->emit_type_info) {
        // Generate language.core
        for (S32 i = 0; i < pctx->base_language_ordered_decl_len; i++) {
            Ast_Decl *it = get(&pctx->ordered_decls, i);
            genln("");
            gen_ast(it);
        }

        // Generate type info
        genln("int type_infos_len = %d;", length(&pctx->all_types));
        genln("Type_Info *type_infos = (Type_Info[]){");
        global_indent++;
        int i = 0;
        For2(pctx->all_types, t) {
            if (t->kind == TYPE_POLYMORPH) continue;
            if (i++ != t->type_id) {
                compiler_error(0, "Internal compiler error: type info array is inconsistent");
            }

            genln("{/*%Q*/", typestring(t));
            global_indent += 1;
            genln(".kind = %d, ", (S32)t->kind);
            genln(".size = %d, ", (S32)t->size);
            genln(".align = %d, ", (S32)t->align);
            genln(".is_unsigned = %s, ", t->is_unsigned ? "true" : "false");
            genln(".type = %d, ", t->type_id);

            switch (t->kind) {
                case TYPE_POINTER:
                case TYPE_SLICE: {
                    genln(".base_type = %d", t->base->type_id);
                } break;
                case TYPE_ARRAY: {
                    genln(".base_type = %d, ", t->base->type_id);
                    genln(".array_size = %d", t->arr.size);
                } break;
                case TYPE_LAMBDA: {
                    if (t->func.args.len == 0) goto end_of_switch;
                    genln(".lambda_return = %d, ", t->func.ret->type_id);
                    genln(".lambda_arguments.len = %d, ", t->func.args.len);
                    genln(".lambda_arguments.data = (Type_Info[%d]){", t->func.args.len);
                    global_indent += 1;
                    For2(t->func.args, arg) {
                        genln("{.type = %d}, ", arg->type_id);
                    }
                    global_indent -= 1;
                    genln("}");
                } break;
                case TYPE_UNION:
                case TYPE_STRUCT: {
                    if (t->agg.members.len == 0) goto end_of_switch;
                    genln(".struct_members.len = %d, ", t->agg.members.len);
                    genln(".struct_members.data = (Type_Info_Struct_Member[%d]){", t->agg.members.len);
                    global_indent += 1;
                    For2(t->agg.members, m) {
                        genln("{.name = {(uint8_t *)\"%Q\", %d}, .type = %d, .offset = %d}, ", m.name, m.name.len, m.type->type_id, m.offset);
                    }
                    global_indent -= 1;
                    genln("}");
                } break;
                case AST_ENUM: {
                    // todo;
                } break;
                default: {
                }
            }
        end_of_switch:;
            global_indent -= 1;
            genln("},");
        }
        global_indent--;
        genln("};");
    }

    if (pctx->single_header_library_mode) {
        genln("#endif");
        genln("#ifdef %Q_IMPLEMENTATION ", pctx->single_header_library_name);
    }

    // Generate actual code
    int index = 0;
    For(pctx->ordered_decls) {
        if (index >= pctx->base_language_ordered_decl_len) {
            genln("");
            gen_ast(it);
        }
        index += 1;
    }

    if (pctx->single_header_library_mode) {
        genln("#endif");
    }

    String string_result = string_flatten(pctx->perm, &pctx->gen);
    pctx->time.code_generation = os_time() - pctx->time.code_generation;
    return string_result;
}