/**
 * Revisión de SOLO LECTURA antes de que /ordenes-compra y los dos endpoints de Requisiciones que
 * generan OC pidan permiso (plan 2026-10-23-ordenes-compra, Task 6; spec punto 2).
 * Corre en una transacción READ ONLY: no puede escribir nada. Se corre en cada base antes de desplegar.
 *
 * Simula lo que cada perfil tendrá DESPUÉS de la migración 20261023100000_oc_permisos (lo que ya
 * tiene en el módulo COMPRAS, que es lo que mira PermissionGuard, más lo que le da el criterio):
 *   a1. _VER a todo perfil con algún privilegio activo de COMPRAS.
 *   a2. _CREAR / _EDITAR / _ELIMINAR si tiene algún privilegio de COMPRAS con acción CREAR, EDITAR o ELIMINAR.
 *   a3. _APROBAR si tiene algún privilegio de COMPRAS con acción APROBAR.
 *   b.  _VER si tiene CMP_FAC_FACTURA_PROV_CREAR o algún CMP_REC_RECEPCION_* (en cualquier módulo).
 *
 * Imprime por empresa:
 *  1. Usuarios con eventos de auditoría `orden_compra` de los últimos 12 meses cuya acción
 *     (CREATE → _CREAR, UPDATE → _EDITAR, APPROVE → _APROBAR, CANCEL → _ELIMINAR) quedaría sin el
 *     permiso en ninguno de sus perfiles. Los superadmin pasan el guard y no se listan.
 *  2. Usuarios que generaron OC desde Requisiciones (`requisicion_historial.accion = 'oc_creada'`,
 *     últimos 12 meses) sin _CREAR después de la migración.
 * Si hay filas, imprime el SQL de asignación COMENTADO, por perfil, para que el usuario decida.
 * El script NO lo ejecuta.
 *
 * Uso: npx ts-node scripts/revisar-permisos-ordenes-compra.ts
 */
import 'dotenv/config';
import { Prisma, PrismaClient } from '@prisma/client';

const MODULO = 'COMPRAS';
const MESES = 12;
const P = {
  VER: 'CMP_OC_ORDEN_COMPRA_VER',
  CREAR: 'CMP_OC_ORDEN_COMPRA_CREAR',
  EDITAR: 'CMP_OC_ORDEN_COMPRA_EDITAR',
  ELIMINAR: 'CMP_OC_ORDEN_COMPRA_ELIMINAR',
  APROBAR: 'CMP_OC_ORDEN_COMPRA_APROBAR',
} as const;
const TODOS = Object.values(P);
/** Acción de la auditoría de OC → privilegio que la pide ahora. */
const PRIVILEGIO_DE_ACCION: Record<string, string> = {
  CREATE: P.CREAR,
  UPDATE: P.EDITAR,
  APPROVE: P.APROBAR,
  CANCEL: P.ELIMINAR,
};

type PerfilDespues = { perfil_id: string; perfil: string; despues: string[] };
type UsuarioSinPermiso = {
  empresa: string;
  usuario_id: string;
  usuario: string;
  origen: string;
  eventos: number;
  falta: string;
  perfiles: PerfilDespues[];
};

const prisma = new PrismaClient();

/**
 * Por perfil: los privilegios de OC que tendrá después de la migración. Misma definición de
 * "privilegio de COMPRAS" que la migración: por el submódulo del privilegio o por el modulo_id.
 */
const PERFILES_DESPUES = Prisma.sql`
  SELECT pf.id AS perfil_id, COALESCE(pf.perfil, pf.id::text) AS perfil,
         ARRAY(
           SELECT DISTINCT c FROM unnest(
             COALESCE(ARRAY_AGG(DISTINCT pr.codigo) FILTER (WHERE pr.codigo IN (${Prisma.join(TODOS)}) AND mp.codigo = ${MODULO}), '{}')
             || CASE WHEN BOOL_OR(ms.codigo = ${MODULO} OR mp.codigo = ${MODULO}) THEN ARRAY[${P.VER}]::text[] ELSE '{}' END
             || CASE WHEN BOOL_OR((ms.codigo = ${MODULO} OR mp.codigo = ${MODULO}) AND pr.accion IN ('CREAR', 'EDITAR', 'ELIMINAR'))
                     THEN ARRAY[${P.CREAR}, ${P.EDITAR}, ${P.ELIMINAR}]::text[] ELSE '{}' END
             || CASE WHEN BOOL_OR((ms.codigo = ${MODULO} OR mp.codigo = ${MODULO}) AND pr.accion = 'APROBAR')
                     THEN ARRAY[${P.APROBAR}]::text[] ELSE '{}' END
             || CASE WHEN BOOL_OR(pr.codigo = 'CMP_FAC_FACTURA_PROV_CREAR' OR pr.codigo LIKE 'CMP\\_REC\\_RECEPCION\\_%')
                     THEN ARRAY[${P.VER}]::text[] ELSE '{}' END
           ) AS c
         ) AS despues
    FROM perfiles pf
    LEFT JOIN perfiles_privilegios pp ON pp.perfil_id = pf.id AND pp.active = true
    LEFT JOIN privilegios pr ON pr.id = pp.privilegio_id
    LEFT JOIN submodulos s ON s.id = pr.submodulo_id
    LEFT JOIN modulos ms ON ms.id = s.modulo_id
    LEFT JOIN modulos mp ON mp.id = pp.modulo_id
   GROUP BY pf.id, pf.perfil`;

