const std = @import("std");

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

pub const Options = struct {
    address: std.Io.net.IpAddress,
    headers: []const std.http.Header = &.{},
};

pub fn serve(
    gpa: std.mem.Allocator,
    comptime routes: RouteSet,
    options: Options,
) !void {
    var threaded: std.Io.Threaded = .init(gpa, .{});
    var group: std.Io.Group = .init;
    const io = threaded.io();
    var server = try options.address.listen(io, .{ .reuse_address = true });

    const send_options: Response.SendOptions = .{
        .headers = options.headers,
    };

    while (true) {
        const stream = try server.accept(io);
        group.async(io, handle, .{ io, gpa, stream, &routes, send_options });
    }
}

pub fn handle(
    io: std.Io,
    gpa: std.mem.Allocator,
    stream: std.Io.net.Stream,
    routes: *const RouteSet,
    send_options: Response.SendOptions,
) void {
    var read_buffer: [1024 * 8]u8 = undefined;
    var write_buffer: [1024 * 8]u8 = undefined;

    defer stream.close(io);

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

    var reader = stream.reader(io, &read_buffer);
    var writer = stream.writer(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});
        return;
    };

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

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