const std = @import("std");
const fs = std.fs;
const io = std.io;
const mem = std.mem;
const os = std.os;
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const GeneralPurposeAllocator = std.heap.GeneralPurposeAllocator;

const flags = @import("../flags.zig");
const User = @import("../User.zig");
const Group = @import("../Group.zig");

const usage =
    \\usage: turbonss-unix2db [options]
    \\
    \\  -h          Print this help message and exit
    \\  --passwd    Path to passwd file (default: ./passwd)
    \\  --group     Path to group file (default: ./group)
    \\
;

pub fn main() !void {
    // This line is here because of https://github.com/ziglang/zig/issues/7807
    const argv: []const [*:0]const u8 = os.argv;
    const gpa = GeneralPurposeAllocator(.{});

    const return_code = execute(gpa, argv[1..]) catch |err| {
        try io.getStdErr().writeAll("uncaught error: {s}\n", @intToError(err));
        os.exit(1);
    };

    os.exit(return_code);
}

fn execute(
    allocator: Allocator,
    stderr: anytype,
    argv: []const [*:0]const u8,
) !u8 {
    const result = flags.parse(argv, &[_]flags.Flag{
        .{ .name = "-h", .kind = .boolean },
        .{ .name = "--passwd", .kind = .arg },
        .{ .name = "--group", .kind = .arg },
    }) catch {
        try stderr.writeAll(usage);
        return 1;
    };

    if (result.boolFlag("-h")) {
        try io.getStdOut().writeAll(usage);
        return 0;
    }

    if (result.args.len != 0) {
        try stderr.print("ERROR: unknown option '{s}'\n", .{result.args[0]});
        try stderr.writeAll(usage);
        return 1;
    }

    const passwd = result.argFlag("--passwd") orelse "./passwd";
    const group = result.argFlag("--group") orelse "./group";

    var passwdFile = try fs.cwd().openFile(passwd, .{ .mode = .read_only });
    defer passwdFile.close();
    var groupFile = try fs.cwd().openFile(group, .{ .mode = .read_only });
    defer groupFile.close();

    var users = try User.fromReader(allocator, passwdFile.reader());
    var groups = try Group.fromReader(allocator, groupFile.reader());

    try stderr.print("read {d} users\n", .{users.len});
    try stderr.print("read {d} groups\n", .{groups.len});
    return 0;
}

const testing = std.testing;

test "invalid argument" {
    const allocator = testing.allocator;
    const args = &[_][*:0]const u8{"--invalid-argument"};
    var stderr = ArrayList(u8).init(allocator);
    defer stderr.deinit();

    const exit_code = try execute(allocator, stderr.writer(), args[0..]);
    try testing.expectEqual(@as(u8, 1), exit_code);
    try testing.expect(mem.startsWith(u8, stderr.items, "ERROR: unknown "));
}