/** Usuarios (no superadmin) con su uso de OC: (usuario, empresa, origen, privilegio que pide, eventos). */
const USOS = Prisma.sql`
  SELECT a.user_id, a.empresa_id, 'auditoría ' || a.action AS origen,
         CASE a.action
           ${Prisma.join(
             Object.entries(PRIVILEGIO_DE_ACCION).map(([accion, priv]) => Prisma.sql`WHEN ${accion} THEN ${priv}`),
             ' ',
           )}
         END AS privilegio,
         COUNT(*) AS eventos
    FROM audit_logs a
   WHERE a.entity_type = 'orden_compra'
     AND a.action IN (${Prisma.join(Object.keys(PRIVILEGIO_DE_ACCION))})
     AND a.created_at >= NOW() - (${MESES} * INTERVAL '1 month')
     AND a.user_id IS NOT NULL
   GROUP BY a.user_id, a.empresa_id, a.action
  UNION ALL
  SELECT h.usuario_id, r.empresa_id, 'OC desde Requisiciones' AS origen, ${P.CREAR} AS privilegio, COUNT(*) AS eventos
    FROM requisicion_historial h
    JOIN requisicion_cab r ON r.id = h.requisicion_id
   WHERE h.accion = 'oc_creada'
     AND h.created_at >= NOW() - (${MESES} * INTERVAL '1 month')
     AND h.usuario_id IS NOT NULL
   GROUP BY h.usuario_id, r.empresa_id`;

async function usuariosSinPermiso(tx: Prisma.TransactionClient): Promise<UsuarioSinPermiso[]> {
  const filas = await tx.$queryRaw<
    {
      empresa: string;
      usuario_id: string;
      usuario: string;
      origen: string;
      privilegio: string;
      eventos: bigint;
      perfiles: PerfilDespues[] | null;
    }[]
  >`
    WITH despues AS (${PERFILES_DESPUES}), usos AS (${USOS})
    SELECT COALESCE(e.razon_social, e.id::text, '(sin empresa)') AS empresa, u.id AS usuario_id,
           COALESCE(NULLIF(TRIM(CONCAT_WS(' ', u.nombres, u.apellidos)), ''), u.username, u.id::text) AS usuario,
           us.origen, us.privilegio, us.eventos,
           (SELECT json_agg(json_build_object('perfil_id', d.perfil_id, 'perfil', d.perfil, 'despues', d.despues))
              FROM usuario_perfiles up JOIN despues d ON d.perfil_id = up.perfil_id
             WHERE up.user_id = u.id) AS perfiles
      FROM usos us
      JOIN usuario u ON u.id = us.user_id
      LEFT JOIN empresas e ON e.id = us.empresa_id
     WHERE COALESCE(u.is_superadmin, false) = false
       AND NOT EXISTS (
         SELECT 1 FROM usuario_perfiles up JOIN despues d ON d.perfil_id = up.perfil_id
          WHERE up.user_id = u.id AND us.privilegio = ANY(d.despues))
     ORDER BY 1, 3, 4`;
  return filas.map((f) => ({
    empresa: f.empresa,
    usuario_id: f.usuario_id,
    usuario: f.usuario,
    origen: f.origen,
    eventos: Number(f.eventos),
    falta: f.privilegio,
    perfiles: f.perfiles ?? [],
  }));
}

/** Resumen informativo: perfiles con cada privilegio de OC hoy y después de la migración. */
async function resumen(tx: Prisma.TransactionClient) {
  return tx.$queryRaw<{ privilegio: string; hoy: bigint; despues: bigint }[]>`
    WITH despues AS (${PERFILES_DESPUES}),
    hoy AS (
      SELECT DISTINCT pp.perfil_id, pr.codigo
        FROM perfiles_privilegios pp
        JOIN privilegios pr ON pr.id = pp.privilegio_id AND pr.codigo IN (${Prisma.join(TODOS)})
        JOIN modulos m ON m.id = pp.modulo_id AND m.codigo = ${MODULO}
       WHERE pp.active = true)
    SELECT c AS privilegio,
           (SELECT COUNT(*) FROM hoy WHERE hoy.codigo = c) AS hoy,
           (SELECT COUNT(*) FROM despues WHERE c = ANY(despues.despues)) AS despues
      FROM unnest(ARRAY[${Prisma.join(TODOS)}]::text[]) AS c`;
}

