#undef UNICODE
#define NOB_IMPLEMENTATION
// Redefine nob_cc_flags() to carry the project's debug flags. Keep in sync
// with CFLAGS_STR below.
#define SPL_CFLAGS "-Wall", "-Wextra", "-O0", "-g", "-D_CRT_SECURE_NO_WARNINGS"
#define nob_cc_flags(cmd) nob_cmd_append(cmd, SPL_CFLAGS)
#include "nob.h"
#ifdef _WIN32
#include <consoleapi2.h>
#endif

// C-side bootstrap build script. Builds the stage0 VM tools and the splc0
// compiler from their C sources. The SPL self-hosting chain (splc1, ...) is
// out of scope and is driven by a different mechanism.
//
// Usage:
//     cc -o nob nob.c          # bootstrap once
//     ./nob                    # build all targets
//     ./nob build <targets...> # build specific targets
//     ./nob run <target> [..]  # build and run
//     ./nob test               # build and run VM unit tests
//     ./nob clean              # remove build artifacts
//     ./nob list               # list all targets
//     ./nob help               # print this help

#define BUILD_FOLDER "build/"

#ifdef _WIN32
#define EXE_SUFFIX ".exe"
#else
#define EXE_SUFFIX ""
#endif

// Content of the .cflags stamp file; must match SPL_CFLAGS above.
#define CFLAGS_STR "-Wall -Wextra -O0 -g"
// Stamp file whose mtime is refreshed whenever the flags change so that all
// object files get rebuilt.
static const char *CFLAGS_STAMP = BUILD_FOLDER ".cflags";

// Target descriptions
#define VM_SRCS "stage0/spl_mcode.c", "stage0/spl_syscall.c", "stage0/spl_vm.c"
#define SPLC0_PART_SRCS                                                                            \
    "stage1/spl_ast.c", "stage1/spl_lexer.c", "stage1/spl_dumptree.c", "stage1/spl_type.c",        \
        "stage1/spl_sema.c", "stage1/spl_ir.c", "stage1/spl_ast2ir.c"

static const char *spl_cli_srcs[] = {"stage0/spl_cli.c", VM_SRCS};
static const char *splc0_srcs[] = {"stage1/splc0.c", VM_SRCS, SPLC0_PART_SRCS};
static const char *test_srcs[] = {"stage0/test_spl_vm.c", VM_SRCS};
static const char *spl_disasm_srcs[] = {"stage0/spl_disasm.c", VM_SRCS};

typedef struct {
    const char *name;
    const char **srcs;
    size_t srcs_count;
} Exe_Target;

static Exe_Target exe_targets[] = {
    {"spl_cli", spl_cli_srcs, NOB_ARRAY_LEN(spl_cli_srcs)},
    {"splc0", splc0_srcs, NOB_ARRAY_LEN(splc0_srcs)},
    {"test", test_srcs, NOB_ARRAY_LEN(test_srcs)},
    {"spl_disasm", spl_disasm_srcs, NOB_ARRAY_LEN(spl_disasm_srcs)},
};

static const Exe_Target *find_exe_target(const char *name) {
    for (size_t i = 0; i < NOB_ARRAY_LEN(exe_targets); ++i) {
        if (strcmp(exe_targets[i].name, name) == 0) {
            return &exe_targets[i];
        }
    }
    return NULL;
}

static const char *obj_path(const char *src) {
    // "stage0/spl_vm.c" -> "build/stage0_spl_vm.o"
    size_t prefix_len = strlen(BUILD_FOLDER);
    char *out = (char *)nob_temp_alloc(prefix_len + strlen(src) + 2 + 1);
    char *w = out;
    memcpy(w, BUILD_FOLDER, prefix_len);
    w += prefix_len;
    for (const char *p = src; *p && *p != '.'; ++p) {
        *w++ = (*p == '/' || *p == '\\') ? '_' : *p;
    }
    memcpy(w, ".o", 3);
    return out;
}

static const char *exe_path(const char *name) {
    return nob_temp_sprintf(BUILD_FOLDER "%s" EXE_SUFFIX, name);
}

static bool sync_cflags_stamp(void) {
    Nob_String_View cflags = nob_sv_from_cstr(CFLAGS_STR);
    Nob_String_Builder old = {0};
    bool changed = true;
    if (nob_file_exists(CFLAGS_STAMP) && nob_read_entire_file(CFLAGS_STAMP, &old)) {
        changed = !nob_sv_eq(nob_sb_to_sv(old), cflags);
    }
    nob_sb_free(old);

    if (changed) {
        if (!nob_write_entire_file(CFLAGS_STAMP, cflags.data, cflags.count)) {
            return false;
        }
    }
    return true;
}

static bool prepare_build(void) {
    if (!nob_mkdir_if_not_exists(BUILD_FOLDER))
        return false;
    return sync_cflags_stamp();
}

static bool build_object(const char *src) {
    const char *obj = obj_path(src);
    if (!nob_file_exists(src)) {
        nob_log(NOB_ERROR, "source file `%s` does not exist", src);
        return false;
    }

    const char *inputs[] = {src, CFLAGS_STAMP};
    int needs = nob_needs_rebuild(obj, inputs, NOB_ARRAY_LEN(inputs));
    if (needs < 0)
        return false;
    if (needs == 0)
        return true;

    Nob_Cmd cmd = {0};
    nob_cc(&cmd);
    nob_cc_flags(&cmd);
    nob_cmd_append(&cmd, "-c");
    nob_cc_inputs(&cmd, src);
    nob_cc_output(&cmd, obj);
    return nob_cmd_run(&cmd);
}

