const std = @import("std");

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

const Self = @This();

server: std.Io.net.Server,
threaded: std.Io.Threaded,
routes: RouteSet,

pub fn init(
    gpa: std.mem.Allocator,
    address: std.Io.net.IpAddress,
    comptime routes: RouteSet,
) !Self {
    var threaded: std.Io.Threaded = .init(gpa, .{});

    return .{
        .threaded = threaded,
        .server = try address.listen(threaded.io(), .{ .reuse_address = true }),
        .routes = routes,
    };
}

pub fn serve(self: *Self, gpa: std.mem.Allocator) !void {
    var read_buffer: [1024 * 8]u8 = undefined;
    var write_buffer: [1024 * 8]u8 = undefined;

    while (true) {
        const stream = try self.server.accept(self.threaded.io());
        defer stream.close(self.threaded.io());

        var reader = stream.reader(self.threaded.io(), &read_buffer);
        var writer = stream.writer(self.threaded.io(), &write_buffer);

        var server: std.http.Server = .init(&reader.interface, &writer.interface);
        var request = server.receiveHead() catch |e| {
            std.debug.print("error: {}\n", .{e});
            continue;
        };

        std.debug.print("{s} {s}\n", .{ @tagName(request.head.method), request.head.target });

        var arena: std.heap.ArenaAllocator = .init(gpa);
        defer arena.deinit();

        if (self.routes.getInterface(request.head.target)) |interface| {
            const message = interface.handle(gpa, arena.allocator(), self.threaded.io(), &request);
            message.send(self.threaded.io(), &request) catch continue;
        } else {
            request.respond("", .{ .status = .not_found }) catch continue;
        }
    }
}