fediglam/src/main/api/communities.zig

const std = @import("std");
const builtin = @import("builtin");
const util = @import("util");
const models = @import("../db/models.zig");

const DbError = @import("../db.zig").ExecError;

const getRandom = @import("../api.zig").getRandom;

const Uuid = util.Uuid;

const CreateError = error{
    InvalidOrigin,
    UnsupportedScheme,
    CommunityExists,
} || DbError;

pub const Scheme = enum {
    https,
    http,

    pub fn jsonStringify(s: Scheme, _: std.json.StringifyOptions, writer: anytype) !void {
        return std.fmt.format(writer, "\"{s}\"", .{@tagName(s)});
    }
};

pub const Community = struct {
    id: Uuid,

    owner_id: ?Uuid,
    host: []const u8,
    name: []const u8,

    scheme: Scheme,
};

pub fn create(db: anytype, origin: []const u8, name: ?[]const u8) CreateError!Community {
    const scheme_len = firstIndexOf(origin, ':') orelse return error.InvalidOrigin;
    const scheme_str = origin[0..scheme_len];
    const scheme = std.meta.stringToEnum(Scheme, scheme_str) orelse return error.UnsupportedScheme;

    // host must be in the format "{scheme}://{host}"
    if (origin.len <= scheme_len + ("://").len or
        origin[scheme_len] != ':' or
        origin[scheme_len + 1] != '/' or
        origin[scheme_len + 2] != '/') return error.InvalidOrigin;

    const host = origin[scheme_len + 3 ..];

    // community cannot use non-default ports (except for testing)
    // NOTE: Do not add, say localhost and localhost:80 or bugs may happen.
    // Avoid using non-default ports unless a test can't be conducted without it.
    if (firstIndexOf(host, ':') != null and builtin.mode != .Debug) return error.InvalidOrigin;

    // community cannot be hosted on a path
    if (firstIndexOf(host, '/') != null) return error.InvalidOrigin;

    // Require TLS on production builds
    if (scheme != .https and builtin.mode != .Debug) return error.UnsupportedScheme;

    const id = Uuid.randV4(getRandom());

    const community = Community{
        .id = id,
        .owner_id = null,
        .host = host,
        .name = name orelse host,
        .scheme = scheme,
    };

    if ((try db.execRow(&.{Uuid}, "SELECT id FROM community WHERE host = ?", .{host}, null)) != null) {
        return error.CommunityExists;
    }

    try db.insert("community", community);

    return community;
}

fn firstIndexOf(str: []const u8, ch: u8) ?usize {
    for (str) |c, i| {
        if (c == ch) return i;
    }

    return null;
}

pub fn getByHost(db: anytype, host: []const u8, alloc: std.mem.Allocator) !Community {
    const result = (try db.execRow(&.{ Uuid, ?Uuid, []const u8, []const u8, Scheme }, "SELECT id, owner_id, host, name, scheme FROM community WHERE host = ?", .{host}, alloc)) orelse return error.NotFound;

    return Community{
        .id = result[0],
        .owner_id = result[1],
        .host = result[2],
        .name = result[3],
        .scheme = result[4],
    };
}

pub fn transferOwnership(db: anytype, community_id: Uuid, new_owner: Uuid) !void {
    _ = try db.execRow(&.{i64}, "UPDATE community SET owner_id = ? WHERE id = ?", .{ new_owner, community_id }, null);
}