pub fn build(b: *Build) void {
    const test_step = b.step("test-link", "Run link tests");
    b.default_step = test_step;

    const has_macos_sdk = b.option(bool, "has_macos_sdk", "whether the host provides a macOS SDK in system path");
    const has_ios_sdk = b.option(bool, "has_ios_sdk", "whether the host provides a iOS SDK in system path");
    const has_symlinks_windows = b.option(bool, "has_symlinks_windows", "whether the host is windows and has symlinks enabled");

    const build_opts: BuildOptions = .{
        .has_macos_sdk = has_macos_sdk orelse false,
        .has_ios_sdk = has_ios_sdk orelse false,
        .has_symlinks_windows = has_symlinks_windows orelse false,
    };

    test_step.dependOn(@import("elf.zig").testAll(b, build_opts));
    test_step.dependOn(@import("macho.zig").testAll(b, build_opts));
}

pub const BuildOptions = struct {
    has_macos_sdk: bool,
    has_ios_sdk: bool,
    has_symlinks_windows: bool,
};

pub const Options = struct {
    target: std.Build.ResolvedTarget,
    optimize: std.builtin.OptimizeMode = .Debug,
    use_llvm: bool = true,
    use_lld: bool = false,
};

pub fn addTestStep(b: *Build, prefix: []const u8, opts: Options) *Step {
    const target = opts.target.result.zigTriple(b.allocator) catch @panic("OOM");
    const optimize = @tagName(opts.optimize);
    const use_llvm = if (opts.use_llvm) "llvm" else "no-llvm";
    const name = std.fmt.allocPrint(b.allocator, "test-{s}-{s}-{s}-{s}", .{
        prefix, target, optimize, use_llvm,
    }) catch @panic("OOM");
    return b.step(name, "");
}

const OverlayOptions = struct {
    name: []const u8,
    asm_source_bytes: ?[]const u8 = null,
    c_source_bytes: ?[]const u8 = null,
    c_source_flags: []const []const u8 = &.{},
    cpp_source_bytes: ?[]const u8 = null,
    cpp_source_flags: []const []const u8 = &.{},
    zig_source_bytes: ?[]const u8 = null,
    pic: ?bool = null,
    strip: ?bool = null,
};

pub fn addExecutable(b: *std.Build, base: Options, overlay: OverlayOptions) *Step.Compile {
    const compile_step = b.addExecutable(.{
        .name = overlay.name,
        .root_source_file = rsf: {
            const bytes = overlay.zig_source_bytes orelse break :rsf null;
            break :rsf b.addWriteFiles().add("a.zig", bytes);
        },
        .target = base.target,
        .optimize = base.optimize,
        .use_llvm = base.use_llvm,
        .use_lld = base.use_lld,
        .pic = overlay.pic,
        .strip = overlay.strip,
    });
    if (overlay.cpp_source_bytes) |bytes| {
        compile_step.addCSourceFile(.{
            .file = b.addWriteFiles().add("a.cpp", bytes),
            .flags = overlay.cpp_source_flags,
        });
    }
    if (overlay.c_source_bytes) |bytes| {
        compile_step.addCSourceFile(.{
            .file = b.addWriteFiles().add("a.c", bytes),
            .flags = overlay.c_source_flags,
        });
    }
    if (overlay.asm_source_bytes) |bytes| {
        compile_step.addAssemblyFile(b.addWriteFiles().add("a.s", bytes));
    }
    return compile_step;
}

pub fn addObject(b: *Build, base: Options, overlay: OverlayOptions) *Step.Compile {
    const compile_step = b.addObject(.{
        .name = overlay.name,
        .root_source_file = rsf: {
            const bytes = overlay.zig_source_bytes orelse break :rsf null;
            break :rsf b.addWriteFiles().add("a.zig", bytes);
        },
        .target = base.target,
        .optimize = base.optimize,
        .use_llvm = base.use_llvm,
        .use_lld = base.use_lld,
        .pic = overlay.pic,
        .strip = overlay.strip,
    });
    if (overlay.cpp_source_bytes) |bytes| {
        compile_step.addCSourceFile(.{
            .file = b.addWriteFiles().add("a.cpp", bytes),
            .flags = overlay.cpp_source_flags,
        });
    }
    if (overlay.c_source_bytes) |bytes| {
        compile_step.addCSourceFile(.{
            .file = b.addWriteFiles().add("a.c", bytes),
            .flags = overlay.c_source_flags,
        });
    }
    if (overlay.asm_source_bytes) |bytes| {
        compile_step.addAssemblyFile(b.addWriteFiles().add("a.s", bytes));
    }
    return compile_step;
}

