const std = @import("std");
const mem = std.mem;
const net = std.net;
const http = std.http;
const heap = std.heap;

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

    const router = BasicRouter.init(allocator);
    defer router.deinit();

    const address = try net.Address.parseIp("0.0.0.0", 8080);
    var listener = Listener.init(address, allocator, &handle);
    defer listener.deinit();
    try listener.listen();
}

pub fn handle(event: *Listener.Event) anyerror!void {
    try event.res.body.appendSlice("hello there");
}

pub const Listener = struct {
    address: net.Address,
    arena: heap.ArenaAllocator,
    handlerFn: *const fn (event: *Event) anyerror!void,

    pub fn init(address: net.Address, allocator: mem.Allocator, handler: *const fn (event: *Event) anyerror!void) Listener {
        return .{
            .address = address,
            .arena = heap.ArenaAllocator.init(allocator),
            .handlerFn = handler,
        };
    }

    pub fn deinit(self: *Listener) void {
        self.arena.deinit();
    }

    pub fn listen(self: *Listener) !void {
        var tcp = try self.address.listen(.{});
        defer tcp.deinit();
        std.debug.print("listening at: {any}\n", .{self.address});

        while (true) {
            const read_buf = try self.arena.allocator().alloc(u8, 1024 * 32);
            const connection = try tcp.accept();
            var server = http.Server.init(connection, read_buf);
            try self.handle(&server);
            _ = self.arena.reset(.retain_capacity);
        }
    }

    fn handle(self: *Listener, server: *http.Server) !void {
        handler: while (true) {
            var req = server.receiveHead() catch |e| if (e == error.HttpConnectionClosing) break :handler else return e;

            var event = Event{
                .req = .{
                    .uri = try std.Uri.parseWithoutScheme(req.head.target),
                    .headers = std.ArrayList(*const http.Header).init(self.arena.allocator()),
                },
                .res = .{
                    .status = .ok,
                    .headers = std.StringHashMap(*http.Header).init(self.arena.allocator()),
                    .body = std.ArrayList(u8).init(self.arena.allocator()),
                },
            };

            var header_it = req.iterateHeaders();
            while (header_it.next()) |header| try event.req.headers.append(&header);

            try self.handlerFn(&event);

            try self.respondFromEvent(&event, &req);
        }
    }

    fn respondFromEvent(self: *Listener, event: *Event, req: *http.Server.Request) !void {
        const res_body = try event.res.body.toOwnedSlice();
        const res_headers = try self.arena.allocator().alloc(http.Header, event.res.headers.count());
        var i: usize = 0;
        var header_it = event.res.headers.iterator();
        while (header_it.next()) |header_ptr| : (i += 1) res_headers[i] = header_ptr.value_ptr.*.*;
        try req.respond(res_body, .{
            .status = event.res.status,
            .extra_headers = res_headers,
        });
    }

    pub const Event = struct {
        req: Request,
        res: Response,

        pub const Request = struct {
            uri: std.Uri,
            // head: http.Server.Request.Head,
            headers: std.ArrayList(*const http.Header),
        };
        pub const Response = struct {
            status: http.Status,
            headers: std.StringHashMap(*http.Header),
            body: std.ArrayList(u8),
        };
    };
};

pub const BasicRouter = Router(Listener.Event);

pub fn Router(comptime Context: type) type {
    return struct {
        ctx: Context,
        allocator: mem.Allocator,

        static_routes: std.StringHashMap(*Node),

        pub fn init(allocator: mem.Allocator, ctx: Context) Self {
            return .{
                .ctx = ctx,
                .allocator = allocator,
                .static_routes = std.StringHashMap(*Node).init(allocator),
            };
        }

        pub fn deinit(self: *Self) void {
            self.static_routes.deinit();
        }

        pub fn addRoute(self: *Self, path: []const u8, handler: HandlerFn) !void {
            try self.addStaticRoute(path, handler);
        }

        fn addStaticRoute(self: *Self, path: []const u8, handler: HandlerFn) !void {
            try self.static_routes.put(path, .{
                .type = .normal,
                .max_depth = 1,
                .children = std.StringHashMap(*Node).init(self.allocator),
                .handler = handler,
                .placeholder_children = std.ArrayList(*Node).init(self.allocator),
            });
        }

        pub const Node = struct {
            type: Type,
            max_depth: usize, // TODO: what is best here
            parent: ?*Node = null,
            children: std.StringHashMap(*Node),
            handler: HandlerFn,
            wildcard_child_node: ?*Node = null,
            placeholder_children: std.ArrayList(*Node),

            pub const Type = enum { normal, wildcard, placeholder };
        };

        pub const HandlerFn = *const fn (ctx: *Context) anyerror!void;

        const Self = @This();
    };
}