/**
 * Revisión de SOLO LECTURA antes de cerrar los permisos de Órdenes de pago y Cuentas a pagar (plan
 * 2026-10-28-orden-pago-cxp, Task 10; spec punto 2). Corre en una transacción READ ONLY: no puede escribir
 * nada. Se corre en cada base ANTES de desplegar y de aplicar la migración.
 *
 * Desde este cambio: ejecutar y los reintentos piden CMP_OP_ORDEN_PAGO_PAGAR (antes _CREAR), y el alta con
 * «aplicar al guardar» pide además _PAGAR. Simula lo que cada perfil tendrá DESPUÉS de la migración
 * 20261028100100_op_cxp_permisos (lo que ya tiene en el módulo COMPRAS, que es lo que mira PermissionGuard,
 * más lo que le da el criterio). Igual que la migración, solo cuentan filas activas de privilegios activos:
 *   a1. CMP_OP_ORDEN_PAGO_VER y CMP_CXP_CUENTA_PAGAR_VER a todo perfil con algún privilegio activo de COMPRAS.
 *   a2. _CREAR / _PAGAR / _ANULAR de OP si tiene algún privilegio de COMPRAS con acción CREAR, EDITAR o ELIMINAR.
 *   a3. _PAGAR si ya tiene CMP_OP_ORDEN_PAGO_CREAR (en cualquier módulo).
 *   a4. _APROBAR si tiene algún privilegio de COMPRAS con acción APROBAR.
 *
 * Imprime:
 *  0. Perfiles con cada privilegio de OP/CxP en COMPRAS, hoy → después de la migración.
 *  1. Por empresa, usuarios que crearon OP manuales en los últimos 12 meses
 *     (`orden_pago_proveedor_cab.usuario_id` con `origen = 'manual'`: la OP no tenía auditoría hasta este
 *     cambio; en las viejas, usuario_id puede ser quien hizo la última acción) que quedarían sin _CREAR o sin
 *     _PAGAR en todos sus perfiles. Los superadmin pasan el guard y no se listan.
 * 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 --transpile-only -r tsconfig-paths/register --project tsconfig.scripts.json scripts/revisar-permisos-ordenes-pago.ts
 */
import 'dotenv/config';
import { Prisma, PrismaClient } from '@prisma/client';

const MODULO = 'COMPRAS';
const MESES = 12;
const P = {
  VER: 'CMP_OP_ORDEN_PAGO_VER',
  CREAR: 'CMP_OP_ORDEN_PAGO_CREAR',
  PAGAR: 'CMP_OP_ORDEN_PAGO_PAGAR',
  ANULAR: 'CMP_OP_ORDEN_PAGO_ANULAR',
  APROBAR: 'CMP_OP_ORDEN_PAGO_APROBAR',
  CXP_VER: 'CMP_CXP_CUENTA_PAGAR_VER',
} as const;
const TODOS = Object.values(P);
/** Lo que necesita quien crea OP manuales después del cambio: armar la orden y pagarla. */
const NECESARIOS = [P.CREAR, P.PAGAR];

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

const prisma = new PrismaClient();

/**
 * Por perfil: los privilegios de OP/CxP 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; solo filas
 * activas (pp.active) de privilegios activos (pr.active).
 */
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}, ${P.CXP_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.PAGAR}, ${P.ANULAR}]::text[] ELSE '{}' END
             || CASE WHEN BOOL_OR(pr.codigo = ${P.CREAR}) THEN ARRAY[${P.PAGAR}]::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
           ) 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 AND pr.active = true
    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 AND pr.id IS NOT NULL
   GROUP BY pf.id, pf.perfil`;

/** Quién creó OP manuales en los últimos meses: (usuario, empresa, órdenes). */
const USOS = Prisma.sql`
  SELECT o.usuario_id AS user_id, o.empresa_id, COUNT(*) AS ordenes
    FROM orden_pago_proveedor_cab o
   WHERE o.origen = 'manual'
     AND o.usuario_id IS NOT NULL
     AND o.created_at >= NOW() - (${MESES} * INTERVAL '1 month')
   GROUP BY o.usuario_id, o.empresa_id`;

async function usuariosSinPermiso(tx: Prisma.TransactionClient): Promise<UsuarioSinPermiso[]> {
  const filas = await tx.$queryRaw<
    {
      empresa: string;
      usuario_id: string;
      usuario: string;
      ordenes: bigint;
      falta: string;
      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.ordenes, nec.privilegio AS falta,
           (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
     CROSS JOIN unnest(ARRAY[${Prisma.join(NECESARIOS)}]::text[]) AS nec(privilegio)
     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 nec.privilegio = ANY(d.despues))
     ORDER BY 1, 3, 5`;
  return filas.map((f) => ({
    empresa: f.empresa,
    usuario_id: f.usuario_id,
    usuario: f.usuario,
    ordenes: Number(f.ordenes),
    falta: f.falta,
    perfiles: f.perfiles ?? [],
  }));
}

/** Resumen informativo: perfiles con cada privilegio de OP/CxP 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.active = true 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 OP/CxP'}]`).join('; ')
        : 'sin perfil asignado';
      console.log(
        `     - ${f.usuario} (${f.usuario_id}): ${f.ordenes} OP manual(es); 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 pago y Cuentas a pagar (solo lectura) — ${new Date().toISOString()}\n`,
  );
  console.log(
    `Perfiles con cada privilegio en ${MODULO}, hoy → después de la migración 20261028100100_op_cxp_permisos:`,
  );
  for (const c of conteo) console.log(`   ${c.privilegio}: ${Number(c.hoy)} → ${Number(c.despues)}`);

  imprimirSeccion(
    `1. Usuarios que crearon OP manuales en los últimos ${MESES} meses y quedarían sin ${NECESARIOS.join(' o ')}`,
    usuarios,
  );

  if (!usuarios.length) {
    console.log('\nNadie que hoy crea órdenes de pago queda sin _CREAR o _PAGAR. No hace falta asignar nada.');
    return;
  }

  // SQL comentado: el permiso que falta, en cada perfil del usuario que ya opera Compras (tiene _VER de OP
  // 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.ordenes} OP manuales)`,
          ),
        );
      }
    }
  }
  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());
