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, alloc: std.mem.Allocator) !void {
        var headers = http.Headers.init(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 parseRequestBody(comptime T: type, ctx: *http.server.Context, alloc: std.mem.Allocator) !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 = 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, srv.alloc);
        // TODO: defer api.free(srv.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, srv.alloc);
    defer utils.freeRequestBody(info, srv.alloc);

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

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

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

    const user = srv.api.createUser(info) catch |err| switch (err) {
        error.HandleNotAvailable => return try utils.respondJson(ctx, .bad_request, .{ .@"error" = "handle not available" }, srv.alloc),
        else => return err,
    };

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

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.respondJson(ctx, .bad_request, .{ .@"error" = "Invalid UUID" }, srv.alloc);
    const note = (try srv.api.getNote(id, srv.alloc)) orelse return utils.respondJson(ctx, .not_found, .{ .@"error" = "Note not found" }, srv.alloc);
    defer api.free(srv.alloc, note);

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

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.respondJson(ctx, .bad_request, .{ .@"error" = "Invalid UUID" }, srv.alloc);
    const user = (try srv.api.getUser(id, srv.alloc)) orelse return utils.respondJson(ctx, .not_found, .{ .@"error" = "Note not found" }, srv.alloc);
    defer api.free(srv.alloc, user);

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

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.respondJson(ctx, .bad_request, .{ .@"error" = "Invalid UUID" }, srv.alloc);

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

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.respondJson(ctx, .bad_request, .{ .@"error" = "Invalid UUID" }, srv.alloc);

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

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

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

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

pub fn notFound(srv: *RequestServer, ctx: *http.server.Context) void {
    utils.respondJson(ctx, .not_found, .{ .@"error" = "Not Found" }, srv.alloc) catch unreachable;
}