const std = @import("std");

const util = @import("util.zig");

const InitError = error {
    NotEnoughArgs,
    InvalidDimension,
    InvalidQuality,
    InvalidNumJobs,
};

inline fn next_arg(args: *std.process.ArgIterator) ![:0]const u8 {
    return args.next() orelse InitError.NotEnoughArgs;
}

inline fn get_dim(arg: [:0]const u8) !usize {
    const d = try std.fmt.parseInt(usize, arg, 10);
    if (d % 16 != 0 or d == 0) {
        return InitError.InvalidDimension;
    }
    return d;
}

inline fn get_qual(arg: [:0]const u8) !f16 {
    const q = try std.fmt.parseFloat(f16, arg);
    if (q < 0 or q > 1) {
        return InitError.InvalidQuality;
    }
    return q;
}

inline fn get_n_jobs(arg: [:0]const u8) !usize {
    const n = try std.fmt.parseInt(usize, arg, 10);
    if (n == 0) {
        return InitError.InvalidNumJobs;
    }
    return n;
}

fn get_opts(alloc: std.mem.Allocator) !util.Options {
    var args = try std.process.argsWithAllocator(alloc);
    defer args.deinit();
    _ = args.next();

    return util.Options {
        .width = try get_dim(try next_arg(&args)),
        .height = try get_dim(try next_arg(&args)),
        .quality = try get_qual(try next_arg(&args)),
        .n_quant_jobs = try get_n_jobs(try next_arg(&args)),
    };
}

pub fn main() !void {
    var arg_buff: [100]u8 = undefined;
    var arg_fba = std.heap.FixedBufferAllocator.init(&arg_buff);
    const alloc = arg_fba.allocator();

    const opts = try get_opts(alloc);
    std.debug.print("{any}\n", .{opts});
}