const std = @import("std");
const Game = @import("game");
const Engine = @import("engine");
const Lib = Engine.Lib;
const AssetBundle = Engine.AssetBundle;

fn readFileAll(gpa: std.mem.Allocator, dir: std.fs.Dir, sub_path: []const u8) ![]u8 {
    const f = try dir.openFile(sub_path, .{});
    defer f.close();

    var wa: std.Io.Writer.Allocating = .init(gpa);
    defer wa.deinit();

    var buffer: [4 * 4096]u8 = undefined;
    var reader = f.reader(&buffer);
    _ = try reader.interface.stream(&wa.writer, .unlimited);

    return try wa.toOwnedSlice();
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    defer _ = gpa.deinit();

    const args = try std.process.argsAlloc(allocator);
    defer std.process.argsFree(allocator, args);

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

    const cwd = std.fs.cwd();
    const asset_dir_path = args[1];
    const output_path = args[2];

    const asset_dir = try cwd.openDir(asset_dir_path, .{ .iterate = true });

    var loader: Lib.Asset.Loader = .init(allocator, asset_dir);
    defer loader.deinit();
    Game.loadAssets(&loader);

    var bundle = AssetBundle.init();
    defer bundle.deinit(allocator);

    for (loader.assets.items) |asset_desc| {
        const id = asset_desc.id;
        switch (asset_desc.kind) {
            .font => |path| {
                const font_data = try readFileAll(allocator, asset_dir, path);
                defer allocator.free(font_data);

                // TODO:
                try bundle.appendFont(allocator, id, font_data, .{ .format = .ttf });
            },
            .sound => |path| {
                const sound_data = try readFileAll(allocator, asset_dir, path);
                defer allocator.free(sound_data);

                try bundle.appendSound(allocator, id, sound_data, .{
                    // TODO:
                    .format = .vorbis,
                    .playback_style = .decode_once
                });
            },
            .texture => |opts| {
                const texture_data = try readFileAll(allocator, asset_dir, opts.path);
                defer allocator.free(texture_data);

                try bundle.appendTexture(allocator, id, texture_data, opts.info);
            }
        }
    }

    const output_file = try std.fs.cwd().createFile(output_path, .{  });
    defer output_file.close();

    var buffer: [4096 * 4]u8 = undefined;
    var writer = output_file.writer(&buffer);

    try bundle.write(&writer.interface);
    try writer.interface.flush();
}