//server/fd/fd-toolbox-asp-net/permission-data-provider.ts
import { FdMemoryCacheOptions } from "@server/fd/fd-toolbox/cachings/fd-memory-cache-options";
import { Permission } from "@/fd/fd-toolbox-web/permissions/permission.resource";
import { PermissionPackageToPermission } from "@/fd/fd-toolbox-web/permissions/permission-package-to-permission.resource";
import { PermissionDto } from "@server/auth/permission-dto";
import {
    PermissionLevel,
    permissionType,
    PermissionType,
} from "@/fd/fd-toolbox-core/auth/permissions/permission-enums";
import { setCoreCache, tryGetObjectFromCoreCache } from "@server/fd/fd-toolbox/cachings/core-memory-cache";
import { addListValueToDictionary, addMapValueToMap } from "@server/fd/fd-toolbox/services/dictionaries";
import { RoleToPermission } from "@server/auth/role-to-permission";
import { getAllIncludingUserToRoles } from "@server/auth/role-db";
import {
    resourceSchema,
    permissionSchema as permissionTable,
    roleToPermissionSchema,
} from "@packages/plugin/schema";
import { eq, getTableColumns } from "drizzle-orm";
import { getQuery } from "@server/web/drizzle";
import { UserRole } from "@/users/user-role.resource";
import { getPermissionPackageToPermissions } from "../fd-toolbox-web/auth/permissions/permission-package-to-permission-db";
import { getRoleToPermissionPackages } from "../fd-toolbox-web/models/roles/role-to-permission-package-db";
import { getPermissionCacheKey, createShallowPermission } from "../fd-toolbox-web/permissions/permissions";
import { fdCacheKeys } from "../fd-toolbox-web/constants/fd-cache-keys";

export async function getUserRoleIdsToRoleLevels() {
    const roles = await getAllIncludingUserToRoles();

    const userRoleIdsLevels = new Map<string, Map<string, PermissionLevel>>();

    for (const roleItem of roles) {
        if (roleItem.userRoleList) {
            for (const userRoleItem of roleItem.userRoleList.filter(
                (ur: UserRole) => ur.roleId === roleItem.id,
            )) {
                addMapValueToMap(userRoleIdsLevels, userRoleItem.userId, userRoleItem.roleId, roleItem.level);
            }
        }
    }

    return userRoleIdsLevels;
}

export async function saveRoleToPermissionsToCache(
    rolePackageToPermissions: Map<string, string[]>,
    ids: string[],
    type: PermissionType,
) {
    let cacheKeyPrefix: string = fdCacheKeys.roleToDefaultPermissions;

    if (type === permissionType.resource) {
        cacheKeyPrefix = fdCacheKeys.roleToResourcePermissions;
    } else if (type === permissionType.property) {
        cacheKeyPrefix = fdCacheKeys.roleToPropertyPermissions;
    }

    for (const id of ids) {
        await addMapFromCache(rolePackageToPermissions, id, cacheKeyPrefix);

        if (!rolePackageToPermissions.has(id)) {
            await saveRoleToPermissionsToCacheById(id);
            await addMapFromCache(rolePackageToPermissions, id, cacheKeyPrefix);
        }
    }

    return rolePackageToPermissions;
}

export async function getRoleToPermissionList() {
    return getQuery(roleToPermissionSchema);
}

export async function getUserPermissionCacheKey(type: PermissionType, userId: string) {
    return getPermissionCacheKey(type.toString(), userId);
}

export async function getUserResourcePermissionCacheKey(
    type: PermissionType,
    resourceName: string,
    userId: string,
) {
    return getPermissionCacheKey(await getPermissionCacheKey(type.toString(), resourceName), userId);
}

export async function saveUserPermissionsToMemoryCache(
    userPermissionKey: string,
    type: PermissionType,
    userPermissions: Map<string, PermissionDto>,
) {
    const cacheKey = await getUserPermissionCacheKey(type, userPermissionKey);
    await saveToMemoryCache(cacheKey, userPermissions);
}

export async function getUserRoleIdsToRolePermissionLevels(userId: string) {
    const roleIdsLevels = new Map<string, PermissionLevel>();
    const memoryCacheKey = await getPermissionCacheKey(fdCacheKeys.userRolePermissionLevels, userId);

    const cachedUserRoleIdsLevels = tryGetObjectFromCoreCache<Map<string, PermissionLevel>>(memoryCacheKey);

    if (cachedUserRoleIdsLevels) {
        return cachedUserRoleIdsLevels;
    } else {
        await saveUserRoleIdsToRolePermissionLevelsToCache();
        const rolesToLevels = tryGetObjectFromCoreCache<Map<string, PermissionLevel>>(memoryCacheKey);
        if (rolesToLevels) {
            return rolesToLevels;
        }
    }

    return roleIdsLevels;
}

