import { PrismaService } from 'src/prisma/prisma.service';
import { bloqueoPorPrueba, contextoPlanEmpresa, submoduloHabilitado } from './submodulo.guard';

type DbAddons = Pick<PrismaService, 'privilegios' | 'suscripcion_submodulos'>;
type DbPlan = DbAddons & Pick<PrismaService, 'usuario' | 'empresas' | 'submodulos' | 'suscripciones' | 'suscripcion_modulos'>;

/**
 * Capa 1.2 de `PermissionGuard` para uno o varios privilegios, en dos consultas: el privilegio que pertenece a un
 * submódulo addon exige el addon contratado (fila activa de `suscripcion_submodulos` en una suscripción Activo/EnGracia
 * de la empresa). Devuelve, por privilegio bloqueado, el mensaje del 403. Holding y reseller quedan exceptuados: eso lo
 * decide quien llama (el guard ya conoce el tipo de empresa). Aplica también al superadmin, como el guard.
 */
export async function addonsNoContratados(prisma: DbAddons, empresaId: string, privilegios: string[]): Promise<Map<string, string>> {
  const bloqueados = new Map<string, string>();
  if (privilegios.length === 0) return bloqueados;
  const filas = await prisma.privilegios.findMany({
    where: { codigo: { in: privilegios }, active: true },
    select: { codigo: true, submodulos: { select: { id: true, codigo: true, es_addon: true } } },
  });
  // Un código repetido toma la primera fila, como el `findFirst` que hacía el guard.
  const primera = new Map<string, (typeof filas)[number]>();
  for (const f of filas) if (!primera.has(f.codigo)) primera.set(f.codigo, f);
  const addons = [...primera.entries()].flatMap(([privilegio, f]) => (f.submodulos?.es_addon ? [[privilegio, f.submodulos] as const] : []));
  if (addons.length === 0) return bloqueados;
  const contratados = await prisma.suscripcion_submodulos.findMany({
    where: { active: true, submodulo_id: { in: [...new Set(addons.map(([, s]) => s.id))] }, suscripciones: { empresa_id: empresaId, estado: { in: ['Activo', 'EnGracia'] } } },
    select: { submodulo_id: true },
  });
  const activos = new Set(contratados.map((c) => c.submodulo_id));
  for (const [privilegio, s] of addons) {
    if (!activos.has(s.id)) bloqueados.set(privilegio, `El submódulo "${s.codigo}" requiere un addon no contratado en su plan`);
  }
  return bloqueados;
}

/** Por submódulo y por privilegio, el mensaje del 403 que el guard respondería. Vacío = nada bloqueado. */
export interface BloqueosDePlan {
  submodulos: Map<string, string>;
  privilegios: Map<string, string>;
}

export const SIN_BLOQUEOS_DE_PLAN: BloqueosDePlan = { submodulos: new Map(), privilegios: new Map() };

/**
 * Lo que `SubmoduloGuard` y la capa 1.2 de `PermissionGuard` le responderían a este usuario por el plan de la empresa, sin el
 * request: para las lecturas que muestran acciones habilitadas o no (`acciones_permitidas` de Importaciones) con el mismo
 * criterio que el endpoint de cada acción. Usa las mismas funciones que los guards (`submoduloHabilitado`, `bloqueoPorPrueba`,
 * `addonsNoContratados`): el superadmin saltea `SubmoduloGuard` pero no la capa 1.2; holding y reseller saltean las dos.
 * `metodo` es el de las acciones (una escritura), para el período de prueba vencido en solo lectura.
 */
export async function bloqueosDePlan(
  prisma: DbPlan,
  empresaId: string,
  usuarioId: string | undefined,
  pedido: { submodulos: readonly string[]; privilegios: readonly string[]; metodo: string },
): Promise<BloqueosDePlan> {
  // Empresa y suscripción se leen una sola vez por pedido (no una por submódulo).
  const [usuario, contexto] = await Promise.all([
    usuarioId ? prisma.usuario.findUnique({ where: { id: usuarioId }, select: { is_superadmin: true } }) : Promise.resolve(null),
    contextoPlanEmpresa(prisma, empresaId),
  ]);
  const holdingOReseller = await contexto.holdingOReseller();

  const submodulos = new Map<string, string>();
  if (!usuario?.is_superadmin) {
    const estados = await Promise.all([...new Set(pedido.submodulos)].map(async (codigo) => [codigo, await submoduloHabilitado(prisma, empresaId, codigo, contexto)] as const));
    for (const [codigo, estado] of estados) {
      const mensaje = 'mensaje' in estado ? estado.mensaje : bloqueoPorPrueba(estado.fechaFinPrueba, codigo, pedido.metodo);
      if (mensaje) submodulos.set(codigo, mensaje);
    }
  }
  const privilegios = holdingOReseller ? new Map<string, string>() : await addonsNoContratados(prisma, empresaId, [...new Set(pedido.privilegios)]);
  return { submodulos, privilegios };
}
