fediglam/src/main/api.zig

const std = @import("std");
const util = @import("util");
const builtin = @import("builtin");
const sql = @import("sql");

const DateTime = util.DateTime;
const Uuid = util.Uuid;
const Config = @import("./main.zig").Config;

const services = struct {
    const communities = @import("./api/communities.zig");
    const users = @import("./api/users.zig");
    const auth = @import("./api/auth.zig");
    const invites = @import("./api/invites.zig");
    const notes = @import("./api/notes.zig");
};

pub const RegistrationRequest = struct {
    username: []const u8,
    password: []const u8,
    invite_code: []const u8,
    email: ?[]const u8 = null,
};

pub const InviteRequest = struct {
    pub const Kind = services.invites.Kind;

    name: ?[]const u8 = null,
    lifespan: ?DateTime.Duration = null,
    max_uses: ?u16 = null,

    kind: Kind = .user, // must be user unless the creator is an admin
    to_community: ?[]const u8 = null, // only valid on admin community
};

pub const LoginResponse = services.auth.LoginResult;

pub const UserResponse = struct {
    id: Uuid,

    username: []const u8,
    host: []const u8,

    created_at: DateTime,
};

pub const NoteResponse = struct {
    id: Uuid,
    author: struct {
        id: Uuid,
        username: []const u8,
        host: []const u8,
    },

    content: []const u8,
    created_at: DateTime,
};

// Frees an api struct and its fields allocated from alloc
pub fn free(alloc: std.mem.Allocator, val: anytype) void {
    switch (@typeInfo(@TypeOf(val))) {
        .Pointer => |ptr_info| switch (ptr_info.size) {
            .One => {
                free(alloc, val.*);
                alloc.destroy(val);
            },
            .Slice => {
                for (val) |elem| free(alloc, elem);
                alloc.free(val);
            },
            else => unreachable,
        },
        .Struct => inline for (std.meta.fields(@TypeOf(val))) |f| free(alloc, @field(val, f.name)),
        .Array => for (val) |elem| free(alloc, elem),
        .Optional => if (val) |opt| free(alloc, opt),
        .Bool, .Int, .Float, .Enum => {},
        else => unreachable,
    }
}

threadlocal var prng: std.rand.DefaultPrng = undefined;

pub fn initThreadPrng(seed: u64) void {
    prng = std.rand.DefaultPrng.init(seed +% std.Thread.getCurrentId());
}

pub fn getRandom() std.rand.Random {
    return prng.random();
}

pub fn isAdminSetup(db: sql.Db) !bool {
    _ = services.communities.adminCommunityId(db) catch |err| switch (err) {
        error.NotFound => return false,
        else => return err,
    };

    return true;
}

pub fn setupAdmin(db: sql.Db, origin: []const u8, username: []const u8, password: []const u8, allocator: std.mem.Allocator) anyerror!void {
    const tx = try db.begin();
    errdefer tx.rollback();
    var arena = std.heap.ArenaAllocator.init(allocator);
    defer arena.deinit();

    try tx.setConstraintMode(.deferred);

    const community_id = try services.communities.create(
        tx,
        origin,
        .{ .name = "Cluster Admin", .kind = .admin },
        arena.allocator(),
    );

    const user = try services.auth.register(tx, username, password, community_id, .{ .kind = .admin }, arena.allocator());

    try services.communities.transferOwnership(tx, community_id, user);

    try tx.commit();

    std.log.info(
        "Created admin user {s} (id {}) with cluster admin origin {s} (id {})",
        .{ username, user, origin, community_id },
    );
}

pub const ApiSource = struct {
    db_conn: *sql.Conn,
    internal_alloc: std.mem.Allocator,
    config: Config,

    pub const Conn = ApiConn(sql.Db);

    const root_username = "root";

    pub fn init(alloc: std.mem.Allocator, cfg: Config, db_conn: *sql.Conn) !ApiSource {
        return ApiSource{
            .db_conn = db_conn,
            .internal_alloc = alloc,
            .config = cfg,
        };
    }

    pub fn connectUnauthorized(self: *ApiSource, host: []const u8, alloc: std.mem.Allocator) !Conn {
        var arena = std.heap.ArenaAllocator.init(alloc);
        errdefer arena.deinit();

        const db = try self.db_conn.acquire();
        const community = try services.communities.getByHost(db, host, arena.allocator());

        return Conn{
            .db = db,
            .internal_alloc = self.internal_alloc,
            .user_id = null,
            .community = community,
            .arena = arena,
        };
    }

    pub fn connectToken(self: *ApiSource, host: []const u8, token: []const u8, alloc: std.mem.Allocator) !Conn {
        var arena = std.heap.ArenaAllocator.init(alloc);
        errdefer arena.deinit();

        const db = try self.db_conn.acquire();
        const community = try services.communities.getByHost(db, host, arena.allocator());

        const token_info = try services.auth.verifyToken(
            db,
            token,
            community.id,
            arena.allocator(),
        );

        return Conn{
            .db = db,
            .internal_alloc = self.internal_alloc,
            .token_info = token_info,
            .user_id = token_info.account_id,
            .community = community,
            .arena = arena,
        };
    }
};