export async function savePackageToPermissionsToCache(
    rolePackageToPermissions: Map<string, string[]>,
    ids: string[],
    type: PermissionType,
) {
    let cacheKeyPrefix;

    switch (type) {
        case permissionType.resource:
            cacheKeyPrefix = fdCacheKeys.packagesToResourcePermissions;
            break;
        case permissionType.property:
            cacheKeyPrefix = fdCacheKeys.packagesToPropertyPermissions;
            break;
        default:
            cacheKeyPrefix = fdCacheKeys.packagesToDefaultPermissions;
    }

    for (const id of ids) {
        await addMapFromCache(rolePackageToPermissions, id, cacheKeyPrefix);
        if (!rolePackageToPermissions.has(id)) {
            await privateSavePackageToPermissionsToCache(id);

            await addMapFromCache(rolePackageToPermissions, id, cacheKeyPrefix);
        }
    }

    return rolePackageToPermissions;
}

export async function getPermission(id: string) {
    let permission = tryGetObjectFromCoreCache<Permission>(
        await getPermissionCacheKey(fdCacheKeys.permission, id),
    );

    if (permission) {
        return createShallowPermission(permission);
    } else {
        await savePermissionsToCache();
        permission = tryGetObjectFromCoreCache(await getPermissionCacheKey(fdCacheKeys.permission, id));

        return permission && createShallowPermission(permission);
    }
}

export async function addPackageToPermissions(
    rolesToPermissions: Map<string, string[]>,
    packageToPermissionList: PermissionPackageToPermission[],
    type: PermissionType,
) {
    for (const packageToPermission of packageToPermissionList) {
        const permission = await getPermission(packageToPermission.permissionId);
        if (permission?.type === type) {
            addListValueToDictionary(
                rolesToPermissions,
                packageToPermission.permissionPackageId,
                packageToPermission.permissionId,
            );
        }
    }
}

async function createPermissionForCache(permission: {
    id: string;
    resourceId: string | null;
    resourcePropertyId: string | null;
    name: string | null;
    action: number | null;
    type: number;
    resource: { id: string; name: string } | null;
}) {
    return createShallowPermission({
        id: permission.id,
        resourceId: permission.resourceId || undefined,
        resourcePropertyId: permission.resourcePropertyId || undefined,
        name: permission.name || undefined,
        action: permission.action ?? undefined,
        resource: permission.resource || undefined,
        type: permission.type,
    });
}

export async function savePermissionsToCache() {
    const requiredColumns = {
        id: permissionTable.id,
        resourceId: permissionTable.resourceId,
        resourcePropertyId: permissionTable.resourcePropertyId,
        name: permissionTable.name,
        action: permissionTable.action,
        type: permissionTable.type,
        resource: getTableColumns(resourceSchema),
    };

    const query = getQuery(permissionTable, requiredColumns);
    const permissions = await query.leftJoin(
        resourceSchema,
        eq(permissionTable.resourceId, resourceSchema.id),
    );

    const cachePromises = permissions.map(async (permission) => {
        const cacheKey = await getPermissionCacheKey(fdCacheKeys.permission, permission.id);
        const permissionForCache = await createPermissionForCache(permission);
        return saveToMemoryCache(cacheKey, permissionForCache);
    });

    await Promise.all(cachePromises);
    return true;
}

export async function getRoleToPackages(ids: string[]) {
    const roleToPackages = new Map<string, string[]>();

    for (const id of ids) {
        await addMapFromCache(roleToPackages, id, fdCacheKeys.roleToPackages);
        if (!roleToPackages.has(id)) {
            await saveRoleToPermissionPackagesToCache();

            await addMapFromCache(roleToPackages, id, fdCacheKeys.roleToPackages);
        }
    }

    return roleToPackages;
}

async function addMapFromCache<T>(map: Map<string, T[]>, id: string, cacheKeyPrefix: string) {
    const memoryCacheKey = await getPermissionCacheKey(cacheKeyPrefix, id);
    const cachedValue = tryGetObjectFromCoreCache<T[]>(memoryCacheKey);
    if (cachedValue) {
        map.set(id, cachedValue);
    }
}

async function saveRoleToPermissionsToCacheById(id: string) {
    const rolesToResourcePermissions: Map<string, string[]> = new Map();
    const rolesToDefaultPermissions: Map<string, string[]> = new Map();
    const rolesToPropertyPermissions: Map<string, string[]> = new Map();

    const roleToPermissionList = await getRoleToPermissionList();
    let roleIds = [id, ...roleToPermissionList.map((x) => x.roleId)];
    roleIds = [...new Set(roleIds)];

    await addRoleToPermissions(rolesToResourcePermissions, roleToPermissionList, permissionType.resource);
    await addRoleToPermissions(rolesToDefaultPermissions, roleToPermissionList, permissionType.default);
    await addRoleToPermissions(rolesToPropertyPermissions, roleToPermissionList, permissionType.property);

    await saveToMemoryCacheByCacheKeyPrefix(
        rolesToResourcePermissions,
        fdCacheKeys.roleToResourcePermissions,
    );
    await saveToMemoryCacheByCacheKeyPrefix(rolesToDefaultPermissions, fdCacheKeys.roleToDefaultPermissions);
    await saveToMemoryCacheByCacheKeyPrefix(
        rolesToPropertyPermissions,
        fdCacheKeys.roleToPropertyPermissions,
    );
}

