const std = @import("std");

pub fn main(init: std.process.Init) !void {
    // Build-time helper: short-lived process that downloads a single
    // file. Arena lets us skip per-allocation `defer free(...)` and
    // amortizes the allocation cost across the run via the arena's
    // exponential block growth. Process exit reclaims everything.
    const allocator = init.arena.allocator();
    const io = init.io;

    const args = try init.minimal.args.toSlice(allocator);

    if (args.len != 3) return error.InvalidArgs;

    const kcov_path = args[1];
    const arch_name = args[2];

    // Check to see if file exists. If it does, we have nothing more to do
    const stat = std.Io.Dir.cwd().statFile(io, kcov_path, .{}) catch |err| blk: {
        if (err == error.FileNotFound) break :blk null else return err;
    };
    // This might be better checking whether it's executable and >= 7MB, but
    // for now, we'll do a simple exists check
    if (stat != null) return;
    var stdout_buffer: [1024]u8 = undefined;
    var stdout_writer = std.Io.File.stdout().writer(io, &stdout_buffer);
    const stdout = &stdout_writer.interface;

    try stdout.writeAll("Determining latest kcov version\n");
    try stdout.flush();

    var client = std.http.Client{ .allocator = allocator, .io = io };
    defer client.deinit();

    // Get redirect to find latest version
    const list_uri = try std.Uri.parse("https://git.lerch.org/lobo/-/packages/generic/kcov/");
    var req = try client.request(.GET, list_uri, .{ .redirect_behavior = .unhandled });
    defer req.deinit();

    try req.sendBodiless();
    var redirect_buf: [1024]u8 = undefined;
    const response = try req.receiveHead(&redirect_buf);

    if (response.head.status != .see_other) return error.UnexpectedResponse;

    const location = response.head.location orelse return error.NoLocation;
    const version_start = std.mem.lastIndexOfScalar(u8, location, '/') orelse return error.InvalidLocation;
    const version = location[version_start + 1 ..];

    try stdout.print(
        "Downloading kcov version {s} for {s} to {s}...",
        .{ version, arch_name, kcov_path },
    );
    try stdout.flush();

    const binary_url = try std.fmt.allocPrint(
        allocator,
        "https://git.lerch.org/api/packages/lobo/generic/kcov/{s}/kcov-{s}",
        .{ version, arch_name },
    );

    const cache_dir = std.fs.path.dirname(kcov_path) orelse return error.InvalidPath;
    std.Io.Dir.cwd().createDir(io, cache_dir, std.Io.File.Permissions.default_dir) catch |e| switch (e) {
        error.PathAlreadyExists => {},
        else => return e,
    };

    const uri = try std.Uri.parse(binary_url);
    const file = try std.Io.Dir.cwd().createFile(io, kcov_path, .{});
    defer file.close(io);
    file.setPermissions(io, @enumFromInt(0o755)) catch {};

    var buffer: [8192]u8 = undefined;
    var writer = file.writer(io, &buffer);
    const result = try client.fetch(.{
        .location = .{ .uri = uri },
        .response_writer = &writer.interface,
    });

    if (result.status != .ok) return error.DownloadFailed;
    try writer.interface.flush();

    try stdout.writeAll("done\n");
    try stdout.flush();
}