/**
 * Role & Permission Factory - 测试数据工厂（v2.1）
 * 
 * 用于生成测试角色和权限数据
 * 
 * 基于文档: docs/modules/organization/09-test-scenarios.md - 测试工具和辅助函数
 * 版本: v2.1
 */

import { PrismaClient } from '@prisma/client';
import { randomString } from './user.factory';

const prisma = new PrismaClient();

/**
 * 创建测试角色
 */
export async function createTestRole(overrides: any = {}) {
  const defaultData = {
    code: `ROLE_${randomString()}`,
    name: `测试角色_${randomString()}`,
    enabled: true,
  };

  return await prisma.role.create({
    data: {
      ...defaultData,
      ...overrides,
    },
    include: {
      permissions: {
        include: {
          permission: true,
        },
      },
    },
  });
}

/**
 * 批量创建角色（带权限）
 */
export async function createManyRoles(
  count: number,
  permissionsPerRole: number = 0,
) {
  const roles = [];

  for (let i = 0; i < count; i++) {
    const role = await createTestRole({
      code: `ROLE_${i}`,
      name: `角色${i}`,
    });

    if (permissionsPerRole > 0) {
      const permissions = await createManyPermissions(permissionsPerRole);
      await Promise.all(
        permissions.map((perm) =>
          prisma.rolePermission.create({
            data: { roleId: role.id, permissionId: perm.id },
          }),
        ),
      );
    }

    roles.push(role);
  }

  return roles;
}

/**
 * 创建测试权限
 */
export async function createTestPermission(overrides: any = {}) {
  const resource = overrides.resource || `resource_${randomString()}`;
  const action = overrides.action || `action_${randomString()}`;

  const defaultData = {
    code: `${resource}:${action}`,
    name: `权限_${randomString()}`,
    resource,
    action,
  };

  return await prisma.permission.create({
    data: {
      ...defaultData,
      ...overrides,
    },
  });
}

/**
 * 批量创建权限
 */
export async function createManyPermissions(count: number) {
  const permissions = [];

  for (let i = 0; i < count; i++) {
    const perm = await prisma.permission.create({
      data: {
        code: `resource${i}:action${i}`,
        name: `权限${i}`,
        resource: `resource${i}`,
        action: `action${i}`,
      },
    });
    permissions.push(perm);
  }

  return permissions;
}

/**
 * 为角色分配权限
 */
export async function assignPermissionToRole(
  roleId: string,
  permissionId: string,
) {
  return await prisma.rolePermission.create({
    data: {
      roleId,
      permissionId,
    },
  });
}

/**
 * 为用户分配角色（支持组织级别，v2.1）
 */
export async function assignRoleToUser(
  userId: string,
  roleId: string,
  organizationId: string | null = null,
) {
  return await prisma.userRole.create({
    data: {
      userId,
      roleId,
      organizationId,
    },
  });
}

/**
 * 清理测试角色和权限
 */
export async function cleanupTestRolesAndPermissions() {
  await prisma.userRole.deleteMany({});
  await prisma.rolePermission.deleteMany({});
  await prisma.role.deleteMany({});
  await prisma.permission.deleteMany({});
}