pub fn addStaticLibrary(b: *Build, base: Options, overlay: OverlayOptions) *Compile {
    const compile_step = b.addStaticLibrary(.{
        .name = overlay.name,
        .root_source_file = rsf: {
            const bytes = overlay.zig_source_bytes orelse break :rsf null;
            break :rsf b.addWriteFiles().add("a.zig", bytes);
        },
        .target = base.target,
        .optimize = base.optimize,
        .use_llvm = base.use_llvm,
        .use_lld = base.use_lld,
        .pic = overlay.pic,
        .strip = overlay.strip,
    });
    if (overlay.cpp_source_bytes) |bytes| {
        compile_step.addCSourceFile(.{
            .file = b.addWriteFiles().add("a.cpp", bytes),
            .flags = overlay.cpp_source_flags,
        });
    }
    if (overlay.c_source_bytes) |bytes| {
        compile_step.addCSourceFile(.{
            .file = b.addWriteFiles().add("a.c", bytes),
            .flags = overlay.c_source_flags,
        });
    }
    if (overlay.asm_source_bytes) |bytes| {
        compile_step.addAssemblyFile(b.addWriteFiles().add("a.s", bytes));
    }
    return compile_step;
}

pub fn addSharedLibrary(b: *Build, base: Options, overlay: OverlayOptions) *Compile {
    const compile_step = b.addSharedLibrary(.{
        .name = overlay.name,
        .root_source_file = rsf: {
            const bytes = overlay.zig_source_bytes orelse break :rsf null;
            break :rsf b.addWriteFiles().add("a.zig", bytes);
        },
        .target = base.target,
        .optimize = base.optimize,
        .use_llvm = base.use_llvm,
        .use_lld = base.use_lld,
        .pic = overlay.pic,
        .strip = overlay.strip,
    });
    if (overlay.cpp_source_bytes) |bytes| {
        compile_step.addCSourceFile(.{
            .file = b.addWriteFiles().add("a.cpp", bytes),
            .flags = overlay.cpp_source_flags,
        });
    }
    if (overlay.c_source_bytes) |bytes| {
        compile_step.addCSourceFile(.{
            .file = b.addWriteFiles().add("a.c", bytes),
            .flags = overlay.c_source_flags,
        });
    }
    if (overlay.asm_source_bytes) |bytes| {
        compile_step.addAssemblyFile(b.addWriteFiles().add("a.s", bytes));
    }
    return compile_step;
}

pub fn addRunArtifact(comp: *Compile) *Run {
    const b = comp.step.owner;
    const run = b.addRunArtifact(comp);
    run.skip_foreign_checks = true;
    return run;
}

pub fn addCSourceBytes(comp: *Compile, bytes: []const u8, flags: []const []const u8) void {
    const b = comp.step.owner;
    const file = WriteFile.create(b).add("a.c", bytes);
    comp.addCSourceFile(.{ .file = file, .flags = flags });
}

pub fn addCppSourceBytes(comp: *Compile, bytes: []const u8, flags: []const []const u8) void {
    const b = comp.step.owner;
    const file = WriteFile.create(b).add("a.cpp", bytes);
    comp.addCSourceFile(.{ .file = file, .flags = flags });
}

pub fn addAsmSourceBytes(comp: *Compile, bytes: []const u8) void {
    const b = comp.step.owner;
    const actual_bytes = std.fmt.allocPrint(b.allocator, "{s}\n", .{bytes}) catch @panic("OOM");
    const file = WriteFile.create(b).add("a.s", actual_bytes);
    comp.addAssemblyFile(file);
}

pub fn expectLinkErrors(comp: *Compile, test_step: *Step, expected_errors: Compile.ExpectedCompileErrors) void {
    comp.expect_errors = expected_errors;
    const bin_file = comp.getEmittedBin();
    bin_file.addStepDependencies(test_step);
}

const std = @import("std");

const Build = std.Build;
const Compile = Step.Compile;
const Run = Step.Run;
const Step = Build.Step;
const WriteFile = Step.WriteFile;