import type { EntityManager } from '@mikro-orm/core';
import { Role } from '../modules/roles/entities/role.entity';
import type { PermissionEnum } from '../common/enums/permission.enum';
import type {Permission } from '../modules/roles/entities/permission.entity';
import { rolesData } from './data/roles.data';

export class RolesSeeder {
  async run(em: EntityManager, permissions: Permission[]): Promise<Map<string, Role>> {
    const rolesMap = new Map<string, Role>();

    for (const roleConfig of rolesData) {
      const existingRole = await em.findOne(Role, { name: roleConfig.name });
      let role: Role;

      if (!existingRole) {
        role = em.create(Role, {
          name: roleConfig.name,
          title: roleConfig.title,
          isSystem: roleConfig.isSystem,
        });
      } else {
        role = existingRole;
        await role.permissions.init();

        if (role.title !== roleConfig.title) {
          role.title = roleConfig.title;
        }

        if (role.isSystem !== roleConfig.isSystem) {
          role.isSystem = roleConfig.isSystem;
        }
      }

      const filteredPermissions = permissions.filter((p) =>
        roleConfig.permissionFilter(p.name as PermissionEnum),
      );
      const filteredPermissionNames = new Set(filteredPermissions.map((p) => p.name));

      for (const existingPermission of role.permissions.getItems()) {
        if (!filteredPermissionNames.has(existingPermission.name)) {
          role.permissions.remove(existingPermission);
        }
      }

      for (const permission of filteredPermissions) {
        if (!role.permissions.contains(permission, false)) {
          role.permissions.add(permission);
        }
      }

      em.persist(role);
      rolesMap.set(roleConfig.name, role);
    }

    await em.flush();
    return rolesMap;
  }
}