import {getDatabase, createOptions} from "@vostro/c2-utils/lib/database";
import {get as getCache, set as setCache, exists as existsCache} from "@vostro/c2-utils/lib/cache";
import { C2Utils } from '@vostro/c2-utils/lib/types';

export async function buildPermissionSetForRole(role: string |any , context = {}) {
  if (role === "public" || !role) {
    const db = await getDatabase();
    const {Role} = db.models;
    role = await Role.findOne(createOptions({}, {
      where: {
        name: "public",
      },
      override: true,
    }));
  }
  return buildPermissionSetForRoleById(role.id, context);
}


export async function buildPermissionSetForRoleById(roleId: string, context = {}) {
  if (existsCache("permission-sets", roleId)) {
    return getCache("permission-sets", roleId);
  }
  const db = await getDatabase();
  const {RolePermission, Permission} = db.models;
  const rolePermissions = await RolePermission.findAll(createOptions(context, {
    where: {
      roleId: roleId,
    },
    include: [{
      model: Permission,
      as: "permission",
    }],
    override: true,
  }));

  const permissions = rolePermissions.reduce((o: { [x: string]: { [x: string]: any; }; }, rp: { permission: { type: string | number; name: string | number; }; level: any; }) => {
    if (!o[rp.permission.type]) {
      o[rp.permission.type] = {};
    }
    o[rp.permission.type][rp.permission.name] = rp.level;
    return o;
  }, {
    model: {},
    query: {},
    mutation: {},
    subscription: {},
  });
  await setCache("permission-sets", roleId, permissions);
  return permissions;
}



export let roleCache: any = {};

export async function getRoleLevel(role: string | any, permission: any, type: any, context: C2Utils.DataContext) {
  if (role === "public" || !role) {
    const db = await getDatabase();
    const {Role} = db.models;
    role = await Role.findOne(createOptions({}, {
      where: {
        name: "public",
      },
      override: true,
    }));
  }

  const key = `${role.id}:${permission}:${type}`;
  if (roleCache[key]) {
    return roleCache[key];
  }

  const db = await getDatabase();
  const {Role, RolePermission, Permission} = db.models;
  const perm = await RolePermission.findOne(createOptions(context, {
    include: [{
      model: Role,
      as: "role",
      where: {
        id: role.id,
      },
    }, {
      model: Permission,
      as: "permission",
      where: {
        name: permission,
        type: type,
      },
    }],
    override: true,
  }));
  if (perm) {
    roleCache[key] = perm.level;
  } else {
    roleCache[key] = "none";
  }
  return roleCache[key];
}