const std = @import("std");
const argsWithAllocator = std.process.argsWithAllocator;
const eql = std.mem.eql;
const expect = std.testing.expect;
const parseInt = std.fmt.parseInt;
const print = std.debug.print;
const GeneralPurposeAllocator = std.heap.GeneralPurposeAllocator;

/// There are 4 args: help, version, copyright, and quiet
/// ArgType also contains longarg, which is how zeven checks if the arg
/// will be --
const ArgType = enum {
    help,
    version,
    copyright,
    quiet,
    longarg,
    badarg,
};

const VERSION = "1.0.0";
const LICENSE = "MIT";

test "@rem(-2, 2) == 0" {
    try expect(@rem(-2, 2) == 0);
}

test "parseInt(i32, \"-2\", 10) == -2" {
    var test_int = try parseInt(i32, "-2", 10);

    try expect(test_int == -2);
}

test "parseInt(i32, \"\", 10) != 0" {
    var test_int = try parseInt(i32, "-2", 10);
    try expect(test_int != 0);
}

pub fn main() anyerror!u8 {
    // This is an iterator for the provided args
    var gpa = GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    defer _ = gpa.deinit();
    var arg_it = try argsWithAllocator(allocator);
    defer arg_it.deinit();
    var f_arg: ?ArgType = null;
    var f_int: i32 = undefined;
    // This is whether or not to print the results
    var quiet: bool = false;
    // This is to check if a value has been provided
    var value: bool = false;
    // This skips the name of the binary
    _ = arg_it.next();
    while (arg_it.next()) |arg| {
        f_arg = null;
        if (arg[0] == '-') { // It's an arg!
            f_arg = switch (arg[1]) {
                'h' => ArgType.help,
                'v' => ArgType.version,
                'c' => ArgType.copyright,
                'q' => ArgType.quiet,
                '-' => ArgType.longarg,
                '0'...'9' => null,
                else => ArgType.badarg,
            };
        }
        if (f_arg) |usearg| {
            var realarg = usearg;
            if (usearg == ArgType.longarg) {
                if (eql(u8, arg, "--help")) {
                    realarg = ArgType.help;
                } else if (eql(u8, arg, "--copyright")) {
                    realarg = ArgType.copyright;
                } else if (eql(u8, arg, "--version")) {
                    realarg = ArgType.version;
                } else if (eql(u8, arg, "--quiet")) {
                    realarg = ArgType.quiet;
                } else {
                    realarg = ArgType.badarg;
                }
            }
            _ = switch (realarg) {
                ArgType.quiet => {
                    quiet = true;
                    continue;
                },
                ArgType.help => {
                    return print_arg(0);
                },
                ArgType.copyright => {
                    return print_arg(1);
                },
                ArgType.version => {
                    return print_arg(2);
                },
                else => {
                    return print_arg(255);
                },
            };
        } else { // Not an arg!
            value = true;
            f_int = parseInt(i32, arg, 10) catch |err| return err;
        }
    }
    if (value) {
        if (@rem(f_int, 2) == 0) {
            if (!quiet) {
                print("even\n", .{});
            }
            return 0;
        } else {
            if (!quiet) {
                print("odd\n", .{});
            }
            return 1;
        }
    } else {
        print("No value was provided!\n", .{});
    }
    return 1;
}

pub fn print_arg(err: u8) !u8 {
    return switch (err) {
        0 => {
            print("zeven: a simple binary to check if a number ", .{});
            print("is even or odd\n", .{});
            print("\tzeven [-cvh]\n", .{});
            print("\tzeven [--help]\n", .{});
            print("\tzeven [--copyright]\n", .{});
            print("\tzeven [--version]\n", .{});
            print("\tzeven [-q] [--quiet] X\n", .{});
            return 0;
        },
        1 => {
            print("zeven is Free software under the {s} license.\n", .{LICENSE});
            print("zeven copyright (c) Zachary Smith 2024\n", .{});
            return 0;
        },
        2 => {
            print("zeven version {s}\n", .{VERSION});
            return 0;
        },
        else => {
            print("Error!\n", .{});
            return 1;
        },
    };
}