fediglam/src/main/controllers.zig

const std = @import("std");
const root = @import("root");
const builtin = @import("builtin");
const http = @import("http");
const api = @import("./api.zig");
const models = @import("./models.zig");
const Uuid = @import("util").Uuid;

const utils = struct {
    const json_options = if (builtin.mode == .Debug) .{
        .whitespace = .{
            .indent = .{ .Space = 2 },
            .separator = true,
        },
    } else .{
        .whitespace = .{
            .indent = .None,
            .separator = false,
        },
    };

    // Responds to a request with a json value
    fn respondJson(ctx: *http.server.Context, status: http.Status, value: anytype) !void {
        var headers = http.Headers.init(ctx.alloc);
        defer headers.deinit();

        // Don't need to free this k/v pair because they aren't dynamically allocated
        try headers.put("Content-Type", "application/json");

        var stream = try ctx.openResponse(&headers, status);
        defer stream.close();

        const writer = stream.writer();
        try std.json.stringify(value, json_options, writer);

        try stream.finish();
    }

    fn respondError(ctx: *http.server.Context, status: http.Status, err: []const u8) !void {
        return respondJson(ctx, status, .{ .@"error" = err });
    }

    fn parseRequestBody(comptime T: type, ctx: *http.server.Context) !T {
        const body = ctx.request.body orelse return error.BodyRequired;
        var tokens = std.json.TokenStream.init(body);
        const parsed = try std.json.parse(T, &tokens, .{ .allocator = ctx.alloc });

        return parsed;
    }

    fn freeRequestBody(value: anytype, alloc: std.mem.Allocator) void {
        std.json.parseFree(@TypeOf(value), value, .{ .allocator = alloc });
    }

    fn getApiContext(srv: *RequestServer, ctx: *http.server.Context) !api.ApiContext {
        const header = ctx.request.headers.get("authorization") orelse "(null)";

        const token = header[("bearer ").len..];

        return try srv.api.makeApiContext(token, ctx.alloc);
        // TODO: defer api.free(ctx.alloc, user_ctx);
    }
};

const RequestServer = root.RequestServer;
const RouteArgs = http.RouteArgs;

pub fn createNote(srv: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void {
    const user_context = try utils.getApiContext(srv, ctx);
    // TODO: defer free ApiContext
    const info = try utils.parseRequestBody(api.NoteCreate, ctx);
    defer utils.freeRequestBody(info, ctx.alloc);

    const note = try srv.api.createNoteUser(info, user_context);

    try utils.respondJson(ctx, .created, note);
}

pub fn register(srv: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void {
    const info = try utils.parseRequestBody(api.RegistrationInfo, ctx);
    defer utils.freeRequestBody(info, ctx.alloc);

    const user = srv.api.register(info) catch |err| switch (err) {
        error.UsernameUnavailable => return try utils.respondError(ctx, .bad_request, "Username Unavailable"),
        else => return err,
    };

    try utils.respondJson(ctx, .created, user);
}

pub fn getNote(srv: *RequestServer, ctx: *http.server.Context, args: RouteArgs) !void {
    const id_str = args.get("id") orelse return error.NotFound;
    const id = Uuid.parse(id_str) catch return utils.respondError(ctx, .bad_request, "Invalid UUID");
    const note = (try srv.api.getNote(id, ctx.alloc)) orelse return utils.respondError(ctx, .not_found, "Note not found");
    defer api.free(ctx.alloc, note);

    try utils.respondJson(ctx, .ok, note);
}

pub fn getUser(srv: *RequestServer, ctx: *http.server.Context, args: RouteArgs) !void {
    const id_str = args.get("id") orelse return error.NotFound;
    const id = Uuid.parse(id_str) catch return utils.respondError(ctx, .bad_request, "Invalid UUID");
    const user = (try srv.api.getActor(id, ctx.alloc)) orelse return utils.respondError(ctx, .not_found, "Note not found");
    defer api.free(ctx.alloc, user);

    try utils.respondJson(ctx, .ok, user);
}

pub fn react(srv: *RequestServer, ctx: *http.server.Context, args: RouteArgs) !void {
    const user_context = try utils.getApiContext(srv, ctx);
    // TODO: defer free ApiContext

    const note_id = args.get("id") orelse return error.NotFound;
    const id = Uuid.parse(note_id) catch return utils.respondError(ctx, .bad_request, "Invalid UUID");

    try srv.api.react(id, user_context);
    try utils.respondJson(ctx, .created, .{});
}

pub fn listReacts(srv: *RequestServer, ctx: *http.server.Context, args: RouteArgs) !void {
    const user_context = try utils.getApiContext(srv, ctx);
    // TODO: defer free ApiContext

    const note_id = args.get("id") orelse return error.NotFound;
    const id = Uuid.parse(note_id) catch return utils.respondError(ctx, .bad_request, "Invalid UUID");

    const reacts = try srv.api.listReacts(id, user_context);
    try utils.respondJson(ctx, .ok, .{ .items = reacts });
}

pub fn authenticate(srv: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void {
    const user_ctx = try utils.getApiContext(srv, ctx);
    // TODO: defer api.free(ctx.alloc, user_ctx);

    try utils.respondJson(ctx, .ok, user_ctx.user_context);
}

pub fn login(srv: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void {
    const credentials = try utils.parseRequestBody(struct { username: []const u8, password: []const u8 }, ctx);
    defer utils.freeRequestBody(credentials, ctx.alloc);

    const actor = srv.api.login(credentials.username, credentials.password, ctx.alloc) catch |err| switch (err) {
        error.PasswordVerificationFailed => return utils.respondError(ctx, .bad_request, "Invalid Login"),
        else => return err,
    };
    defer api.free(ctx.alloc, actor);

    try utils.respondJson(ctx, .ok, actor);
}

pub fn healthcheck(_: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void {
    try utils.respondJson(ctx, .ok, .{ .status = "ok" });
}

pub fn notFound(_: *RequestServer, ctx: *http.server.Context) void {
    utils.respondError(ctx, .not_found, "Not Found") catch unreachable;
}