const std = @import("std");

pub const fallback = @import("fallback.zig");
pub const login = @import("login.zig");

pub const HandlerInfo = struct {
    handler: *const fn (
                 request: *std.http.Server.Request,
                 allocator: std.mem.Allocator,
             ) anyerror!void,
    needs_auth: bool,
    method: std.http.Method,

    pub fn handle(
        self: *const @This(),
        request: *std.http.Server.Request,
        allocator: std.mem.Allocator,
    ) !void {
        if (request.head.method != self.method) {
            try request.respond("{ \"error\": \"Bad Request\" }", .{ .status = .bad_request });
        }

        self.handler(request, allocator) catch |err| {
            const response, const status_code: std.http.Status = switch (err) {
                error.BadRequest => .{ "{ \"error\": \"Bad Request\" }", .bad_request },
                error.Unauthorized => .{ "{ \"error\": \"Unauthorized\" }", .unauthorized },
                error.Forbidden => .{ "{ \"error\": \"Forbidden\" }", .forbidden },
                error.NotFound => .{ "{ \"error\": \"Not Found\" }", .not_found },
                else => .{ "{ \"error\": \"Internal Server Error\" }", .internal_server_error },
            };

            try request.respond(response, .{ .status = status_code });
        };
    }
};

pub const handlers = std.StaticStringMap(HandlerInfo).initComptime(.{
    .{
        "",
        HandlerInfo {
            .handler = fallback.handler,
            .needs_auth = false,
            .method = .GET,
        }
    },
    .{
        "/api/login",
        HandlerInfo {
            .handler = login.handler,
            .needs_auth = false,
            .method = .POST,
        }
    },
});

pub fn get(path: []const u8) HandlerInfo {
    return (handlers.getLongestPrefix(std.mem.trimEnd(u8, path, "/")) orelse unreachable).value;
}