//server/auth/role-db.ts
import { Role } from "@/auth/roles/role.resource";
import { db } from "@server/db/db";
import { dbIsAny } from "@server/fd/fd-toolbox/db/db";
import { resourceNames } from "@/fd/fd-toolbox/resources/resource-names";
import { eq } from "drizzle-orm";
import { createResource, getResourceById, updateResource } from "@server/fd/fd-toolbox/db/type-db";
import { tableNames } from "@server/db/table-names";
import { getQuery } from "@server/web/drizzle";
import { UserRole } from "@/users/user-role.resource";
import { User } from "@/users/user.resource";
import { parseJson } from "@/lib/utils";
import { roleSchema, userRoleSchema, userSchema } from "@packages/plugin/schema";
import { apiNotFoundError } from "@server/web/errors";
import { errorMessages } from "@/meta/constants/error-messages";

type TableNames = typeof tableNames;

type RowType = Record<TableNames[keyof TableNames], Record<string, unknown> | null>;

export async function getAllIncludingUserToRoles() {
    const query = getQuery(roleSchema)
        .leftJoin(userRoleSchema, eq(userRoleSchema.roleId, roleSchema.id))
        .leftJoin(userSchema, eq(userRoleSchema.userId, userSchema.id));
    const rolesJoined: RowType[] = await query;

    const rolesMap = new Map<string, Role>();

    for (const row of rolesJoined) {
        const roleData = row[tableNames.role];
        if (!roleData) continue;

        const roleObj = parseJson<Role>(roleData);
        const role = getRoleFromMap(rolesMap, roleObj);

        const userRoleData = row[tableNames.userRole];
        const userData = row[tableNames.user];
        if (!userRoleData || !userData) continue;

        const userRole = parseJson<UserRole>(userRoleData);
        const user = parseJson<User>(userData);

        role.userRoleList?.push({
            ...userRole,
            role,
            user,
        });
    }

    return Array.from(rolesMap.values());
}

function getRoleFromMap(rolesMap: Map<string, Role>, roleObj: Role) {
    if (!rolesMap.has(roleObj.id)) {
        roleObj.userRoleList = [];
        rolesMap.set(roleObj.id, roleObj);
    }
    return rolesMap.get(roleObj.id)!;
}

export async function getRoleByName(name: string, throwIfNotFound?: true): Promise<Role>;
export async function getRoleByName(name: string, throwIfNotFound?: boolean): Promise<Role | undefined>;
export async function getRoleByName(name: string, throwIfNotFound = false) {
    const roleFromDb: Role | undefined = await db.query.roleSchema.findFirst({
        where: eq(roleSchema.name, name),
    });

    if (throwIfNotFound && !roleFromDb) {
        throw apiNotFoundError(errorMessages.roleNotFound.replace("{0}", name));
    }

    return roleFromDb;
}

export async function anyRoleExists() {
    const result = dbIsAny(resourceNames.role);

    return result;
}

export async function upsertRole(roleModel: Role) {
    const resourceFromDb = await getResourceById(resourceNames.role, roleModel.id, false);

    if (resourceFromDb) {
        await updateResource(roleModel, resourceNames.role);
    } else {
        await createResource(roleModel, resourceNames.role);
    }
}