const std = @import("std");
const assert = std.debug.assert;
const builtin = @import("builtin");
const arch = builtin.cpu.arch;
const os = builtin.os.tag;

fn discover_brew_prefix(b: *std.Build, library_name: []const u8) ![]const u8 {
    assert(os == .macos);
    const result = try std.ChildProcess.run(.{
        .allocator = b.allocator,
        .argv = &.{ "brew", "--prefix", library_name },
    });

    var i = result.stdout.len - 1;
    while (result.stdout[i] == '\n' or result.stdout[i] == ' ') {
        i -= 1;
    }
    const trimmed_path = result.stdout[0 .. i + 1];
    return trimmed_path;
}

pub fn build(b: *std.Build) !void {
    const self_hosted_ci = b.option(bool, "self_hosted_ci", "This option enables the self-hosted CI behavior") orelse false;
    const third_party_ci = b.option(bool, "third_party_ci", "This option enables the third-party CI behavior") orelse false;
    const is_ci = self_hosted_ci or third_party_ci;
    const print_stack_trace = b.option(bool, "print_stack_trace", "This option enables printing stack traces inside the compiler") orelse is_ci;
    const native_target = b.resolveTargetQuery(.{});
    const optimization = b.standardOptimizeOption(.{});
    const enable_editor = false;
    const use_editor = b.option(bool, "editor", "Use the GUI editor to play around the programming language") orelse (!is_ci and enable_editor);
    const use_debug = b.option(bool, "use_debug", "This option enables the LLVM debug build in the development PC") orelse false;
    const static = b.option(bool, "static", "This option enables the compiler to be built statically") orelse switch (@import("builtin").os.tag) {
        else => use_debug,
        .windows => true,
        // .macos => true,
    };
    const compiler_options = b.addOptions();
    compiler_options.addOption(bool, "print_stack_trace", print_stack_trace);
    compiler_options.addOption(bool, "ci", is_ci);
    compiler_options.addOption(bool, "editor", use_editor);

    const fetcher = b.addExecutable(.{
        .name = "llvm_fetcher",
        .root_source_file = b.path("build/fetcher.zig"),
        .target = native_target,
        .optimize = .Debug,
        .single_threaded = true,
    });

    var target_query = b.standardTargetOptionsQueryOnly(switch (@import("builtin").os.tag) {
        else => .{},
        .windows => .{
            .default_target = .{
                .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64_v3 },
                .cpu_arch = .x86_64,
                .os_tag = .windows,
                .abi = .gnu,
            },
        },
    });
    const abi = b.option(std.Target.Abi, "abi", "This option modifies the ABI used for the compiler") orelse if (static) switch (target_query.os_tag orelse @import("builtin").os.tag) {
        else => target_query.abi,
        .linux => b: {
            const os_release = try std.fs.cwd().readFileAlloc(b.allocator, "/etc/os-release", 0xffff);
            const attribute_name = "ID=";
            const i = std.mem.indexOf(u8, os_release, attribute_name) orelse unreachable;
            const maybe_start_quote_index = i + attribute_name.len;
            const value = if (os_release[maybe_start_quote_index] == '\"') attr: {
                const end_quote_index = std.mem.indexOf(u8, os_release[maybe_start_quote_index + 1 ..], "\"") orelse unreachable;
                const attribute_value = os_release[maybe_start_quote_index + 1 ..][0..end_quote_index];
                break :attr attribute_value;
            } else attr: {
                const line_feed = std.mem.indexOf(u8, os_release[maybe_start_quote_index..], "\n") orelse unreachable;
                const attribute_value = os_release[maybe_start_quote_index..][0..line_feed];
                break :attr attribute_value;
            };
            break :b if (std.mem.eql(u8, value, "arch") or std.mem.eql(u8, value, "endeavouros")) .musl else target_query.abi;
        },
    } else target_query.abi;

    target_query.abi = abi;
    const target = b.resolveTargetQuery(target_query);

    const compiler = b.addExecutable(.{
        .name = "nat",
        .root_source_file = b.path("bootstrap/main.zig"),
        .target = target,
        .optimize = optimization,
    });

    const cpp_files = .{
        "src/llvm/llvm.cpp",
        // "src/llvm/lld.cpp",
        // "src/llvm/clang_main.cpp",
        // "src/llvm/clang_cc1.cpp",
        // "src/llvm/clang_cc1as.cpp",
        // "src/llvm/ar.cpp",
    };

    compiler.addCSourceFiles(.{
        .files = &cpp_files,
        .flags = &.{
            "-g",
            "-std=c++17",
            "-D__STDC_CONSTANT_MACROS",
            "-D__STDC_FORMAT_MACROS",
            "-D__STDC_LIMIT_MACROS",
            "-D_GNU_SOURCE",
            "-fvisibility-inlines-hidden",
            "-fno-exceptions",
            "-fno-rtti",
            "-Werror=type-limits",
            "-Wno-missing-braces",
            "-Wno-comment",
        },
    });

    compiler.root_module.addOptions("configuration", compiler_options);
    compiler.formatted_panics = print_stack_trace;
    compiler.root_module.unwind_tables = print_stack_trace or target.result.os.tag == .windows;
    compiler.root_module.omit_frame_pointer = false;
    compiler.root_module.error_tracing = print_stack_trace;
    compiler.want_lto = false;

    compiler.linkLibC();

    const zstd = if (target.result.os.tag == .windows) "zstd.lib" else "libzstd.a";

    const static_llvm_libraries = [_][]const u8{
        "libLLVMAArch64AsmParser.a",
        "libLLVMAArch64CodeGen.a",
        "libLLVMAArch64Desc.a",
        "libLLVMAArch64Disassembler.a",
        "libLLVMAArch64Info.a",
        "libLLVMAArch64Utils.a",
        "libLLVMAggressiveInstCombine.a",
        "libLLVMAMDGPUAsmParser.a",
        "libLLVMAMDGPUCodeGen.a",
        "libLLVMAMDGPUDesc.a",
        "libLLVMAMDGPUDisassembler.a",
        "libLLVMAMDGPUInfo.a",
        "libLLVMAMDGPUTargetMCA.a",
        "libLLVMAMDGPUUtils.a",
        "libLLVMAnalysis.a",
        "libLLVMARMAsmParser.a",
        "libLLVMARMCodeGen.a",
        "libLLVMARMDesc.a",
        "libLLVMARMDisassembler.a",
        "libLLVMARMInfo.a",
        "libLLVMARMUtils.a",
        "libLLVMAsmParser.a",
        "libLLVMAsmPrinter.a",
        "libLLVMAVRAsmParser.a",
        "libLLVMAVRCodeGen.a",
        "libLLVMAVRDesc.a",
        "libLLVMAVRDisassembler.a",
        "libLLVMAVRInfo.a",
        "libLLVMBinaryFormat.a",
        "libLLVMBitReader.a",
        "libLLVMBitstreamReader.a",
        "libLLVMBitWriter.a",
        "libLLVMBPFAsmParser.a",
        "libLLVMBPFCodeGen.a",
        "libLLVMBPFDesc.a",
        "libLLVMBPFDisassembler.a",
        "libLLVMBPFInfo.a",
        "libLLVMCFGuard.a",
        "libLLVMCFIVerify.a",
        "libLLVMCodeGen.a",
        "libLLVMCodeGenTypes.a",
        "libLLVMCore.a",
        "libLLVMCoroutines.a",
        "libLLVMCoverage.a",
        "libLLVMDebugInfoBTF.a",
        "libLLVMDebugInfoCodeView.a",
        "libLLVMDebuginfod.a",
        "libLLVMDebugInfoDWARF.a",
        "libLLVMDebugInfoGSYM.a",
        "libLLVMDebugInfoLogicalView.a",
        "libLLVMDebugInfoMSF.a",
        "libLLVMDebugInfoPDB.a",
        "libLLVMDemangle.a",
        "libLLVMDiff.a",
        "libLLVMDlltoolDriver.a",
        "libLLVMDWARFLinker.a",
        "libLLVMDWARFLinkerParallel.a",
        "libLLVMDWP.a",
        "libLLVMExecutionEngine.a",
        "libLLVMExtensions.a",
        "libLLVMFileCheck.a",
        "libLLVMFrontendHLSL.a",
        "libLLVMFrontendOpenACC.a",
        "libLLVMFrontendOpenMP.a",
        "libLLVMFuzzerCLI.a",
        "libLLVMFuzzMutate.a",
        "libLLVMGlobalISel.a",
        "libLLVMHexagonAsmParser.a",
        "libLLVMHexagonCodeGen.a",
        "libLLVMHexagonDesc.a",
        "libLLVMHexagonDisassembler.a",
        "libLLVMHexagonInfo.a",
        "libLLVMInstCombine.a",
        "libLLVMInstrumentation.a",
        "libLLVMInterfaceStub.a",
        "libLLVMInterpreter.a",
        "libLLVMipo.a",
        "libLLVMIRPrinter.a",
        "libLLVMIRReader.a",
        "libLLVMJITLink.a",
        "libLLVMLanaiAsmParser.a",
        "libLLVMLanaiCodeGen.a",
        "libLLVMLanaiDesc.a",
        "libLLVMLanaiDisassembler.a",
        "libLLVMLanaiInfo.a",
        "libLLVMLibDriver.a",
        "libLLVMLineEditor.a",
        "libLLVMLinker.a",
        "libLLVMLoongArchAsmParser.a",
        "libLLVMLoongArchCodeGen.a",
        "libLLVMLoongArchDesc.a",
        "libLLVMLoongArchDisassembler.a",
        "libLLVMLoongArchInfo.a",
        "libLLVMLTO.a",
        "libLLVMMC.a",
        "libLLVMMCA.a",
        "libLLVMMCDisassembler.a",
        "libLLVMMCJIT.a",
        "libLLVMMCParser.a",
        "libLLVMMipsAsmParser.a",
        "libLLVMMipsCodeGen.a",
        "libLLVMMipsDesc.a",
        "libLLVMMipsDisassembler.a",
        "libLLVMMipsInfo.a",
        "libLLVMMIRParser.a",
        "libLLVMMSP430AsmParser.a",
        "libLLVMMSP430CodeGen.a",
        "libLLVMMSP430Desc.a",
        "libLLVMMSP430Disassembler.a",
        "libLLVMMSP430Info.a",
        "libLLVMNVPTXCodeGen.a",
        "libLLVMNVPTXDesc.a",
        "libLLVMNVPTXInfo.a",
        "libLLVMObjCARCOpts.a",
        "libLLVMObjCopy.a",
        "libLLVMObject.a",
        "libLLVMObjectYAML.a",
        "libLLVMOption.a",
        "libLLVMOrcJIT.a",
        "libLLVMOrcShared.a",
        "libLLVMOrcTargetProcess.a",
        "libLLVMPasses.a",
        "libLLVMPowerPCAsmParser.a",
        "libLLVMPowerPCCodeGen.a",
        "libLLVMPowerPCDesc.a",
        "libLLVMPowerPCDisassembler.a",
        "libLLVMPowerPCInfo.a",
        "libLLVMProfileData.a",
        "libLLVMRemarks.a",
        "libLLVMRISCVAsmParser.a",
        "libLLVMRISCVCodeGen.a",
        "libLLVMRISCVDesc.a",
        "libLLVMRISCVDisassembler.a",
        "libLLVMRISCVInfo.a",
        "libLLVMRISCVTargetMCA.a",
        "libLLVMRuntimeDyld.a",
        "libLLVMScalarOpts.a",
        "libLLVMSelectionDAG.a",
        "libLLVMSparcAsmParser.a",
        "libLLVMSparcCodeGen.a",
        "libLLVMSparcDesc.a",
        "libLLVMSparcDisassembler.a",
        "libLLVMSparcInfo.a",
        "libLLVMSupport.a",
        "libLLVMSymbolize.a",
        "libLLVMSystemZAsmParser.a",
        "libLLVMSystemZCodeGen.a",
        "libLLVMSystemZDesc.a",
        "libLLVMSystemZDisassembler.a",
        "libLLVMSystemZInfo.a",
        "libLLVMTableGen.a",
        "libLLVMTableGenCommon.a",
        "libLLVMTableGenGlobalISel.a",
        "libLLVMTarget.a",
        "libLLVMTargetParser.a",
        "libLLVMTextAPI.a",
        "libLLVMTransformUtils.a",
        "libLLVMVEAsmParser.a",
        "libLLVMVECodeGen.a",
        "libLLVMVectorize.a",
        "libLLVMVEDesc.a",
        "libLLVMVEDisassembler.a",
        "libLLVMVEInfo.a",
        "libLLVMWebAssemblyAsmParser.a",
        "libLLVMWebAssemblyCodeGen.a",
        "libLLVMWebAssemblyDesc.a",
        "libLLVMWebAssemblyDisassembler.a",
        "libLLVMWebAssemblyInfo.a",
        "libLLVMWebAssemblyUtils.a",
        "libLLVMWindowsDriver.a",
        "libLLVMWindowsManifest.a",
        "libLLVMX86AsmParser.a",
        "libLLVMX86CodeGen.a",
        "libLLVMX86Desc.a",
        "libLLVMX86Disassembler.a",
        "libLLVMX86Info.a",
        "libLLVMX86TargetMCA.a",
        "libLLVMXCoreCodeGen.a",
        "libLLVMXCoreDesc.a",
        "libLLVMXCoreDisassembler.a",
        "libLLVMXCoreInfo.a",
        "libLLVMXRay.a",
        //LLD
        "liblldCOFF.a",
        "liblldCommon.a",
        "liblldELF.a",
        "liblldMachO.a",
        "liblldMinGW.a",
        "liblldWasm.a",
        // Zlib
        "libz.a",
        // Zstd
        zstd,
        // Clang
        "libclangAnalysis.a",
        "libclangAnalysisFlowSensitive.a",
        "libclangAnalysisFlowSensitiveModels.a",
        "libclangAPINotes.a",
        "libclangARCMigrate.a",
        "libclangAST.a",
        "libclangASTMatchers.a",
        "libclangBasic.a",
        "libclangCodeGen.a",
        "libclangCrossTU.a",
        "libclangDependencyScanning.a",
        "libclangDirectoryWatcher.a",
        "libclangDriver.a",
        "libclangDynamicASTMatchers.a",
        "libclangEdit.a",
        "libclangExtractAPI.a",
        "libclangFormat.a",
        "libclangFrontend.a",
        "libclangFrontendTool.a",
        "libclangHandleCXX.a",
        "libclangHandleLLVM.a",
        "libclangIndex.a",
        "libclangIndexSerialization.a",
        "libclangInterpreter.a",
        "libclangLex.a",
        "libclangParse.a",
        "libclangRewrite.a",
        "libclangRewriteFrontend.a",
        "libclangSema.a",
        "libclangSerialization.a",
        "libclangStaticAnalyzerCheckers.a",
        "libclangStaticAnalyzerCore.a",
        "libclangStaticAnalyzerFrontend.a",
        "libclangSupport.a",
        "libclangTooling.a",
        "libclangToolingASTDiff.a",
        "libclangToolingCore.a",
        "libclangToolingInclusions.a",
        "libclangToolingInclusionsStdlib.a",
        "libclangToolingRefactoring.a",
        "libclangToolingSyntax.a",
        "libclangTransformer.a",
    };

    if (static or target.result.os.tag == .windows) {
        if (target.result.os.tag == .linux) compiler.linkage = .static;
        compiler.linkLibCpp();

        const prefix = "nat/cache";
        const llvm_version = "17.0.6";
        const llvm_path = b.option([]const u8, "llvm_path", "LLVM prefix path") orelse blk: {
            assert(!self_hosted_ci);
            if (third_party_ci or (!target.query.isNativeOs() or !target.query.isNativeCpu())) {
                var llvm_directory = try std.ArrayListUnmanaged(u8).initCapacity(b.allocator, 128);
                const cpu = if (std.mem.eql(u8, target.result.cpu.model.name, @tagName(target.result.cpu.arch))) "baseline" else target.result.cpu.model.name;
                if (!is_ci) {
                    llvm_directory.appendSliceAssumeCapacity(prefix ++ "/");
                    llvm_directory.appendSliceAssumeCapacity("llvm-");
                    llvm_directory.appendSliceAssumeCapacity(llvm_version);
                    llvm_directory.appendSliceAssumeCapacity("-");
                    llvm_directory.appendSliceAssumeCapacity(@tagName(target.result.cpu.arch));
                    llvm_directory.appendSliceAssumeCapacity("-");
                    llvm_directory.appendSliceAssumeCapacity(@tagName(target.result.os.tag));
                    llvm_directory.appendSliceAssumeCapacity("-");
                    llvm_directory.appendSliceAssumeCapacity(@tagName(target.result.abi));
                    llvm_directory.appendSliceAssumeCapacity("-");
                    llvm_directory.appendSliceAssumeCapacity(cpu);
                } else {
                    llvm_directory.appendSliceAssumeCapacity(prefix ++ "/x86_64-linux-gnu-x86_64_v3-release-static");
                }

                const url = if (is_ci) "https://github.com/birth-software/fetch-llvm/releases/download/v17.0.6/x86_64-linux-gnu-x86_64_v3-release-static.tar.gz" else try std.mem.concat(b.allocator, u8, &.{ "https://github.com/birth-software/fetch-llvm/releases/download/v", llvm_version, "/llvm-", llvm_version, "-", @tagName(target.result.cpu.arch), "-", @tagName(target.result.os.tag), "-", @tagName(target.result.abi), "-", cpu, ".tar.xz" });

                var dir = std.fs.cwd().openDir(llvm_directory.items, .{}) catch {
                    const run = b.addRunArtifact(fetcher);
                    compiler.step.dependOn(&run.step);
                    run.addArg("-prefix");
                    run.addArg(prefix);
                    run.addArg("-url");
                    run.addArg(url);
                    break :blk llvm_directory.items;
                };

                dir.close();

                break :blk llvm_directory.items;
            } else {
                break :blk switch (use_debug) {
                    true => "../zig-bootstrap/out/x86_64-linux-musl-native-debug-static",
                    false => "../zig-bootstrap/out/x86_64-linux-musl-native-release-static",
                };
            }
        };

        const llvm_include_dir = try std.mem.concat(b.allocator, u8, &.{ llvm_path, "/include" });
        compiler.addIncludePath(std.Build.path(b, llvm_include_dir));
        const llvm_lib_dir = try std.mem.concat(b.allocator, u8, &.{ llvm_path, "/lib" });

        for (static_llvm_libraries) |llvm_library| {
            compiler.addObjectFile(std.Build.path(b, try std.mem.concat(b.allocator, u8, &.{ llvm_lib_dir, "/", llvm_library })));
        }
    } else {
        compiler.linkSystemLibrary("LLVM");
        // compiler.linkSystemLibrary("clang-cpp");
        // compiler.linkSystemLibrary("lldCommon");
        // compiler.linkSystemLibrary("lldCOFF");
        // compiler.linkSystemLibrary("lldELF");
        // compiler.linkSystemLibrary("lldMachO");
        // compiler.linkSystemLibrary("lldWasm");
        // compiler.linkSystemLibrary("unwind");
        // compiler.linkSystemLibrary(if (is_ci) "z" else "zlib");
        // compiler.linkSystemLibrary("zstd");

        switch (target.result.os.tag) {
            .linux => {
                if (third_party_ci) {
                    compiler.addObjectFile(.{ .cwd_relative = "/lib/x86_64-linux-gnu/libstdc++.so.6" });
                    compiler.addIncludePath(.{ .cwd_relative = "/usr/include" });
                    compiler.addIncludePath(.{ .cwd_relative = "/usr/include/x86_64-linux-gnu" });
                    compiler.addIncludePath(.{ .cwd_relative = "/usr/include/c++/11" });
                    compiler.addIncludePath(.{ .cwd_relative = "/usr/include/x86_64-linux-gnu/c++/11" });
                    compiler.addIncludePath(.{ .cwd_relative = "/usr/lib/llvm-17/include" });
                    compiler.addLibraryPath(.{ .cwd_relative = "/lib/x86_64-linux-gnu" });
                    compiler.addLibraryPath(.{ .cwd_relative = "/usr/lib/llvm-17/lib" });
                } else {
                    const result = try std.ChildProcess.run(.{
                        .allocator = b.allocator,
                        .argv = &.{
                            "c++", "--version",
                        },
                        .max_output_bytes = 0xffffffffffffff,
                    });
                    const success = switch (result.term) {
                        .Exited => |exit_code| exit_code == 0,
                        else => false,
                    };

                    if (!success) {
                        unreachable;
                    }

                    var tokenizer = std.mem.tokenize(u8, result.stdout, " ");
                    const cxx_version = while (tokenizer.next()) |chunk| {
                        if (std.ascii.isDigit(chunk[0])) {
                            if (std.SemanticVersion.parse(chunk)) |sema_version| {
                                break try std.fmt.allocPrint(b.allocator, "{}.{}.{}", .{sema_version.major, sema_version.minor, sema_version.patch});
                            } else |err| err catch {};
                        }
                    } else {
                        unreachable;
                    };

                    const cxx_include_base = try std.mem.concat(b.allocator, u8, &.{ "/usr/include/c++/", cxx_version });
                    const cxx_include_arch = try std.mem.concat(b.allocator, u8, &.{ cxx_include_base, "/" ++ @tagName(@import("builtin").cpu.arch) ++ "-pc-linux-gnu" });
                    compiler.addObjectFile(.{ .cwd_relative = "/usr/lib64/libstdc++.so.6" });
                    compiler.addIncludePath(.{ .cwd_relative = "../../local/llvm18-debug/include" });
                    compiler.addIncludePath(.{ .cwd_relative = "/usr/include" });
                    compiler.addIncludePath(.{ .cwd_relative = cxx_include_base });
                    compiler.addIncludePath(.{ .cwd_relative = cxx_include_arch });
                    compiler.addLibraryPath(.{ .cwd_relative = "../../local/llvm18-debug/lib" });
                    compiler.addLibraryPath(.{ .cwd_relative = "/usr/lib64" });
                }
            },
            .macos => {
                compiler.linkLibCpp();

                if (discover_brew_prefix(b, "llvm@17")) |llvm_prefix| {
                    const llvm_include_path = try std.mem.concat(b.allocator, u8, &.{ llvm_prefix, "/include" });
                    const llvm_lib_path = try std.mem.concat(b.allocator, u8, &.{ llvm_prefix, "/lib" });
                    compiler.addIncludePath(.{ .cwd_relative = llvm_include_path });
                    compiler.addLibraryPath(.{ .cwd_relative = llvm_lib_path });
                } else |err| {
                    return err;
                }

                if (discover_brew_prefix(b, "zstd")) |zstd_prefix| {
                    const zstd_lib_path = try std.mem.concat(b.allocator, u8, &.{ zstd_prefix, "/lib" });
                    compiler.addLibraryPath(.{ .cwd_relative = zstd_lib_path });
                } else |err| {
                    return err;
                }

                if (discover_brew_prefix(b, "zlib")) |zlib_prefix| {
                    const zlib_lib_path = try std.mem.concat(b.allocator, u8, &.{ zlib_prefix, "/lib" });
                    compiler.addLibraryPath(.{ .cwd_relative = zlib_lib_path });
                } else |err| {
                    return err;
                }
            },
            .windows => {},
            else => |tag| @panic(@tagName(tag)),
        }

        if (use_editor) {
            compiler.linkSystemLibrary("glfw");
            compiler.linkSystemLibrary("GL");
            compiler.addCSourceFiles(.{
                .root = b.path("dependencies/imgui"),
                .files = &.{
                    "imgui.cpp",
                    "imgui_draw.cpp",
                    "imgui_tables.cpp",
                    "imgui_widgets.cpp",
                    "backends/imgui_impl_glfw.cpp",
                    "backends/imgui_impl_opengl3.cpp",
                },
                .flags = &.{},
            });
            compiler.addCSourceFile(.{
                .file = b.path("bootstrap/editor.cpp"),
                .flags = &.{ "-g" },
            });
            compiler.addIncludePath(b.path("dependencies/imgui"));
        }
    }

    if (target.result.os.tag == .windows) {
        compiler.linkSystemLibrary("ole32");
        compiler.linkSystemLibrary("version");
        compiler.linkSystemLibrary("uuid");
    }

    const install_exe = b.addInstallArtifact(compiler, .{});
    b.getInstallStep().dependOn(&install_exe.step);
    b.installDirectory(.{
        .source_dir = std.Build.path(b, "lib"),
        .install_dir = .bin,
        .install_subdir = "lib",
    });

    const compiler_exe_path = b.fmt("zig-out/bin/{s}", .{install_exe.dest_sub_path});
    const run_command = b.addSystemCommand(&.{compiler_exe_path});
    run_command.step.dependOn(b.getInstallStep());

    const debug_command = switch (os) {
        .linux => blk: {
            const result = b.addSystemCommand(&.{"gf2"});
            result.addArgs(&.{ "-ex", "set debuginfod enabled off" });
            result.addArgs(&.{ "-ex", "set disassembly-flavor intel" });
            result.addArg("-ex=r");
            result.addArgs(&.{ "-ex", "up" });
            result.addArg("--args");
            break :blk result;
        },
        .windows => blk: {
            const result = b.addSystemCommand(&.{"remedybg"});
            result.addArg("-g");

            break :blk result;
        },
        .macos => blk: {
            const result = b.addSystemCommand(&.{"lldb"});
            result.addArg("--");
            break :blk result;
        },
        else => @compileError("OS not supported"),
    };
    debug_command.step.dependOn(b.getInstallStep());
    debug_command.addArg(compiler_exe_path);

    const test_runner = b.addExecutable(.{
        .name = "test_runner",
        .root_source_file = b.path("build/test_runner.zig"),
        .target = native_target,
        .optimize = optimization,
        .single_threaded = true,
    });
    b.default_step.dependOn(&test_runner.step);

    const test_command = b.addRunArtifact(test_runner);
    test_command.step.dependOn(&compiler.step);
    b.installArtifact(test_runner);
    test_command.step.dependOn(b.getInstallStep());

    if (b.args) |args| {
        run_command.addArgs(args);
        debug_command.addArgs(args);
        test_command.addArgs(args);
    }

    const run_step = b.step("run", "Test the Nativity compiler");
    run_step.dependOn(&run_command.step);
    const debug_step = b.step("debug", "Debug the Nativity compiler");
    debug_step.dependOn(&debug_command.step);
    const test_step = b.step("test", "Test the Nativity compiler");
    test_step.dependOn(&test_command.step);

    const test_all = b.step("test_all", "Test all");
    test_all.dependOn(&test_command.step);
}