// MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS=1 -- use this if you're getting that odd crash on mac
b: *std.Build,
nw_builder: *std.Build,
target: std.Build.ResolvedTarget,
optimize: std.builtin.Mode,
nw_mod: *std.Build.Module,
spirvReflect: SpirvReflect.SpirvGenerator2,
gltf2ozz: ozz.GltfToOzz,
options: *std.Build.Step.Options,
cookShaders: bool,

backlogRoot: []const u8,
// list of all shaders discovered under
// content/_shaders/def
reflectShaderPathList: [][]u8 = undefined,

const engineDepList = [_][]const u8{
    "assets",
    "audio",
    "core",
    "papyrus",
    "platform",
    "rend",
    "imgui",
    "physics",
    "ui",
};

const BuildSystem = @This();
const std = @import("std");
const Build = std.Build;
const LazyPath = Build.LazyPath;

const SpirvReflect = @import("SpirvReflect");
const ozz = @import("ozz");

pub const InitOptions = struct {
    import_name: []const u8 = "Backlog",
    backlogRoot: []const u8 = "./BacklogEngine",
    target: Build.ResolvedTarget,
    optimize: std.builtin.OptimizeMode,
};

pub fn init(b: *std.Build, opts: InitOptions) BuildSystem {
    const nwdep = b.dependency(opts.import_name, .{
        .target = opts.target,
        .optimize = opts.optimize,
    });

    const self = BuildSystem{
        .b = b,
        .nw_builder = nwdep.builder,
        .target = opts.target,
        .optimize = opts.optimize,
        .nw_mod = nwdep.module("Backlog"),
        .backlogRoot = opts.backlogRoot,
        .spirvReflect = SpirvReflect.SpirvGenerator2.init(nwdep.builder, .{}),
        .options = createGameOptions(b),
        .gltf2ozz = ozz.GltfToOzz.init(nwdep.builder, .{}),
        .cookShaders = b.option(bool, "cookShaders", "generates shaders and updates .json files before running the build. (needs to be done whenever shaders are updated, this just runs tools/scripts/cook-shaders.py)") orelse false,
    };

    const exeList = [2]*std.Build.Step.Compile{ self.gltf2ozz.exe, self.spirvReflect.reflect };
    const install_tools = b.step("tools", "installs tools needed to generate outputs for the engine");
    for (exeList) |exe| {
        const toolsInstall = b.addInstallArtifact(exe, .{
            .dest_dir = .{ .override = .{ .custom = "tools" } },
        });

        install_tools.dependOn(&toolsInstall.step);
    }

    {
        const runArtifact = b.addRunArtifact(self.gltf2ozz.exe);
        if (b.args) |args| {
            runArtifact.addArgs(args);
        }

        const run_exe = b.step("gltf2ozz", "runs the gltf animation converter.");
        run_exe.dependOn(&runArtifact.step);
    }

    {
        const runArtifact = b.addRunArtifact(self.spirvReflect.reflect);
        if (b.args) |args| {
            runArtifact.addArgs(args);
        }

        const run_exe = b.step("spv-reflect", "runs the gltf animation converter.");
        run_exe.dependOn(&runArtifact.step);
    }

    return self;
}

pub const AddProgramOptions = struct {
    name: []const u8,
    desc: []const u8,
    root_source_file: LazyPath,
    imports: []const Build.Module.Import = &.{},
};