const literal = (texto: string) => `'${texto.replace(/'/g, "''")}'`;

/** INSERT del privilegio a un perfil, en COMPRAS, sin duplicar filas (no hay índice único). */
function sqlAsignar(perfilId: string, privilegio: string, comentario: string): string {
  return [
    `-- ${comentario}`,
    'INSERT INTO perfiles_privilegios (perfil_id, privilegio_id, modulo_id, active)',
    `SELECT ${literal(perfilId)}::uuid, pr.id, m.id, true`,
    '  FROM privilegios pr',
    `  JOIN modulos m ON m.codigo = ${literal(MODULO)}`,
    ` WHERE pr.codigo = ${literal(privilegio)} AND pr.active = true`,
    '   AND NOT EXISTS (SELECT 1 FROM perfiles_privilegios x',
    `                    WHERE x.perfil_id = ${literal(perfilId)}::uuid AND x.privilegio_id = pr.id AND x.modulo_id = m.id AND x.active = true);`,
  ].join('\n');
}

function porEmpresa<T extends { empresa: string }>(filas: T[]): Map<string, T[]> {
  const grupos = new Map<string, T[]>();
  for (const f of filas) grupos.set(f.empresa, [...(grupos.get(f.empresa) ?? []), f]);
  return grupos;
}

function imprimirSeccion(titulo: string, filas: UsuarioSinPermiso[]) {
  console.log(`\n${titulo}: ${filas.length}`);
  for (const [empresa, grupo] of porEmpresa(filas)) {
    console.log(`   ${empresa}`);
    for (const f of grupo) {
      const perfiles = f.perfiles.length
        ? f.perfiles.map((p) => `${p.perfil} [${p.despues.join(', ') || 'nada de OC'}]`).join('; ')
        : 'sin perfil asignado';
      console.log(
        `     - ${f.usuario} (${f.usuario_id}): ${f.origen}, ${f.eventos} evento(s); falta ${f.falta}; perfiles después de la migración: ${perfiles}`,
      );
    }
  }
}

async function main() {
  const { usuarios, conteo } = await prisma.$transaction(async (tx) => {
    await tx.$executeRawUnsafe('SET TRANSACTION READ ONLY');
    return { usuarios: await usuariosSinPermiso(tx), conteo: await resumen(tx) };
  });

  console.log(`Revisión de permisos de Órdenes de compra (solo lectura) — ${new Date().toISOString()}\n`);
  console.log(`Perfiles con cada privilegio en ${MODULO}, hoy → después de la migración 20261023100000_oc_permisos:`);
  for (const c of conteo) console.log(`   ${c.privilegio}: ${Number(c.hoy)} → ${Number(c.despues)}`);

  const auditoria = usuarios.filter((u) => u.origen.startsWith('auditoría'));
  const requisiciones = usuarios.filter((u) => !u.origen.startsWith('auditoría'));
  imprimirSeccion(
    `1. Usuarios con auditoría orden_compra de los últimos ${MESES} meses que quedarían sin el permiso de esa acción`,
    auditoria,
  );
  imprimirSeccion(
    `2. Usuarios que generaron OC desde Requisiciones en ${MESES} meses y quedarían sin ${P.CREAR}`,
    requisiciones,
  );

  // SQL comentado: el permiso que falta, en cada perfil del usuario que ya opera Compras (tiene _VER
  // después de la migración); un perfil ajeno a Compras no se toca.
  const sentencias = new Map<string, string>();
  for (const u of usuarios) {
    for (const p of u.perfiles.filter((x) => x.despues.includes(P.VER))) {
      const clave = `${p.perfil_id}:${u.falta}`;
      if (!sentencias.has(clave)) {
        sentencias.set(
          clave,
          sqlAsignar(p.perfil_id, u.falta, `${u.empresa} · ${u.usuario} · perfil ${p.perfil} (${u.origen})`),
        );
      }
    }
  }
  if (!usuarios.length) {
    console.log('\nNadie que hoy usa OC queda sin el permiso. No hace falta asignar nada.');
    return;
  }
  console.log('\n-- SQL de asignación (NO se ejecutó; descomentar solo lo que corresponda y aplicarlo a mano).');
  if (!sentencias.size)
    console.log('-- Ningún usuario listado tiene un perfil que opere Compras: asignarle uno a mano.');
  console.log([...sentencias.values()].map((sql) => sql.replace(/^/gm, '-- ')).join('\n\n'));
}

main()
  .catch((error) => {
    console.error(error);
    process.exitCode = 1;
  })
  .finally(() => prisma.$disconnect());