async function addRoleToPermissions(
    rolesToPermissions: Map<string, string[]>,
    roleToPermissionList: RoleToPermission[],
    type: PermissionType,
) {
    for (const roleToPermissionItem of roleToPermissionList) {
        const permission = await getPermission(roleToPermissionItem.permissionId);
        if (permission?.type === type) {
            addListValueToDictionary(
                rolesToPermissions,
                roleToPermissionItem.roleId,
                roleToPermissionItem.permissionId,
            );
        }
    }
}

async function applyPermissionsToPackages(
    permissionMap: Map<string, string[]>,
    permissionList: PermissionPackageToPermission[],
    permissionTypeParam: PermissionType,
    packageIds: string[],
) {
    await addPackageToPermissions(permissionMap, permissionList, permissionTypeParam);

    if (permissionMap.size === 0) {
        for (const packId of packageIds) {
            permissionMap.set(packId, []);
        }
    }
}

async function privateSavePackageToPermissionsToCache(id: string) {
    const packagesToResourcePermissions = new Map<string, string[]>();
    const packagesToDefaultPermissions = new Map<string, string[]>();
    const packagesToPropertyPermissions = new Map<string, string[]>();

    const packageToPermissionList = await getPermissionPackageToPermissions();

    let permissionPackageIds = [id];

    permissionPackageIds = permissionPackageIds.concat(
        packageToPermissionList.map((x) => x.permissionPackageId),
    );
    permissionPackageIds = Array.from(new Set(permissionPackageIds));

    await applyPermissionsToPackages(
        packagesToResourcePermissions,
        packageToPermissionList,
        permissionType.resource,
        permissionPackageIds,
    );

    await applyPermissionsToPackages(
        packagesToDefaultPermissions,
        packageToPermissionList,
        permissionType.default,
        permissionPackageIds,
    );

    await applyPermissionsToPackages(
        packagesToPropertyPermissions,
        packageToPermissionList,
        permissionType.property,
        permissionPackageIds,
    );

    await saveToMemoryCacheByCacheKeyPrefix(
        packagesToResourcePermissions,
        fdCacheKeys.packagesToResourcePermissions,
    );
    await saveToMemoryCacheByCacheKeyPrefix(
        packagesToDefaultPermissions,
        fdCacheKeys.packagesToDefaultPermissions,
    );
    await saveToMemoryCacheByCacheKeyPrefix(
        packagesToPropertyPermissions,
        fdCacheKeys.packagesToPropertyPermissions,
    );
}

async function saveRoleToPermissionPackagesToCache() {
    const rolesToPackages = new Map<string, string[]>();

    const roleToPermissionPackageList = await getRoleToPermissionPackages();

    for (const roleToPermissionPackage of roleToPermissionPackageList) {
        addListValueToDictionary(
            rolesToPackages,
            roleToPermissionPackage.roleId,
            roleToPermissionPackage.permissionPackageId,
        );
    }

    await saveToMemoryCacheByCacheKeyPrefix(rolesToPackages, fdCacheKeys.roleToPackages);
}

async function saveToMemoryCacheByCacheKeyPrefix(
    idsToPermissions: Map<string, string[]>,
    cacheKeyPrefix: string,
) {
    for (const [key, value] of idsToPermissions) {
        const newKey = await getPermissionCacheKey(cacheKeyPrefix, key);
        await saveToMemoryCache(newKey, value);
    }
}

async function saveUserRoleIdsToRolePermissionLevelsToCache() {
    const userIdRoleIdsToRolePermissionLevels = await getUserRoleIdsToRoleLevels();

    for (const [userId, rolePermissionLevels] of userIdRoleIdsToRolePermissionLevels.entries()) {
        const key = await getPermissionCacheKey(fdCacheKeys.userRolePermissionLevels, userId);
        await saveToMemoryCache(key, rolePermissionLevels);
    }
}

async function saveToMemoryCache<T extends object>(key: string, value: T) {
    const fdMemoryCacheOptions: FdMemoryCacheOptions = {
        absoluteExpirationRelativeToNowSeconds: 24 * fdCacheKeys.secondsInAHour,
    };

    setCoreCache(key, value, fdMemoryCacheOptions);
}