pub fn addProgram(self: *BuildSystem, opts: AddProgramOptions) *std.Build.Module {
    const b = self.b;

    const exe = self.nw_builder.addExecutable(.{
        .name = opts.name,
        .target = self.target,
        .optimize = self.optimize,
        .root_source_file = self.nw_builder.path("engine/main.zig"),
    });

    b.installArtifact(exe);
    const runArtifact = b.addRunArtifact(exe);
    if (b.args) |args| {
        runArtifact.addArgs(args);
    }
    const run_exe = b.step(self.b.fmt("run-{s}", .{opts.name}), opts.desc);
    run_exe.dependOn(&runArtifact.step);

    // main path = name/main.zig
    const mod = b.addModule(opts.name, .{
        .target = self.target,
        .optimize = self.optimize,
        .root_source_file = opts.root_source_file,
        .imports = opts.imports,
    });

    exe.root_module.addImport("main", mod);
    exe.root_module.addImport("Backlog", self.nw_mod);
    mod.addImport("Backlog", self.nw_mod);
    exe.root_module.addOptions("BacklogOptions", self.options);

    if (self.cookShaders) {
        const cookShadersScript = b.fmt("{s}/tools/scripts/cookShaders.py", .{self.backlogRoot});
        const cookShadersCommand = b.addSystemCommand(&[_][]const u8{"python"});
        cookShadersCommand.addArg(cookShadersScript);

        run_exe.dependOn(&cookShadersCommand.step);
    }

    b.getInstallStep().dependOn(self.nw_builder.getInstallStep());

    return mod;
}

pub fn createGameOptions(b: *std.Build) *std.Build.Step.Options {
    const opts = b.addOptions();

    // build options for core.zig
    opts.addOption(
        bool,
        "mutex_job_queue",
        b.option(bool, "mutex_job_queue", "temporary test, reverts to old mutex based queue behaviour in jobs.zig:JobManager") orelse false,
    );
    opts.addOption(
        bool,
        "zero_logging",
        b.option(bool, "zero_logging", "disables all logging, only intended for use on job dispatch testing") orelse false,
    );
    opts.addOption(
        bool,
        "slow_logging",
        b.option(bool, "slow_logging", "Disables buffered logging, takes a hit to performance but gain timing information on logging") orelse false,
    );
    opts.addOption(
        bool,
        "force_mailbox",
        b.option(bool, "force_mailbox", "forces mailbox mode for present mode. unlocks framerate to irresponsible levels") orelse false,
    );
    opts.addOption(
        bool,
        "use_renderthread",
        true,
    );

    return opts;
}

pub fn addExtraModule(self: *BuildSystem, mod: *std.Build.Module, moduleName: []const u8) void {
    const dep = self.b.dependency(moduleName, .{ .target = self.target, .optimize = self.optimize });
    mod.addImport(moduleName, dep.module(moduleName));
}

pub fn addSDL3Install(self: *BuildSystem, b: *std.Build, optimize: std.builtin.OptimizeMode) void {
    b.installArtifact(b.dependency("sdl3_lib", .{ .target = self.target, .optimize = optimize }).artifact("SDL3"));
}

// ========= standalone build instance =======
// maybe it should be an engine launcher or something..
pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    const spirvDep = b.dependency("SpirvReflect", .{
        .target = target,
        .optimize = optimize,
    });
    _ = spirvDep;

    {
        const mod = b.addModule("Backlog", .{
            .target = target,
            .optimize = optimize,
            .root_source_file = b.path("engine/backlog.zig"),
        });

        for (engineDepList) |depName| {
            const dep = b.dependency(
                depName,
                .{
                    .target = target,
                    .optimize = optimize,
                },
            );
            mod.addImport(depName, dep.module(depName));
        }

        // link in large platform support functions
        {
            const dep = b.dependency("sdl3", .{ .target = target, .optimize = optimize });
            const lib = dep.module("sdl3_lib");

            mod.addImport("sdl3_fwd", lib);
        }
    }

    {
        const mod = b.addModule("BacklogExtern", .{
            .target = target,
            .optimize = optimize,
            .root_source_file = b.path("engine/backlogExtern.zig"),
        });

        for (engineDepList) |depName| {
            const dep = b.dependency(
                depName,
                .{
                    .target = target,
                    .optimize = optimize,
                },
            );
            mod.addImport(depName, dep.module(depName));
        }
    }
}