static bool link_exe(const Exe_Target *target) {
    const char *exe = exe_path(target->name);
    const char **objs = (const char **)nob_temp_alloc(sizeof(const char *) * target->srcs_count);
    for (size_t i = 0; i < target->srcs_count; ++i) {
        objs[i] = obj_path(target->srcs[i]);
    }

    int needs = nob_needs_rebuild(exe, objs, target->srcs_count);
    if (needs < 0)
        return false;
    if (needs == 0)
        return true;

    Nob_Cmd cmd = {0};
    nob_cc(&cmd);
    nob_cc_flags(&cmd);
    for (size_t i = 0; i < target->srcs_count; ++i) {
        nob_cc_inputs(&cmd, objs[i]);
    }
    nob_cc_output(&cmd, exe);
    return nob_cmd_run(&cmd);
}

static bool build_target(const char *name) {
    const Exe_Target *target = find_exe_target(name);
    if (target == NULL) {
        nob_log(NOB_ERROR, "unknown target `%s`", name);
        return false;
    }

    for (size_t i = 0; i < target->srcs_count; ++i) {
        if (!build_object(target->srcs[i])) {
            return false;
        }
    }
    return link_exe(target);
}

static bool build_all(void) {
    for (size_t i = 0; i < NOB_ARRAY_LEN(exe_targets); ++i) {
        if (!build_target(exe_targets[i].name)) {
            return false;
        }
    }
    return true;
}

static bool delete_walk_entry(Nob_Walk_Entry entry) { return nob_delete_file(entry.path); }

static bool delete_directory_recursively(const char *dir_path) {
    return nob_walk_dir(dir_path, delete_walk_entry, .post_order = true);
}

static void print_help(const char *program_name) {
    nob_log(NOB_INFO, "SPL C-side bootstrap build system (nob)");
    nob_log(NOB_INFO, "%s", " ");
    nob_log(NOB_INFO, "Usage: %s <command> [args...]", program_name);
    nob_log(NOB_INFO, "%s", " ");
    nob_log(NOB_INFO, "Commands:");
    nob_log(NOB_INFO, "    build [targets...]  build all targets or the given ones");
    nob_log(NOB_INFO, "    run <target> [args] build and run a target");
    nob_log(NOB_INFO, "    test                build and run VM unit tests");
    nob_log(NOB_INFO, "    clean               remove build artifacts");
    nob_log(NOB_INFO, "    list                list all targets");
    nob_log(NOB_INFO, "    help/-h/--help      print this help message");
    nob_log(NOB_INFO, "%s", " ");
    nob_log(NOB_INFO, "Targets:");
    for (size_t i = 0; i < NOB_ARRAY_LEN(exe_targets); ++i) {
        nob_log(NOB_INFO, "    %s", exe_targets[i].name);
    }
}

int main(int argc, char **argv) {
#ifdef _WIN32
    SetConsoleOutputCP(CP_UTF8);
#endif
    NOB_GO_REBUILD_URSELF_PLUS(argc, argv, "nob.h");
    set_log_handler(nob_cancer_log_handler);

    const char *program_name = nob_shift(argv, argc);
    const char *command_name = "build";
    if (argc > 0) {
        command_name = nob_shift(argv, argc);
    }

    if (strcmp(command_name, "build") == 0) {
        if (!prepare_build())
            return 1;
        if (argc > 0) {
            while (argc > 0) {
                const char *target_name = nob_shift(argv, argc);
                if (!build_target(target_name))
                    return 1;
            }
        } else {
            if (!build_all())
                return 1;
        }
        return 0;
    }

    if (strcmp(command_name, "run") == 0) {
        if (argc <= 0) {
            nob_log(NOB_ERROR, "usage: %s run <target> [args...]", program_name);
            return 1;
        }
        const char *target_name = nob_shift(argv, argc);
        if (!prepare_build())
            return 1;
        if (!build_target(target_name))
            return 1;
        Nob_Cmd cmd = {0};
        nob_cmd_append(&cmd, exe_path(target_name));
        while (argc > 0) {
            nob_cmd_append(&cmd, nob_shift(argv, argc));
        }
        return nob_cmd_run(&cmd) ? 0 : 1;
    }

    if (strcmp(command_name, "test") == 0) {
        if (!prepare_build())
            return 1;
        if (!build_target("test"))
            return 1;
        Nob_Cmd cmd = {0};
        nob_cmd_append(&cmd, exe_path("test"));
        return nob_cmd_run(&cmd) ? 0 : 1;
    }

    if (strcmp(command_name, "clean") == 0) {
        if (nob_file_exists(BUILD_FOLDER)) {
            if (!delete_directory_recursively(BUILD_FOLDER))
                return 1;
        }
        nob_log(NOB_INFO, "cleaned %s", BUILD_FOLDER);
        return 0;
    }

    if (strcmp(command_name, "list") == 0) {
        for (size_t i = 0; i < NOB_ARRAY_LEN(exe_targets); ++i) {
            nob_log(NOB_INFO, "%s:", exe_targets[i].name);
            for (size_t j = 0; j < exe_targets[i].srcs_count; ++j) {
                nob_log(NOB_INFO, "    %s", exe_targets[i].srcs[j]);
            }
        }
        return 0;
    }

    if (strcmp(command_name, "help") == 0 || strcmp(command_name, "-h") == 0 ||
        strcmp(command_name, "--help") == 0) {
        print_help(program_name);
        return 0;
    }

    nob_log(NOB_ERROR, "unknown command `%s`", command_name);
    print_help(program_name);
    return 1;
}