const std = @import("std");

const Self = @This();

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

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

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

pub fn serve(self: *Self, content: []const u8) !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 });

        if (std.mem.eql(u8, request.head.target, "/")) {
            request.respond(content, .{
                .status = .ok,
                .extra_headers = &.{
                    .{ .name = "Content-Type", .value = "text/html" },
                },
            }) catch continue;
        } else {
            request.respond("Not Found", .{ .status = .not_found }) catch continue;
        }
    }
}