#include "buildit.h"

typedef struct WorkerSharedState WorkerSharedState;

/* ========================== *
 * Globals
 * ========================== */

Bool force_rebuild = false;

Arena arena = { 0 };
D_Store store = { 0 };
D_Hist hist = { 0 };
WorkerSharedState *worker_shared = { 0 };

/* ========================== *
 * Util
 * ========================== */

void Error(String msg)
{
    SH_PrintF(Lit("ERROR: %F\n"), FmtStr(msg));
}

Bool IsDirty(D_Tag tag)
{
    Bool res = force_rebuild ? true : D_IsDirty(&store, &hist, tag);
    if (!res) {
        if (tag.kind == D_TagKind_File || tag.kind == D_TagKind_Dir) {
            res = !D_Exists(tag);
        }
    }

    return res;
}

/* ========================== *
 * Step
 * ========================== */

typedef struct Step Step;
typedef struct StepList StepList;

typedef void StepFunc(Step *step);

typedef enum StepStatus {
    StepStatus_None,
    StepStatus_Success,
    StepStatus_Failure
} StepStatus;

typedef struct Step Step;
struct Step {
    String name;
    StepFunc *func;
    void *arg;
    StepList *sl;

    OS_Mutex res_mutex;
    OS_ConditionVariable res_cv;
    StepStatus res_status;
    String res_output;

    Step *next;
    Step *prev;

    Step *next_unqueued;
    Step *prev_unqueued;
};

typedef struct StepList StepList;
struct StepList {
    OS_Mutex mutex;
    Arena arena;

    Step *first;
    Step *last;
    Size count;

    Step *first_unqueued;
    Step *last_unqueued;

    StepList *next;
};

StepList StepListAlloc(void)
{
    StepList sl = { 0 };
    sl.mutex = OS_MutexAlloc();
    sl.arena = ArenaAlloc(Gigabyte(64));
    return sl;
}

Step *DequeueNextStep(StepList *sl)
{
    Step *res = 0;
    OS_MutexLockW(&sl->mutex);
    {
        res = sl->first_unqueued;
        if (res) {
            DllRemoveNP(sl->first_unqueued, sl->last_unqueued, res, next_unqueued, prev_unqueued);
        }
    }
    OS_MutexUnlockW(&sl->mutex);
    return res;
}

void AddStep(StepList *sl, String name, StepFunc *func, void *arg)
{
    OS_MutexLockW(&sl->mutex);
    {
        Step *s = ArenaPush(&sl->arena, Step);
        s->name = StringCopy(&sl->arena, name);
        s->func = func;
        s->arg = arg;
        s->sl = sl;
        s->res_mutex = OS_MutexAlloc();
        s->res_cv = OS_ConditionVariableAlloc();
        DllPushBack(sl->first, sl->last, s);
        DllPushBackNP(sl->first_unqueued, sl->last_unqueued, s, next_unqueued, prev_unqueued);
        ++sl->count;
    }
    OS_MutexUnlockW(&sl->mutex);
}

/* ========================== *
 * Worker
 * ========================== */

typedef struct Worker Worker;

typedef struct WorkerSharedState WorkerSharedState;
struct WorkerSharedState {
    OS_Mutex mutex;
    OS_ConditionVariable cv;
    Arena arena;

    StepList *first_step_list;
    StepList *last_step_list;

    Bool shutdown;
    Worker *first_worker;
    I64 worker_count;
};

typedef struct Worker Worker;
struct Worker {
    OS_Thread thread;
    Worker *next;
};

OS_ThreadEntryPointFuncDef(WorkerEntryPoint, arg)
{
    I64 id = (I64)arg;
    {
        TempArena scratch = ScratchBeginNoConflict();
        String name = StringF(scratch.arena, Lit("Buildit worker #%F"), FmtI64Zfill(id, 2));
        OS_SetThreadName(name);
        ScratchEnd(scratch);
    }

    while (!worker_shared->shutdown) {
        OS_MutexLockW(&worker_shared->mutex);
        {
            if (!worker_shared->shutdown && !worker_shared->first_step_list) {
                OS_ConditionVariableWaitW(&worker_shared->cv, &worker_shared->mutex);
            }

            if (!worker_shared->shutdown && worker_shared->first_step_list) {
                StepList *sl = worker_shared->first_step_list;
                Step *s = DequeueNextStep(sl);
                if (s) {
                    OS_MutexUnlockW(&worker_shared->mutex);
                    {
                        s->func(s);
                    }
                    OS_MutexLockW(&worker_shared->mutex);
                } else {
                    /* Wait for all steps in old step list to finish, then pop the list */
                    for (Step *check_step = sl->first; check_step; check_step = check_step->next) {
                        OS_MutexLockW(&check_step->res_mutex);
                        {
                            while (check_step->res_status == StepStatus_None) {
                                OS_ConditionVariableWaitW(&check_step->res_cv, &check_step->res_mutex);
                            }
                        }
                        OS_MutexUnlockW(&check_step->res_mutex);
                    }
                    SllQueuePop(worker_shared->first_step_list, worker_shared->last_step_list);
                }
            }
        }
        OS_MutexUnlockW(&worker_shared->mutex);
    }
}

void StartWorkers(I64 count)
{
    OS_MutexLockW(&worker_shared->mutex);
    {
        for (I64 i = 0; i < count; ++i) {
            Worker *w = ArenaPush(&worker_shared->arena, Worker);
            w->thread = OS_ThreadAlloc(&WorkerEntryPoint, (void *)worker_shared->worker_count);
            SllStackPush(worker_shared->first_worker, w);
            ++worker_shared->worker_count;
        }
    }
    OS_MutexUnlockW(&worker_shared->mutex);
}

