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

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

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

    var app = yazap.App.init(gpa, "zits", "High performance NATS compatible client and server.");
    defer app.deinit();

    var zits_app = app.rootCommand();

    var server_cmd = app.createCommand("serve", "Run a high performance NATS compatible server.");
    try server_cmd.addArgs(&[_]yazap.Arg{
        yazap.Arg.singleValueOption(
            "addr",
            'a',
            std.fmt.comptimePrint(
                "Address to bind to (default: {s})",
                .{std.meta.fieldInfo(zits.Server.ServerInfo, .host).defaultValue().?},
            ),
        ),
        yazap.Arg.singleValueOption(
            "port",
            'p',
            std.fmt.comptimePrint(
                "Port to listen on (default: {d})",
                .{std.meta.fieldInfo(zits.Server.ServerInfo, .port).defaultValue().?},
            ),
        ),
        yazap.Arg.singleValueOption(
            "name",
            'n',
            "Server name (default: auto)",
        ),
    });
    try zits_app.addSubcommand(server_cmd);

    const pub_cmd = app.createCommand("pub", "Publish a message.");
    try zits_app.addSubcommand(pub_cmd);

    const matches = try app.parseProcess();

    if (matches.subcommandMatches("serve")) |serve_matches| {
        var info: zits.Server.ServerInfo = .{
            .server_id = zits.Server.createId(),
            .server_name = zits.Server.createName(),
            .version = "zits-master",
            .max_payload = 99999,
        };
        if (serve_matches.getSingleValue("port")) |port| {
            info.port = std.fmt.parseUnsigned(@TypeOf(info.port), port, 10) catch |err| std.process.fatal("Could not parse port ({s}): {}\n", .{ port, err });
        }

        if (serve_matches.getSingleValue("name")) |name| {
            info.server_name = name;
        }

        try Server.main(gpa, info);
        return;
    }
}

// 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 });
//     }
// }