fn ApiConn(comptime DbConn: type) type {
    return struct {
        const Self = @This();

        db: DbConn,
        internal_alloc: std.mem.Allocator, // used *only* for large, internal buffers
        token_info: ?services.auth.TokenInfo = null,
        user_id: ?Uuid = null,
        community: services.communities.Community,
        arena: std.heap.ArenaAllocator,

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

        fn isAdmin(self: *Self) bool {
            // TODO
            return self.user_id != null and self.community.kind == .admin;
        }

        pub fn login(self: *Self, username: []const u8, password: []const u8) !LoginResponse {
            return services.auth.login(
                self.db,
                username,
                self.community.id,
                password,
                self.arena.allocator(),
            );
        }

        pub const AuthorizationInfo = struct {
            id: Uuid,
            username: []const u8,
            community_id: Uuid,
            host: []const u8,

            issued_at: DateTime,
        };
        pub fn verifyAuthorization(self: *Self) !AuthorizationInfo {
            if (self.token_info) |info| {
                const user = try services.users.get(self.db, info.account_id, self.arena.allocator());

                return AuthorizationInfo{
                    .id = user.id,
                    .username = user.username,
                    .community_id = self.community.id,
                    .host = self.community.host,

                    .issued_at = info.issued_at,
                };
            }

            return error.Unauthorized;
        }

        pub fn createCommunity(self: *Self, origin: []const u8) !services.communities.Community {
            if (!self.isAdmin()) {
                return error.PermissionDenied;
            }

            const tx = try self.db.begin();
            errdefer tx.rollback();
            const community_id = try services.communities.create(
                tx,
                origin,
                .{},
                self.arena.allocator(),
            );

            const community = services.communities.get(
                tx,
                community_id,
                self.arena.allocator(),
            ) catch |err| return switch (err) {
                error.NotFound => error.DatabaseError,
                else => |err2| err2,
            };

            try tx.commit();

            return community;
        }

        pub fn createInvite(self: *Self, options: InviteRequest) !services.invites.Invite {
            // Only logged in users can make invites
            const user_id = self.user_id orelse return error.TokenRequired;

            const community_id = if (options.to_community) |host| blk: {
                // You can only specify a different community if you're on the admin domain
                if (self.community.kind != .admin) return error.WrongCommunity;

                // Only admins can invite on the admin domain
                if (!self.isAdmin()) return error.PermissionDenied;

                break :blk (try services.communities.getByHost(self.db, host, self.arena.allocator())).id;
            } else self.community.id;

            // Users can only make user invites
            if (options.kind != .user and !self.isAdmin()) return error.PermissionDenied;

            const invite_id = try services.invites.create(self.db, user_id, community_id, .{
                .name = options.name,
                .lifespan = options.lifespan,
                .max_uses = options.max_uses,
                .kind = options.kind,
            }, self.arena.allocator());

            return try services.invites.get(self.db, invite_id, self.arena.allocator());
        }

        pub fn register(self: *Self, request: RegistrationRequest) !UserResponse {
            std.log.debug("registering user {s} with code {s}", .{ request.username, request.invite_code });
            const invite = try services.invites.getByCode(self.db, request.invite_code, self.arena.allocator());

            if (!Uuid.eql(invite.community_id, self.community.id)) return error.NotFound;
            if (invite.max_uses != null and invite.times_used >= invite.max_uses.?) return error.InviteExpired;
            if (invite.expires_at != null and DateTime.now().isAfter(invite.expires_at.?)) return error.InviteExpired;

            if (self.community.kind == .admin) @panic("Unimplmented");

            const user_id = try services.users.create(self.db, request.username, request.password, self.community.id, .{ .invite_id = invite.id, .email = request.email }, self.internal_alloc);

            switch (invite.invite_type) {
                .user => {},
                .system => @panic("System user invites unimplemented"),
                .community_owner => {
                    try services.communities.transferOwnership(self.db, self.community.id, user_id);
                },
            }

            return self.getUser(user_id) catch |err| switch (err) {
                error.NotFound => error.Unexpected,
                else => err,
            };
        }

        pub fn getUser(self: *Self, user_id: Uuid) !UserResponse {
            const user = try services.users.get(self.db, user_id, self.arena.allocator());

            if (self.user_id == null) {
                if (!Uuid.eql(self.community.id, user.community_id)) return error.NotFound;
            }

            return UserResponse{
                .id = user.id,
                .username = user.username,
                .host = user.host,
                .created_at = user.created_at,
            };
        }

        pub fn createNote(self: *Self, content: []const u8) !NoteResponse {
            if (self.community.kind == .admin) return error.WrongCommunity;
            const user_id = self.user_id orelse return error.TokenRequired;

            const note_id = try services.notes.create(self.db, user_id, content);

            return self.getNote(note_id) catch |err| switch (err) {
                error.NotFound => error.Unexpected,
                else => err,
            };
        }

        pub fn getNote(self: *Self, note_id: Uuid) !NoteResponse {
            const note = try services.notes.get(self.db, note_id, self.arena.allocator());
            const user = try services.users.get(self.db, note.author_id, self.arena.allocator());

            // Only serve community-specific notes on unauthenticated requests
            if (self.user_id == null) {
                if (!Uuid.eql(self.community.id, user.community_id)) return error.NotFound;
            }

            return NoteResponse{
                .id = note.id,
                .author = .{
                    .id = user.id,
                    .username = user.username,
                    .host = user.host,
                },
                .content = note.content,
                .created_at = note.created_at,
            };
        }

        pub fn queryCommunities(self: *Self, args: services.communities.QueryArgs) ![]services.communities.Community {
            if (!self.isAdmin()) return error.PermissionDenied;
            return services.communities.query(self.db, args, self.arena.allocator());
        }
    };
}