void ShutdownWorkers(void)
{
    OS_MutexLockW(&worker_shared->mutex);
    {
        worker_shared->shutdown = true;
        OS_ConditionVariableBroadcast(&worker_shared->cv);
    }
    OS_MutexUnlockW(&worker_shared->mutex);

    for (Worker *w = worker_shared->first_worker; w; w = w->next) {
        OS_ThreadWaitRelease(&w->thread);
    }
}

void AddStepListToWorkQueue(StepList *sl)
{
    OS_MutexLockW(&worker_shared->mutex);
    {
        SllQueuePush(worker_shared->first_step_list, worker_shared->last_step_list, sl);
        OS_ConditionVariableBroadcast(&worker_shared->cv);
    }
    OS_MutexUnlockW(&worker_shared->mutex);
}

/* ========================== *
 * Build steps
 * ========================== */

typedef struct BuildStepSimpleCommandArg BuildStepSimpleCommandArg;
struct BuildStepSimpleCommandArg {
    String cmd;
};

typedef struct BuildStepMsvcCompileCommandArg BuildStepMsvcCompileCommandArg;
struct BuildStepMsvcCompileCommandArg {
    String cmd;
    D_Tag depfile_dependent;
    D_Tag output_depfile;
    D_TagList depfile_force_includes;
};

void BuildStepSimpleCommand(Step *s)
{
    TempArena scratch = ScratchBeginNoConflict();

    BuildStepSimpleCommandArg *arg = s->arg;
    SH_CommandResult result = SH_RunCommandCaptureOutput(scratch.arena, arg->cmd, true);

    OS_MutexLockW(&s->res_mutex);
    {
        if (result.output.len > 0) {
            OS_MutexLockW(&s->sl->mutex);
            {
                s->res_output.text = ArenaPushArrayNoZero(&s->sl->arena, Byte, result.output.len);
            }
            OS_MutexUnlockW(&s->sl->mutex);
            s->res_output.len = result.output.len;
            MemoryCopy(s->res_output.text, result.output.text, result.output.len);
        }
        s->res_status = result.error ? StepStatus_Failure : StepStatus_Success;
        OS_ConditionVariableBroadcast(&s->res_cv);
    }
    OS_MutexUnlockW(&s->res_mutex);

    ScratchEnd(scratch);
}

void BuildStepMsvcCompileCommand(Step *s)
{
    TempArena scratch = ScratchBeginNoConflict();

    BuildStepMsvcCompileCommandArg *arg = s->arg;
    SH_CommandResult result = SH_RunCommandCaptureOutput(scratch.arena, arg->cmd, true);

    if (!result.error && !D_IsNil(arg->depfile_dependent) && !D_IsNil(arg->output_depfile)) {
        String depfile_data = D_DepfileTextFromMsvcOutput(scratch.arena, arg->depfile_dependent, arg->depfile_force_includes, result.output);
        D_ClearWrite(arg->output_depfile, depfile_data);
    }

    OS_MutexLockW(&s->res_mutex);
    {
        if (result.output.len > 0) {
            OS_MutexLockW(&s->sl->mutex);
            {
                s->res_output.text = ArenaPushArrayNoZero(&s->sl->arena, Byte, result.output.len);
            }
            OS_MutexUnlockW(&s->sl->mutex);
            s->res_output.len = result.output.len;
            MemoryCopy(s->res_output.text, result.output.text, result.output.len);
        }
        s->res_status = result.error ? StepStatus_Failure : StepStatus_Success;
        OS_ConditionVariableBroadcast(&s->res_cv);
    }
    OS_MutexUnlockW(&s->res_mutex);

    ScratchEnd(scratch);
}

/* ========================== *
 * Build
 * ========================== */

