const std = @import("std");
const Io = std.Io;

const miniz = @import("miniz");

pub fn main(init: std.process.Init) !void {
    const io = init.io;
    const arena = init.arena.allocator();
    const args = try init.minimal.args.toSlice(arena);

    if (args.len != 3) {
        std.debug.print("Usage: ./create-zip <input> <output>", .{});
        std.process.exit(1);
    }

    const input_path = args[1];
    const output_zip_path = args[2];
    const cwd = Io.Dir.cwd();

    var archive: miniz.Archive = undefined;
    try archive.initFile(output_zip_path);
    defer archive.end();

    const input_stat = try cwd.statFile(io, input_path, .{});
    if (input_stat.kind == .file) {
        try addFileToArchive(&archive, io, cwd, input_path);

    } else if (input_stat.kind == .directory) {
        var input_dir = try cwd.openDir(io, input_path, .{ .iterate = true });
        defer input_dir.close(io);

        var input_dir_iter = input_dir.iterate();
        while (try input_dir_iter.next(io)) |entry| {
            if (entry.kind == .file) {
                try addFileToArchive(&archive, io, input_dir, entry.name);
            }
        }
    } else {
        std.debug.print("Invalid input\n", .{});
        std.process.exit(1);
    }

    try archive.finalize();
}

fn addFileToArchive(archive: *miniz.Archive, io: Io, dir: Io.Dir, sub_path: []const u8) !void {
    var path_buff: [std.fs.max_path_bytes+1]u8 = undefined;
    const path_len = try dir.realPathFile(io, sub_path, path_buff[0..(path_buff.len-1)]);
    path_buff[path_len] = 0;

    const name = std.fs.path.basename(sub_path);
    var namez_buff: [std.fs.max_name_bytes+1]u8 = undefined;
    @memcpy(namez_buff[0..name.len], name);
    namez_buff[name.len] = 0;
    try archive.addFile(namez_buff[0..name.len :0], path_buff[0..path_len :0]);
}