const std = @import("std");
const zits = @import("zits");
const clap = @import("clap");

const Message = zits.MessageParser.Message;
const Server = zits.Server;

const SubCommands = enum {
    help,
    serve,
    @"pub",
};

const main_parsers = .{
    .command = clap.parsers.enumeration(SubCommands),
};

// The parameters for `main`. Parameters for the subcommands are specified further down.
const main_params = clap.parseParamsComptime(
    \\-h, --help  Display this help and exit.
    \\<command>
    \\
);

// To pass around arguments returned by clap, `clap.Result` and `clap.ResultEx` can be used to
// get the return type of `clap.parse` and `clap.parseEx`.
pub const MainArgs = clap.ResultEx(clap.Help, &main_params, main_parsers);

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

    var iter = try std.process.ArgIterator.initWithAllocator(gpa);
    defer iter.deinit();

    _ = iter.next();

    var diag = clap.Diagnostic{};
    var res = clap.parseEx(clap.Help, &main_params, main_parsers, &iter, .{
        .diagnostic = &diag,
        .allocator = gpa,

        // Terminate the parsing of arguments after parsing the first positional (0 is passed
        // here because parsed positionals are, like slices and arrays, indexed starting at 0).
        //
        // This will terminate the parsing after parsing the subcommand enum and leave `iter`
        // not fully consumed. It can then be reused to parse the arguments for subcommands.
        .terminating_positional = 0,
    }) catch |err| {
        try diag.reportToFile(.stderr(), err);
        return err;
    };
    defer res.deinit();
    std.debug.print("res: {any}\n", .{res});

    if (res.args.help != 0)
        return clap.helpToFile(.stderr(), clap.Help, &main_params, .{});

    const command = res.positionals[0] orelse return error.MissingCommand;
    switch (command) {
        .help => return clap.helpToFile(.stderr(), clap.Help, &main_params, .{}),
        .serve => try Server.main(gpa, &iter, res),
        .@"pub" => unreachable,
    }
}

// fn serverMain(gpa: std.mem.Allocator, iter: *std.process.ArgIterator, main_args: MainArgs) !void {
//     _ = iter;
//     _ = main_args;

//     var threaded: std.Io.Threaded = .init(gpa);
//     defer threaded.deinit();
//     const io = threaded.io();

//     const info: ServerInfo = .{
//         .server_id = "NBEK5DBBB4ZO5LTBGPXACZSB2QUTODC6GGN5NLOSPIGSRFWJID4XU52C",
//         .server_name = "bar",
//         .version = "2.11.8",
//         .go = "go1.24.6",
//         .headers = true,
//         .max_payload = 1048576,
//     };

//     var server = try std.Io.net.IpAddress.listen(
//         .{
//             .ip4 = .{
//                 .bytes = .{ 0, 0, 0, 0 },
//                 .port = info.port,
//             },
//         },
//         io,
//         .{},
//     );
//     defer server.deinit(io);

//     var group: std.Io.Group = .init;
//     defer group.wait(io);
//     for (0..5) |_| {
//         const stream = try server.accept(io);
//         group.async(io, handleConnection, .{ gpa, io, stream, info });
//     }
// }