void OnBuild(StringList cli_args)
{
    arena = ArenaAlloc(Gigabyte(64));
    store = D_StoreAlloc();
    worker_shared = ArenaPush(&arena, WorkerSharedState);

    /* ========================== *
     * Setup workers
     * ========================== */

    worker_shared->mutex = OS_MutexAlloc();
    worker_shared->arena = ArenaAlloc(Gigabyte(64));

    I64 worker_count = OS_GetProcessorCount();
    StartWorkers(worker_count);

    /* ========================== *
     * Read args
     * ========================== */

    String arg_outdir = Lit("build");
    Bool arg_msvc = false;
    Bool arg_rtc = false;
    Bool arg_asan = false;
    Bool arg_crtlib = false;
    Bool arg_debinfo = false;
    Bool arg_developer = false;
    Bool arg_profiling = false;
    Bool arg_unoptimized = false;

    {
        typedef enum ArgState {
            ArgState_None,
            ArgState_OutputDir
        } ArgState;

        ArgState arg_state = ArgState_None;
        for (StringListNode *n = cli_args.first; n; n = n->next) {
            String arg = n->string;
            if (n != cli_args.first) {
                switch (arg_state) {
                    case ArgState_OutputDir:
                    {
                        arg_outdir = arg;
                        arg_state = ArgState_None;
                    } break;

                    default:
                    {
                        if (StringEqual(arg, Lit("-O"))) arg_state = ArgState_OutputDir;
                        if (StringEqual(arg, Lit("-clang"))) arg_msvc = false;
                        if (StringEqual(arg, Lit("-msvc"))) arg_msvc = true;
                        if (StringEqual(arg, Lit("-rtc"))) arg_rtc = true;
                        if (StringEqual(arg, Lit("-asan"))) arg_asan = true;
                        if (StringEqual(arg, Lit("-crtlib"))) arg_crtlib = true;
                        if (StringEqual(arg, Lit("-debinfo"))) arg_debinfo = true;
                        if (StringEqual(arg, Lit("-developer"))) arg_developer = true;
                        if (StringEqual(arg, Lit("-profiling"))) arg_profiling = true;
                        if (StringEqual(arg, Lit("-unoptimized"))) arg_unoptimized = true;
                    } break;
                }
            }
        }
    }

    String hist_path = OS_GetAbsPath(&arena, StringF(&arena, Lit("%F/.dephist"), FmtStr(arg_outdir)));
    String build_hash_path = OS_GetAbsPath(&arena, StringF(&arena, Lit("%F/.pp_build_hash"), FmtStr(arg_outdir)));
    String out_dep_dir_path = OS_GetAbsPath(&arena, StringF(&arena, Lit("%F/dep/"), FmtStr(arg_outdir)));
    String out_obj_dir_path = OS_GetAbsPath(&arena, StringF(&arena, Lit("%F/obj/"), FmtStr(arg_outdir)));
    String out_inc_dir_path = OS_GetAbsPath(&arena, StringF(&arena, Lit("%F/inc/"), FmtStr(arg_outdir)));
    String out_bin_dir_path = OS_GetAbsPath(&arena, StringF(&arena, Lit("%F/bin/"), FmtStr(arg_outdir)));

    if (!OS_DirExists(out_obj_dir_path)) {
        OS_CreateDirAtAbsPath(out_obj_dir_path);
    }
    if (!OS_DirExists(out_inc_dir_path)) {
        OS_CreateDirAtAbsPath(out_inc_dir_path);
    }
    if (!OS_DirExists(out_bin_dir_path)) {
        OS_CreateDirAtAbsPath(out_bin_dir_path);
    }

    {
        SH_Print(Lit("------------------------------\n"));
        String compiler = { 0 };
        String compiler_loc = { 0 };
        {
            SH_CommandResult where_res = { 0 };
            if (arg_msvc) {
                compiler = Lit("Msvc");
                where_res = SH_RunCommandCaptureOutput(&arena, Lit("where cl.exe"), true);
            } else {
                compiler = Lit("Clang");
                where_res = SH_RunCommandCaptureOutput(&arena, Lit("where clang.exe"), true);
            }
            compiler_loc = where_res.error ? Lit("Not found") : StringReplace(&arena, where_res.output, Lit("\n"), Lit(""));
        }
        SH_PrintF(Lit("Compiler path: %F\n"), FmtStr(compiler_loc));
        SH_PrintF(Lit("Build path: \"%F\"\n"), FmtStr(out_bin_dir_path));
        SH_PrintF(Lit("[%F]\n"), FmtStr(compiler));
        if (arg_asan) SH_Print(Lit("[Asan Enabled]\n"));
        if (arg_profiling) SH_Print(Lit("[Profiling]\n"));
        if (arg_developer) SH_Print(Lit("[Developer build]\n"));
        SH_Print(Lit("------------------------------\n\n"));
    }

    /* ========================== *
     * Constants
     * ========================== */

    String dep_file_extension = Lit("d");
    String obj_file_extension = Lit("obj");
    Bool should_embed_res_dir = !arg_developer;
    Bool should_embed_in_rc = !!arg_msvc;

    D_Tag executable_file = D_TagFromPath(&arena, StringF(&arena, Lit("%F/PowerPlay.exe"), FmtStr(out_bin_dir_path)), D_TagKind_File);
    D_Tag res_dir = D_TagFromPath(&arena, Lit("res"), D_TagKind_Dir);
    D_Tag shaders_dir = D_TagFromPath(&arena, Lit("src/shaders"), D_TagKind_Dir);
    D_Tag icon_file = D_TagFromPath(&arena, Lit("icon.ico"), D_TagKind_File);

    D_Tag inc_src_file = D_TagFromPath(&arena, Lit("src/inc.c"), D_TagKind_File);
    D_Tag rc_res_file = D_TagFromPath(&arena, StringF(&arena, Lit("%F/rc.res"), FmtStr(out_obj_dir_path)), D_TagKind_File);

    /* ========================== *
     * Determine compiler args
     * ========================== */

    StringList c_compile_args = { 0 };
    StringList cpp_compile_args = { 0 };
    StringList pch_c_compile_args = { 0 };
    StringList pch_cpp_compile_args = { 0 };
    StringList compile_and_link_args = { 0 };
    StringList compile_args = { 0 };
    StringList compile_warnings = { 0 };
    StringList link_warnings = { 0 };
    StringList link_args = { 0 };
    StringList rc_compile_args = { 0 };
    {
        if (arg_msvc) {
            /* Msvc */
            StringListAppend(&arena, &c_compile_args, Lit("cl.exe /nologo /c \"%F\" /Fo\"%F\" /FS /showIncludes"));
            StringListAppend(&arena, &cpp_compile_args, Lit("cl.exe /nologo /c \"%F\" /Fo\"%F\" /FS /showIncludes"));
            StringListAppend(&arena, &pch_c_compile_args, Lit("cl.exe /nologo /c /Yc\"%F\" \"%F\" /FS /showIncludes"));
            StringListAppend(&arena, &pch_cpp_compile_args, Lit("cl.exe /nologo /c /Yc\"%F\" \"%F\" /FS /showIncludes"));
            StringListAppend(&arena, &rc_compile_args, Lit("rc /fo\"%F\" \"%F\""));

            StringListAppend(&arena, &link_args, Lit("link.exe /nologo %F /OUT:\"%F\" /DEBUG:FULL /OPT:REF /OPT:ICF"));

            String warnings = Lit("/WX /Wall "
                                  "/options:strict "
                                  "/wd4820 /wd4201 /wd5220 /wd4514 /wd4244 /wd5045 /wd4242 /wd4061 /wd4189 /wd4723 /wd5246");
            StringListAppend(&arena, &compile_warnings, warnings);
            StringListAppend(&arena, &link_warnings, Lit("/WX"));

            StringListAppend(&arena, &compile_args, StringF(&arena, Lit("/Fd\"%F\\\""), FmtStr(out_bin_dir_path)));
        } else {
            /* Clang */
            StringListAppend(&arena, &c_compile_args, Lit("clang -xc -std=c99 -c \"%F\" -o \"%F\" -MD"));
            StringListAppend(&arena, &cpp_compile_args, Lit("clang -xc++ -std=c++20 -c \"%F\" -o \"%F\" -MD"));
            StringListAppend(&arena, &pch_c_compile_args, Lit("clang -xc-header -std=c99 -c \"%F\" -o \"%F\" -MD"));
            StringListAppend(&arena, &pch_cpp_compile_args, Lit("clang -xc++-header -std=c++20 -c \"%F\" -o \"%F\" -MD"));
            StringListAppend(&arena, &rc_compile_args, Lit("llvm-rc /fo\"%F\" \"%F\""));

            StringListAppend(&arena, &link_args, Lit("clang %F -o \"%F\""));

            StringListAppend(&arena,
                             &compile_and_link_args,
                             Lit("-fuse-ld=lld-link "
                                 "-fno-strict-aliasing "
                                 "-fno-finite-loops "
                                 "-fwrapv "
                                 "-msse4.1 "
                                 "-msse4.2 "));

            String warnings = Lit("-Weverything -Werror "
                                  "-Wframe-larger-than=65536 "
                                  "-Wno-unused-macros -Wno-gnu-zero-variadic-macro-arguments -Wno-documentation "
                                  "-Wno-old-style-cast -Wno-conversion -Wno-sign-conversion "
                                  "-Wno-declaration-after-statement -Wno-extra-semi -Wno-extra-semi-stmt "
                                  "-Wno-bad-function-cast -Wno-class-varargs -Wno-unreachable-code-break "
                                  "-Wno-cast-align -Wno-float-equal -Wno-zero-as-null-pointer-constant "
                                  "-Wno-cast-qual -Wno-missing-noreturn -Wno-missing-field-initializers "
                                  "-Wno-missing-braces -Wno-initializer-overrides "
                                  "-Wno-c99-extensions -Wno-c++98-compat-pedantic -Wno-c++98-compat "
                                  "-Wno-switch-enum -Wno-switch-default "
                                  "-Wno-reserved-identifier -Wno-reserved-macro-identifier "
                                  "-Wno-unsafe-buffer-usage -Wno-writable-strings "
                                  ""
                                  "-Wno-c11-extensions -Wno-gnu-anonymous-struct -Wno-nested-anon-types "
                                  ""
                                  "-Wno-double-promotion");
            /* -Wno-unused-variable -Wno-unused-but-set-variable -Wno-unused-parameter */

            StringListAppend(&arena, &compile_warnings, warnings);
            StringListAppend(&arena, &link_warnings, warnings);
        }

        /* RTC */
        if (arg_rtc) {
            if (!arg_crtlib) {
                Error(Lit("CRTLIB (C runtime library) Must be enabled when compiling with RTC (runtime checks)"));
                OS_Exit(1);
            }
            StringListAppend(&arena, &compile_args, Lit("-DRTC=1"));
            if (arg_msvc) {
                if (!arg_asan) {
                    /* Enable /RTC option (not compatible with ASAN) */
                    StringListAppend(&arena, &compile_and_link_args, Lit("/RTCcsu"));
                }
            } else {
                /* Enable UBSan */
                StringListAppend(&arena, &compile_and_link_args, Lit("-fsanitize=undefined -fsanitize-trap=all"));
                //StringListAppend(&arena, &compile_and_link_args, Lit("-fsanitize=undefined"));
            }
        }

        /* CRTLIB */
        if (arg_crtlib) {
            StringListAppend(&arena, &compile_args, Lit("-DCRTLIB=1"));
        } else {
            if (arg_msvc) {
                /* TODO */
                Error(Lit("TODO\n"));
                OS_Exit(1);
            } else {
                StringListAppend(&arena, &compile_and_link_args, Lit("-mno-stack-arg-probe -fno-builtin -nostdlib"));
            }
        }

        /* Optimization */
        if (arg_unoptimized) {
            StringListAppend(&arena, &compile_args, Lit("-DUNOPTIMIZED=1"));
            if (arg_msvc) {
                StringListAppend(&arena, &compile_args, Lit("/Od"));
            } else {
                StringListAppend(&arena, &compile_and_link_args, Lit("-O0"));
            }
        } else {
            if (arg_msvc) {
                StringListAppend(&arena, &compile_args, Lit("/O2"));
                StringListAppend(&arena, &link_args, Lit("/LTCG"));
            } else {
                StringListAppend(&arena, &compile_and_link_args, Lit("-O3 -flto"));
            }
        }

        /* Debug info */
        if (arg_debinfo) {
            StringListAppend(&arena, &compile_args, Lit("-DDEBINFO=1"));
            if (arg_msvc) {
                StringListAppend(&arena, &compile_args, Lit("/JMC /Zi"));
            } else {
                StringListAppend(&arena, &compile_and_link_args, Lit("-g"));
            }
        }

        /* Address sanitizer */
        if (arg_asan) {
            if (!arg_crtlib) {
                Error(Lit("CRTLIB (C runtime library) Must be enabled when compiling with asan enabled"));
                OS_Exit(1);
            }
            StringListAppend(&arena, &compile_args, Lit("-DASAN=1"));
            if (arg_msvc) {
                StringListAppend(&arena, &compile_args, Lit("/fsanitize=address"));
            } else {
                StringListAppend(&arena, &compile_and_link_args, Lit("-fsanitize=address -shared-libasan"));
            }
        }

        /* Developer mode */
        if (arg_developer) {
            StringListAppend(&arena, &compile_args, Lit("-DDEVELOPER=1"));
        }

        /* Profiling */
        if (arg_profiling) {
            if (!arg_crtlib) {
                Error(Lit("CRTLIB (C runtime library) Must be enabled when compiling with profiling enabled"));
                OS_Exit(1);
            }
            if (arg_msvc) {
                Error(Lit("MSVC not supported with profiling enabled (Profiling relies on Clang attributes)"));
                OS_Exit(1);
            }
            StringListAppend(&arena, &compile_args, Lit("-DPROFILING=1"));
            /* Tracy flags */
            StringListAppend(&arena, &compile_args, Lit("-DTRACY_ENABLE=1"));
            StringListAppend(&arena, &compile_args, Lit("-DTRACY_CALLSTACK=5"));
            StringListAppend(&arena, &compile_args, Lit("-DTRACY_NO_SAMPLING -DTRACY_NO_SYSTEM_TRACING -DTRACY_NO_CALLSTACK"));
            /* Disable compile_warnings when compiling tracy client */
            compile_warnings = (StringList) { 0 };
            link_warnings = (StringList) { 0 };
        }

        if (!arg_msvc) {
            String incbin_dir = StringReplace(&arena, out_inc_dir_path, Lit("\\"), Lit("/"));
            StringListAppend(&arena, &compile_args, StringF(&arena, Lit("-DINCBIN_DIR_RAW=\"%F\""), FmtStr(incbin_dir)));
        }
    }

    /* ========================== *
     * Examine build hash
     * ========================== */

    {
        D_Tag build_hash_file = D_TagFromPath(&arena, build_hash_path, D_TagKind_File);

        U64 build_hash = D_HashString64Basis;
        {
            String args_str = StringFromStringList(&arena, Lit(" "), cli_args);
            String compile_time_str = Lit(__DATE__ __TIME__);
            build_hash = D_HashString64(build_hash, args_str);
            build_hash = D_HashString64(build_hash, compile_time_str);
        }

        U64 old_build_hash = 0;
        {
            String build_hash_file_data = D_ReadAll(&arena, build_hash_file);
            if (build_hash_file_data.len >= 8) {
                MemoryCopy((Byte *)&old_build_hash, build_hash_file_data.text, 8);
            }
        }

        if (build_hash != old_build_hash) {
            SH_Print(Lit("Builder exe or build args have changed, forcing complete rebuild.\n"));
            force_rebuild = true;
            String data = StringFromStruct(&build_hash);
            D_ClearWrite(build_hash_file, data);
        }
    }

    /* ========================== *
     * Build
     * ========================== */

    hist = D_HistFromPath(&arena, hist_path);

    StepList tar_build_steps = StepListAlloc();
    StepList rc_and_pch_build_steps = StepListAlloc();
    StepList comp_build_steps = StepListAlloc();
    StepList link_build_steps = StepListAlloc();

    D_TagList link_files = { 0 };

    /* ========================== *
     * Build step: Tar archives
     * ========================== */

    {
        D_TagList tar_input_dirs = { 0 };
        {
            D_TagListAppend(&arena, &tar_input_dirs, shaders_dir);
            if (should_embed_res_dir) {
                D_TagListAppend(&arena, &tar_input_dirs, res_dir);
            }
        }

        for (D_TagListNode *n = tar_input_dirs.first; n; n = n->next) {
            D_Tag input_dir = n->tag;
            D_Tag tar_file = D_TagFromPath(&arena, StringF(&arena, Lit("%F/%F.tar"), FmtStr(out_inc_dir_path), FmtStr(D_GetName(input_dir))), D_TagKind_File);
            D_AddDependency(&store, tar_file, input_dir);
            if (should_embed_in_rc) {
                D_AddDependency(&store, rc_res_file, tar_file);
            } else {
                D_AddDependency(&store, inc_src_file, tar_file);
            }
            if (IsDirty(tar_file)) {
                BuildStepSimpleCommandArg *bs_arg = ArenaPush(&arena, BuildStepSimpleCommandArg);
                bs_arg->cmd = StringF(&arena, Lit("cd %F && tar cvf %F ."), FmtStr(input_dir.full_path), FmtStr(tar_file.full_path));
                String step_name = StringF(&arena, Lit("%F -> %F"), FmtStr(D_GetName(input_dir)), FmtStr(D_GetName(tar_file)));
                AddStep(&tar_build_steps, step_name, &BuildStepSimpleCommand, bs_arg);
            }
        }
    }

    /* ========================== *
     * Build step: Compile RC files
     * ========================== */

    if (PlatformWindows) {
        D_Tag rc_input_file = D_TagFromPath(&arena, StringF(&arena, Lit("%F/rc.rc"), FmtStr(out_inc_dir_path)), D_TagKind_File);
        {
            D_Tag shaders_tar_file = D_TagFromPath(&arena, StringF(&arena, Lit("%F/%F.tar"), FmtStr(out_inc_dir_path), FmtStr(D_GetName(shaders_dir))), D_TagKind_File);
            D_Tag res_tar_file = D_TagFromPath(&arena, StringF(&arena, Lit("%F/%F.tar"), FmtStr(out_inc_dir_path), FmtStr(D_GetName(res_dir))), D_TagKind_File);
            D_AddDependency(&store, rc_input_file, icon_file);
            if (should_embed_in_rc) {
                D_AddDependency(&store, rc_input_file, shaders_tar_file);
                if (should_embed_res_dir) {
                    D_AddDependency(&store, rc_input_file, res_tar_file);
                }
            }
            if (IsDirty(rc_input_file)) {
                D_ClearWrite(rc_input_file, Lit(""));
                D_AppendWrite(rc_input_file, StringF(&arena, Lit("%F %F DISCARDABLE %F\n"), FmtStr(D_GetName(icon_file)), FmtStr(Lit("ICON")), FmtStr(D_GetName(icon_file))));
                if (should_embed_in_rc) {
                    D_AppendWrite(rc_input_file, StringF(&arena, Lit("%F %F DISCARDABLE %F\n"), FmtStr(D_GetName(shaders_tar_file)), FmtStr(Lit("RCDATA")), FmtStr(D_GetName(shaders_tar_file))));
                    if (should_embed_res_dir) {
                        D_AppendWrite(rc_input_file, StringF(&arena, Lit("%F %F DISCARDABLE %F\n"), FmtStr(D_GetName(res_tar_file)), FmtStr(Lit("RCDATA")), FmtStr(D_GetName(res_tar_file))));
                    }
                }
            }
        }

        {
            String rc_compile_args_fmt = StringFromStringLists(&arena, Lit(" "), rc_compile_args);
            D_AddDependency(&store, rc_res_file, rc_input_file);

            if (IsDirty(rc_res_file)) {
                BuildStepSimpleCommandArg *bs_arg = ArenaPush(&arena, BuildStepSimpleCommandArg);
                bs_arg->cmd = StringF(&arena, rc_compile_args_fmt, FmtStr(rc_res_file.full_path), FmtStr(rc_input_file.full_path));
                String step_name = StringF(&arena, Lit("%F -> %F"), FmtStr(D_GetName(rc_input_file)), FmtStr(D_GetName(rc_res_file)));
                AddStep(&rc_and_pch_build_steps, step_name, &BuildStepSimpleCommand, bs_arg);
            }

            D_TagListAppend(&arena, &link_files, rc_res_file);
        }
    }

    /* ========================== *
     * Build step: Compile pch files
     * ========================== */

    D_TagList depfile_force_includes = { 0 };
    {
        D_Tag pch_header_file = D_TagFromPath(&arena, Lit("src/common.h"), D_TagKind_File);
        D_Tag dep_file;
        {
            String name = D_GetName(pch_header_file);
            String dep_file_path = StringF(&arena, Lit("%F/%F.%F"), FmtStr(out_obj_dir_path), FmtStr(name), FmtStr(dep_file_extension));
            dep_file = D_TagFromPath(&arena, dep_file_path, D_TagKind_DepFile);
        }

        D_Tag pch_c_file = D_TagFromPath(&arena, StringF(&arena, Lit("%F/%F.c_pch"), FmtStr(out_obj_dir_path), FmtStr(D_GetName(pch_header_file))), D_TagKind_File);
        D_AddDependency(&store, pch_c_file, pch_header_file);
        D_AddDependency(&store, pch_c_file, dep_file);

        D_Tag pch_cpp_file = D_TagFromPath(&arena, StringF(&arena, Lit("%F/%F.cpp_pch"), FmtStr(out_obj_dir_path), FmtStr(D_GetName(pch_header_file))), D_TagKind_File);
        D_AddDependency(&store, pch_cpp_file, pch_header_file);
        D_AddDependency(&store, pch_cpp_file, dep_file);

        if (arg_msvc) {
            D_TagListAppend(&arena, &depfile_force_includes, pch_header_file);

            D_Tag pch_c_src_gen_file = D_TagFromPath(&arena, StringF(&arena, Lit("%F/common.c"), FmtStr(out_obj_dir_path)), D_TagKind_File);
            D_Tag pch_c_src_gen_obj_file = D_TagFromPath(&arena, StringF(&arena, Lit("%F/common.c.obj"), FmtStr(out_obj_dir_path)), D_TagKind_File);
            D_Tag pch_cpp_src_gen_file = D_TagFromPath(&arena, StringF(&arena, Lit("%F/common.cpp"), FmtStr(out_obj_dir_path)), D_TagKind_File);
            D_Tag pch_cpp_src_gen_obj_file = D_TagFromPath(&arena, StringF(&arena, Lit("%F/common.cpp.obj"), FmtStr(out_obj_dir_path)), D_TagKind_File);

            StringListAppend(&arena, &c_compile_args, StringF(&arena, Lit("/Yu\"%F\" /FI\"%F\" /Fp\"%F\""), FmtStr(pch_header_file.full_path), FmtStr(pch_header_file.full_path), FmtStr(pch_c_file.full_path)));
            StringListAppend(&arena, &cpp_compile_args, StringF(&arena, Lit("/Yu\"%F\" /FI\"%F\" /Fp\"%F\""), FmtStr(pch_header_file.full_path), FmtStr(pch_header_file.full_path), FmtStr(pch_cpp_file.full_path)));
            StringListAppend(&arena, &pch_c_compile_args, StringF(&arena, Lit("/FI\"%F\" /Fp\"%F\" /Fo\"%F\""), FmtStr(pch_header_file.full_path), FmtStr(pch_c_file.full_path), FmtStr(pch_c_src_gen_obj_file.full_path)));
            StringListAppend(&arena, &pch_cpp_compile_args, StringF(&arena, Lit("/FI\"%F\" /Fp\"%F\" /Fo\"%F\""), FmtStr(pch_header_file.full_path), FmtStr(pch_cpp_file.full_path), FmtStr(pch_cpp_src_gen_obj_file.full_path)));

            D_TagListAppend(&arena, &link_files, pch_c_src_gen_obj_file);
            D_TagListAppend(&arena, &link_files, pch_cpp_src_gen_obj_file);

            String pch_c_compile_args_fmt = StringFromStringLists(&arena, Lit(" "), pch_c_compile_args, compile_warnings, compile_and_link_args, compile_args);
            String pch_cpp_compile_args_fmt = StringFromStringLists(&arena, Lit(" "), pch_cpp_compile_args, compile_warnings, compile_and_link_args, compile_args);

            /* C */
            D_AddDependency(&store, pch_c_src_gen_obj_file, pch_c_src_gen_file);
            D_AddDependency(&store, pch_c_file, pch_c_src_gen_obj_file);
            if (IsDirty(pch_c_file)) {
                D_ClearWrite(pch_c_src_gen_file, Lit(""));
                BuildStepSimpleCommandArg *bs_arg = ArenaPush(&arena, BuildStepSimpleCommandArg);
                bs_arg->cmd = StringF(&arena, pch_c_compile_args_fmt, FmtStr(pch_header_file.full_path), FmtStr(pch_c_src_gen_file.full_path));
                String step_name = StringF(&arena, Lit("%F -> %F"), FmtStr(D_GetName(pch_header_file)), FmtStr(D_GetName(pch_c_file)));
                AddStep(&rc_and_pch_build_steps, step_name, &BuildStepSimpleCommand, bs_arg);
            }

            /* Cpp */
            D_AddDependency(&store, pch_cpp_src_gen_obj_file, pch_cpp_src_gen_file);
            D_AddDependency(&store, pch_cpp_file, pch_cpp_src_gen_obj_file);
            if (IsDirty(pch_cpp_file)) {
                D_ClearWrite(pch_cpp_src_gen_file, Lit(""));
                BuildStepSimpleCommandArg *bs_arg = ArenaPush(&arena, BuildStepSimpleCommandArg);
                bs_arg->cmd = StringF(&arena, pch_cpp_compile_args_fmt, FmtStr(pch_header_file.full_path), FmtStr(pch_cpp_src_gen_file.full_path));
                String step_name = StringF(&arena, Lit("%F -> %F"), FmtStr(D_GetName(pch_header_file)), FmtStr(D_GetName(pch_cpp_file)));
                AddStep(&rc_and_pch_build_steps, step_name, &BuildStepSimpleCommand, bs_arg);
            }
        } else {
            StringListAppend(&arena, &c_compile_args, StringF(&arena, Lit("-include-pch %F"), FmtStr(pch_c_file.full_path)));
            StringListAppend(&arena, &cpp_compile_args, StringF(&arena, Lit("-include-pch %F"), FmtStr(pch_cpp_file.full_path)));

            String pch_c_compile_args_fmt = StringFromStringLists(&arena, Lit(" "), pch_c_compile_args, compile_warnings, compile_and_link_args, compile_args);
            String pch_cpp_compile_args_fmt = StringFromStringLists(&arena, Lit(" "), pch_cpp_compile_args, compile_warnings, compile_and_link_args, compile_args);

            /* C */
            if (IsDirty(pch_c_file)) {
                String step_name = StringF(&arena, Lit("%F -> %F"), FmtStr(D_GetName(pch_header_file)), FmtStr(D_GetName(pch_c_file)));
                BuildStepMsvcCompileCommandArg *bs_arg = ArenaPush(&arena, BuildStepMsvcCompileCommandArg);
                bs_arg->cmd = StringF(&arena, pch_c_compile_args_fmt, FmtStr(pch_header_file.full_path), FmtStr(pch_c_file.full_path));
                bs_arg->depfile_dependent = pch_header_file;
                bs_arg->output_depfile = dep_file;
                AddStep(&rc_and_pch_build_steps, step_name, &BuildStepMsvcCompileCommand, bs_arg);
            }

            /* Cpp */
            if (IsDirty(pch_cpp_file)) {
                String step_name = StringF(&arena, Lit("%F -> %F"), FmtStr(D_GetName(pch_header_file)), FmtStr(D_GetName(pch_cpp_file)));
                BuildStepMsvcCompileCommandArg *bs_arg = ArenaPush(&arena, BuildStepMsvcCompileCommandArg);
                bs_arg->cmd = StringF(&arena, pch_cpp_compile_args_fmt, FmtStr(pch_header_file.full_path), FmtStr(pch_cpp_file.full_path));
                bs_arg->depfile_dependent = pch_header_file;
                bs_arg->output_depfile = dep_file;
                AddStep(&rc_and_pch_build_steps, step_name, &BuildStepMsvcCompileCommand, bs_arg);
            }
        }
    }

    /* ========================== *
     * Build step: Compile src files
     * ========================== */

    {
        D_TagList src_input_files = { 0 };
        {
            D_Tag src_dir = D_TagFromPath(&arena, Lit("src"), D_TagKind_Dir);
            D_TagList src_dir_files = D_GetDirContents(&arena, src_dir);
            for (D_TagListNode *n = src_dir_files.first; n; n = n->next) {
                Bool ignore = true;

                D_Tag file = n->tag;
                String path = file.full_path;
                String name = D_GetName(file);
                String extension = StringPathExtension(name);
                Bool is_dir = file.kind == D_TagKind_Dir;
                Bool is_c = !is_dir && StringEqual(extension, Lit("c"));
                Bool is_cpp = !is_dir && !is_c && StringEqual(extension, Lit("cpp"));
                if (is_c || is_cpp) {
                    if (StringBeginsWith(name, Lit("sys_")) ||
                        StringBeginsWith(name, Lit("renderer_")) ||
                        StringBeginsWith(name, Lit("playback_")) ||
                        StringBeginsWith(name, Lit("mp3_")) ||
                        StringBeginsWith(name, Lit("ttf_"))) {
                        if (PlatformWindows) {
                            ignore = !(StringEqual(name, Lit("sys_win32.c")) ||
                                       StringEqual(name, Lit("renderer_d3d11.c")) ||
                                       StringEqual(name, Lit("playback_wasapi.c")) ||
                                       StringEqual(name, Lit("mp3_mmf.c")) ||
                                       StringEqual(name, Lit("ttf_dwrite.cpp")));
                        }
                    } else {
                        ignore = false;
                    }
                }

                if (!ignore) {
                    D_TagListAppend(&arena, &src_input_files, file);
                }
            }
        }

        {
            String c_compile_args_fmt = StringFromStringLists(&arena, Lit(" "), c_compile_args, compile_warnings, compile_and_link_args, compile_args);
            String cpp_compile_args_fmt = StringFromStringLists(&arena, Lit(" "), cpp_compile_args, compile_warnings, compile_and_link_args, compile_args);
            for (D_TagListNode *n = src_input_files.first; n; n = n->next) {
                D_Tag file = n->tag;
                String path = file.full_path;
                String name = D_GetName(file);
                String extension = StringPathExtension(name);
                Bool is_c = StringEqual(extension, Lit("c"));
                Bool is_cpp = !is_c && StringEqual(extension, Lit("cpp"));

                D_Tag dep_file;
                {
                    String name_no_extension = StringPathNoExtension(name);
                    String dep_file_path = StringF(&arena, Lit("%F/%F.%F"), FmtStr(out_obj_dir_path), FmtStr(name_no_extension), FmtStr(dep_file_extension));
                    dep_file = D_TagFromPath(&arena, dep_file_path, D_TagKind_DepFile);
                }

                D_Tag obj_file;
                {
                    String name_no_extension = StringPathNoExtension(name);
                    String obj_file_path = StringF(&arena, Lit("%F/%F.%F"), FmtStr(out_obj_dir_path), FmtStr(name_no_extension), FmtStr(obj_file_extension));
                    obj_file = D_TagFromPath(&arena, obj_file_path, D_TagKind_File);
                }
                D_AddDependency(&store, obj_file, file);
                D_AddDependency(&store, obj_file, dep_file);

                if (IsDirty(obj_file)) {
                    String comp_cmd_fmt = is_c ? c_compile_args_fmt : cpp_compile_args_fmt;
                    String step_name = StringF(&arena, Lit("%F -> %F"), FmtStr(name), FmtStr(D_GetName(obj_file)));
                    if (arg_msvc) {
                        BuildStepMsvcCompileCommandArg *bs_arg = ArenaPush(&arena, BuildStepMsvcCompileCommandArg);
                        bs_arg->cmd = StringF(&arena, comp_cmd_fmt, FmtStr(file.full_path), FmtStr(obj_file.full_path));
                        bs_arg->depfile_dependent = obj_file;
                        bs_arg->output_depfile = dep_file;
                        bs_arg->depfile_force_includes = depfile_force_includes;
                        AddStep(&comp_build_steps, step_name, &BuildStepMsvcCompileCommand, bs_arg);
                    } else {
                        BuildStepSimpleCommandArg *bs_arg = ArenaPush(&arena, BuildStepSimpleCommandArg);
                        bs_arg->cmd = StringF(&arena, comp_cmd_fmt, FmtStr(file.full_path), FmtStr(obj_file.full_path));
                        AddStep(&comp_build_steps, step_name, &BuildStepSimpleCommand, bs_arg);
                    }
                }

                D_TagListAppend(&arena, &link_files, obj_file);
            }
        }
    }

    /* ========================== *
     * Build step: Link
     * ========================== */

    {
        String link_files_str = { 0 };
        {
            StringList link_files_quoted_list = { 0 };
            for (D_TagListNode *n = link_files.first; n; n = n->next) {
                D_Tag file = n->tag;
                String path = StringF(&arena, Lit("\"%F\""), FmtStr(file.full_path));
                StringListAppend(&arena, &link_files_quoted_list, path);
                D_AddDependency(&store, executable_file, file);
            }
            link_files_str = StringFromStringList(&arena, Lit(" "), link_files_quoted_list);
        }
        if (link_files_str.len > 0) {
            String link_args_fmt = StringFromStringLists(&arena, Lit(" "), link_args, link_warnings, compile_and_link_args);
            BuildStepSimpleCommandArg *bs_arg = ArenaPush(&arena, BuildStepSimpleCommandArg);
            bs_arg->cmd = StringF(&arena, link_args_fmt, FmtStr(link_files_str), FmtStr(executable_file.full_path));
            String step_name = Lit("Linking");
            AddStep(&link_build_steps, step_name, &BuildStepSimpleCommand, bs_arg);
        }
    }

     /* ========================== *
      * Execute build steps
      * ========================== */

    /* TODO: Cleanup (testing parallel stuff) */

    Bool success = true;
    if (IsDirty(executable_file)) {
        AddStepListToWorkQueue(&tar_build_steps);
        AddStepListToWorkQueue(&rc_and_pch_build_steps);
        AddStepListToWorkQueue(&comp_build_steps);
        AddStepListToWorkQueue(&link_build_steps);

        I64 step_count = 0;
        step_count += tar_build_steps.count;
        step_count += rc_and_pch_build_steps.count;
        step_count += comp_build_steps.count;
        step_count += link_build_steps.count;

        Step *s = tar_build_steps.first;
        {
            if (!s) {
                s = rc_and_pch_build_steps.first;
                if (!s) {
                    s = comp_build_steps.first;
                    if (!s) {
                        s = link_build_steps.first;
                    }
                }

            }
        }
        I64 step_i = 0;
        while (s) {
            ++step_i;

            SH_PrintF(Lit("[%F/%F] %F\n"), FmtI64(step_i), FmtI64(step_count), FmtStr(s->name));

            OS_MutexLockR(&s->res_mutex);
            {
                while (s->res_status == StepStatus_None) {
                    OS_ConditionVariableWaitR(&s->res_cv, &s->res_mutex);
                }
            }
            OS_MutexUnlockR(&s->res_mutex);

            String output = s->res_output;
            if (s->res_status != StepStatus_Success) {
                Assert(false);
                success = false;
                SH_PrintF(Lit("%F\n"), FmtStr(output));
                break;
            }

            {
                if (s == tar_build_steps.last) {
                    s = rc_and_pch_build_steps.first;
                    if (s) goto skip_cont;
                }
                if (s == rc_and_pch_build_steps.last) {
                    s = comp_build_steps.first;
                    if (s) goto skip_cont;
                }
                if (s == comp_build_steps.last) {
                    s = link_build_steps.first;
                    if (s) goto skip_cont;
                }
            }
            s = s->next;
            skip_cont:
            continue;
        }
    } else {
        SH_Print(Lit("No work to do\n"));
    }

    if (!success) {
        Error(Lit("Build failed\n"));
        OS_Exit(1);
    }

    /* ========================== *
     * Write hist file
     * ========================== */

    D_WriteStoreToHistFile(&store, hist_path);

    ShutdownWorkers();

#if 0
#if Rtc
    getchar();
#endif
#endif
}