/**
 * Revisión de SOLO LECTURA antes de cerrar los permisos de Requisiciones y de aplicar las migraciones de datos
 * del plan 2026-10-29-requisiciones (Task 11; spec puntos 2 y 8). Corre en una transacción READ ONLY: no puede
 * escribir nada. Se corre en cada base ANTES de desplegar y de aplicar las migraciones. Usa PrismaClient directo
 * (no AppModule).
 *
 * Desde este cambio el controller pide el submódulo COMP_REQUISICIONES y un privilegio por acción:
 * _VER (lecturas), _CREAR (alta y enviar), _EDITAR, _APROBAR (aprobar y rechazar) y _ELIMINAR (cancelar).
 * Simula lo que cada perfil tendrá DESPUÉS de la migración 20261029100400_requisiciones_permisos (lo que ya
 * tiene en el módulo COMPRAS, que es lo que mira PermissionGuard, más lo que le da el criterio). Solo cuentan
 * filas activas de privilegios activos:
 *   a1. _VER a todo perfil con algún privilegio de COMPRAS.
 *   a2. _CREAR, _EDITAR y _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.
 *   a4. _VER y _APROBAR si el perfil es de un nivel de requisicion_aprobacion_config.
 *
 * Imprime, por empresa cuando corresponde:
 *  1. Requisiciones por estado.
 *  2. Las pendientes de aprobación (número, solicitante, nivel pendiente, niveles aprobados): la migración
 *     20261029100200 las vuelve a borrador.
 *  3. Niveles de aprobación configurados.
 *  4. Requisiciones sin sucursal.
 *  5. Números repetidos (la migración 20261029100100 se detiene si hay).
 *  6. Líneas ejecutadas por documentos en moneda extranjera (las recalcula 20261029100300).
 *  7. Perfiles con cada privilegio de Requisiciones, hoy → después de la migración.
 *  8. Usuarios que crearon, enviaron, aprobaron, rechazaron o cancelaron en los últimos 12 meses y quedarían
 *     sin el privilegio de esa acción en todos sus perfiles.
 *  9. Perfiles de nivel que reciben _APROBAR solo por a4, marcando los de niveles inactivos.
 * Con filas en 8 o 9, imprime el SQL de asignación COMENTADO, por perfil, para que el usuario decida. NO lo
 * ejecuta.
 *
 * Uso: npx ts-node --transpile-only -r tsconfig-paths/register --project tsconfig.scripts.json scripts/revisar-permisos-requisiciones.ts
 */
import 'dotenv/config';
import { Prisma, PrismaClient } from '@prisma/client';

const MODULO = 'COMPRAS';
const MESES = 12;
const P = {
  VER: 'CMP_REQ_REQUISICION_VER',
  CREAR: 'CMP_REQ_REQUISICION_CREAR',
  EDITAR: 'CMP_REQ_REQUISICION_EDITAR',
  APROBAR: 'CMP_REQ_REQUISICION_APROBAR',
  ELIMINAR: 'CMP_REQ_REQUISICION_ELIMINAR',
} as const;
const TODOS = Object.values(P);

/** Acción del historial (o alta) → privilegio que pide el controller para hacerla. */
const ACCIONES: { accion: string; etiqueta: string; privilegio: string }[] = [
  { accion: 'creada', etiqueta: 'crear', privilegio: P.CREAR },
  { accion: 'enviada_aprobacion', etiqueta: 'enviar', privilegio: P.CREAR },
  { accion: 'aprobada', etiqueta: 'aprobar', privilegio: P.APROBAR },
  { accion: 'aprobada_nivel', etiqueta: 'aprobar un nivel', privilegio: P.APROBAR },
  { accion: 'rechazada', etiqueta: 'rechazar', privilegio: P.APROBAR },
  { accion: 'cancelada', etiqueta: 'cancelar', privilegio: P.ELIMINAR },
];

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

const prisma = new PrismaClient();
const nombreEmpresa = Prisma.sql`COALESCE(e.razon_social, e.id::text)`;

/**
 * Filas de "privilegio de COMPRAS" del perfil `pf`, con la MISMA definición que a1–a3 de la migración
 * (JOIN submodulos / modulos ms; `ms.codigo = COMPRAS OR mp.codigo = COMPRAS`; pp.active y p.active). Un privilegio sin
 * submódulo no cuenta, igual que en la migración.
 */
const COMPRAS_DEL_PERFIL = Prisma.sql`
  SELECT 1
    FROM perfiles_privilegios pp
    JOIN privilegios p ON p.id = pp.privilegio_id
    JOIN submodulos s ON s.id = p.submodulo_id
    JOIN modulos ms ON ms.id = s.modulo_id
    LEFT JOIN modulos mp ON mp.id = pp.modulo_id
   WHERE pp.perfil_id = pf.id
     AND pp.active = true
     AND p.active = true
     AND (ms.codigo = ${MODULO} OR mp.codigo = ${MODULO})`;

/**
 * Por perfil: los privilegios de Requisiciones 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((SELECT ARRAY_AGG(DISTINCT pr.codigo)
                         FROM perfiles_privilegios pp
                         JOIN privilegios pr ON pr.id = pp.privilegio_id AND pr.active = true
                         JOIN modulos mp ON mp.id = pp.modulo_id AND mp.codigo = ${MODULO}
                        WHERE pp.perfil_id = pf.id AND pp.active = true AND pr.codigo IN (${Prisma.join(TODOS)})), '{}')
             || CASE WHEN EXISTS (${COMPRAS_DEL_PERFIL}) THEN ARRAY[${P.VER}]::text[] ELSE '{}' END
             || CASE WHEN EXISTS (${COMPRAS_DEL_PERFIL} AND p.accion IN ('CREAR', 'EDITAR', 'ELIMINAR'))
                     THEN ARRAY[${P.CREAR}, ${P.EDITAR}, ${P.ELIMINAR}]::text[] ELSE '{}' END
             || CASE WHEN EXISTS (${COMPRAS_DEL_PERFIL} AND p.accion = 'APROBAR')
                     THEN ARRAY[${P.APROBAR}]::text[] ELSE '{}' END
             || CASE WHEN EXISTS (SELECT 1 FROM requisicion_aprobacion_config rc WHERE rc.perfil_id = pf.id)
                     THEN ARRAY[${P.VER}, ${P.APROBAR}]::text[] ELSE '{}' END
           ) AS c
         ) AS despues
    FROM perfiles pf`;

/** Quién hizo cada acción en los últimos meses: (usuario, empresa, acción, veces). */
const USOS = Prisma.sql`
  SELECT x.user_id, x.empresa_id, x.accion, x.privilegio, COUNT(*) AS veces
    FROM (
      SELECT c.solicitante_id AS user_id, c.empresa_id, 'creada' AS accion, ${P.CREAR} AS privilegio
        FROM requisicion_cab c
       WHERE c.solicitante_id IS NOT NULL AND c.created_at >= NOW() - (${MESES} * INTERVAL '1 month')
      UNION ALL
      SELECT h.usuario_id, c.empresa_id, h.accion,
             CASE h.accion WHEN 'cancelada' THEN ${P.ELIMINAR}
                           WHEN 'enviada_aprobacion' THEN ${P.CREAR}
                           ELSE ${P.APROBAR} END
        FROM requisicion_historial h
        JOIN requisicion_cab c ON c.id = h.requisicion_id
       WHERE h.usuario_id IS NOT NULL
         AND h.accion IN ('enviada_aprobacion', 'aprobada', 'aprobada_nivel', 'rechazada', 'cancelada')
         AND h.created_at >= NOW() - (${MESES} * INTERVAL '1 month')
    ) x
   GROUP BY x.user_id, x.empresa_id, x.accion, x.privilegio`;

async function usuariosSinPermiso(tx: Prisma.TransactionClient): Promise<UsuarioSinPermiso[]> {
  const filas = await tx.$queryRaw<
    { empresa: string; usuario_id: string; usuario: string; accion: string; veces: 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.accion, us.veces, us.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
     WHERE COALESCE(u.is_superadmin, false) = false
       AND u.active = true
       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) => ({ ...f, veces: Number(f.veces), perfiles: f.perfiles ?? [] }));
}

/**
 * Perfiles de nivel que reciben _APROBAR SOLO por a4 (hoy no lo tienen en COMPRAS ni les llega por a3): son los que
 * la migración habilita para aprobar. Marca los niveles inactivos (a4 no filtra `activo`: esos perfiles ganan _VER y
 * _APROBAR aunque su nivel no se copie al enviar).
 */
async function perfilesAprobarSoloPorNivel(tx: Prisma.TransactionClient) {
  return tx.$queryRaw<{ empresa: string; perfil_id: string; perfil: string; niveles: string; solo_inactivos: boolean; usuarios: bigint }[]>`
    SELECT ${nombreEmpresa} AS empresa, pf.id AS perfil_id, COALESCE(pf.perfil, pf.id::text) AS perfil,
           STRING_AGG(rc.origen_tipo || ' nivel ' || rc.nivel || CASE WHEN COALESCE(rc.activo, true) THEN '' ELSE ' (INACTIVO)' END,
                      ', ' ORDER BY rc.origen_tipo, rc.nivel) AS niveles,
           BOOL_AND(COALESCE(rc.activo, true) = false) AS solo_inactivos,
           (SELECT COUNT(*) FROM usuario_perfiles up JOIN usuario u ON u.id = up.user_id AND u.active = true
             WHERE up.perfil_id = pf.id) AS usuarios
      FROM requisicion_aprobacion_config rc
      JOIN empresas e ON e.id = rc.empresa_id
      JOIN perfiles pf ON pf.id = rc.perfil_id
     WHERE NOT EXISTS (
             SELECT 1 FROM perfiles_privilegios pp
               JOIN privilegios pr ON pr.id = pp.privilegio_id AND pr.active = true AND pr.codigo = ${P.APROBAR}
               JOIN modulos mp ON mp.id = pp.modulo_id AND mp.codigo = ${MODULO}
              WHERE pp.perfil_id = pf.id AND pp.active = true)
       AND NOT EXISTS (
             SELECT 1 FROM perfiles_privilegios pp
               JOIN privilegios p ON p.id = pp.privilegio_id
               JOIN submodulos s ON s.id = p.submodulo_id
               JOIN modulos ms ON ms.id = s.modulo_id
               LEFT JOIN modulos mp ON mp.id = pp.modulo_id
              WHERE pp.perfil_id = pf.id AND pp.active = true AND p.active = true
                AND (ms.codigo = ${MODULO} OR mp.codigo = ${MODULO}) AND p.accion = 'APROBAR')
     GROUP BY e.id, e.razon_social, pf.id, pf.perfil
     ORDER BY 1, 3`;
}

/** Resumen informativo: perfiles con cada privilegio de Requisiciones 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`;
}

async function datos(tx: Prisma.TransactionClient) {
  const porEstado = await tx.$queryRaw<{ empresa: string; estado: string; n: bigint }[]>`
    SELECT ${nombreEmpresa} AS empresa, c.estado, COUNT(*) AS n
      FROM requisicion_cab c JOIN empresas e ON e.id = c.empresa_id
     GROUP BY 1, c.estado ORDER BY 1, 2`;
  const pendientes = await tx.$queryRaw<
    { empresa: string; numero: string | null; solicitante: string | null; pendiente: number | null; aprobados: number[] | null }[]
  >`
    SELECT ${nombreEmpresa} AS empresa, c.numero_requisicion AS numero,
           NULLIF(TRIM(CONCAT_WS(' ', u.nombres, u.apellidos)), '') AS solicitante,
           (SELECT MIN(a.nivel) FROM requisicion_aprobacion a WHERE a.requisicion_id = c.id AND a.estado = 'pendiente') AS pendiente,
           (SELECT ARRAY_AGG(a.nivel ORDER BY a.nivel) FROM requisicion_aprobacion a WHERE a.requisicion_id = c.id AND a.estado = 'aprobada') AS aprobados
      FROM requisicion_cab c
      JOIN empresas e ON e.id = c.empresa_id
      LEFT JOIN usuario u ON u.id = c.solicitante_id
     WHERE c.estado = 'pendiente_aprobacion'
     ORDER BY 1, 2`;
  const niveles = await tx.$queryRaw<
    { empresa: string; origen: string; nivel: number; perfil: string; desde: string; hasta: string | null; activo: boolean | null }[]
  >`
    SELECT ${nombreEmpresa} AS empresa, rc.origen_tipo AS origen, rc.nivel,
           COALESCE(pf.perfil, pf.id::text) AS perfil, rc.monto_desde::text AS desde, rc.monto_hasta::text AS hasta, rc.activo
      FROM requisicion_aprobacion_config rc
      JOIN empresas e ON e.id = rc.empresa_id
      JOIN perfiles pf ON pf.id = rc.perfil_id
     ORDER BY 1, 2, 3`;
  const sinSucursal = await tx.$queryRaw<{ empresa: string; n: bigint }[]>`
    SELECT ${nombreEmpresa} AS empresa, COUNT(*) AS n
      FROM requisicion_cab c JOIN empresas e ON e.id = c.empresa_id
     WHERE c.sucursal_id IS NULL GROUP BY 1 ORDER BY 1`;
  const repetidos = await tx.$queryRaw<{ empresa: string; numero: string; n: bigint }[]>`
    SELECT ${nombreEmpresa} AS empresa, c.numero_requisicion AS numero, COUNT(*) AS n
      FROM requisicion_cab c JOIN empresas e ON e.id = c.empresa_id
     WHERE c.numero_requisicion IS NOT NULL
     GROUP BY e.id, e.razon_social, c.numero_requisicion HAVING COUNT(*) > 1 ORDER BY 1, 2`;
  const extranjera = await tx.$queryRaw<{ empresa: string; moneda: string; lineas: bigint; documentos: bigint }[]>`
    SELECT ${nombreEmpresa} AS empresa, x.moneda, COUNT(DISTINCT x.requisicion_det_id) AS lineas, COUNT(*) AS documentos
      FROM (
        SELECT cd.requisicion_det_id, cc.empresa_id, upper(trim(m.codigo)) AS moneda
          FROM compra_det cd JOIN compra_cab cc ON cc.id = cd.compra_id JOIN moneda m ON m.id = cc.moneda_id
         WHERE cd.requisicion_det_id IS NOT NULL AND COALESCE(cc.anulado, false) = false AND COALESCE(cc.activo, true) = true
           AND upper(trim(m.codigo)) <> 'PYG'
        UNION ALL
        SELECT gd.requisicion_det_id, gc.empresa_id, upper(trim(m.codigo))
          FROM gasto_det gd JOIN gasto_cab gc ON gc.id = gd.gasto_id JOIN moneda m ON m.id = gc.moneda_id
         WHERE gd.requisicion_det_id IS NOT NULL AND COALESCE(gc.anulado, false) = false AND COALESCE(gc.activo, true) = true
           AND upper(trim(m.codigo)) <> 'PYG'
      ) x JOIN empresas e ON e.id = x.empresa_id
     GROUP BY 1, x.moneda ORDER BY 1, 2`;
  return { porEstado, pendientes, niveles, sinSucursal, repetidos, extranjera };
}

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 seccion<T extends { empresa: string }>(titulo: string, filas: T[], linea: (f: T) => string, vacio = 'ninguna') {
  console.log(`\n${titulo}: ${filas.length}`);
  if (!filas.length) return console.log(`   (${vacio})`);
  for (const [empresa, grupo] of porEmpresa(filas)) {
    console.log(`   ${empresa}`);
    for (const f of grupo) console.log(`     - ${linea(f)}`);
  }
}

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

  console.log(`Revisión de Requisiciones (solo lectura) — ${new Date().toISOString()}`);

  seccion('1. Requisiciones por estado (empresa / estado / cantidad)', d.porEstado, (f) => `${f.estado}: ${Number(f.n)}`);
  seccion(
    '2. Pendientes de aprobación (la migración 20261029100200 las vuelve a borrador)',
    d.pendientes,
    (f) =>
      `${f.numero ?? '(sin número)'} · solicitante ${f.solicitante ?? '(sin solicitante)'} · nivel pendiente ${f.pendiente ?? '-'} · niveles aprobados ${(f.aprobados ?? []).join(', ') || 'ninguno'}`,
  );
  seccion(
    '3. Niveles de aprobación configurados',
    d.niveles,
    (f) => `${f.origen} nivel ${f.nivel}: perfil ${f.perfil}, de ${f.desde} a ${f.hasta ?? 'sin tope'}${f.activo === false ? ' (inactivo)' : ''}`,
    'sin niveles: enviar a aprobación fallará con SIN_NIVELES hasta configurarlos',
  );
  seccion('4. Requisiciones sin sucursal', d.sinSucursal, (f) => `${Number(f.n)} requisición(es)`);
  seccion(
    '5. Números repetidos (la migración 20261029100100 se detiene si hay alguno)',
    d.repetidos,
    (f) => `${f.numero}: ${Number(f.n)} veces`,
  );
  seccion(
    '6. Líneas ejecutadas por documentos en moneda extranjera (las recalcula 20261029100300)',
    d.extranjera,
    (f) => `${f.moneda}: ${Number(f.lineas)} línea(s), ${Number(f.documentos)} documento(s)`,
  );

  console.log(`\n7. Perfiles con cada privilegio en ${MODULO}, hoy → después de la migración 20261029100400_requisiciones_permisos:`);
  for (const c of conteo) console.log(`   ${c.privilegio}: ${Number(c.hoy)} → ${Number(c.despues)}`);

  seccion(
    `8. Usuarios que hicieron una acción en los últimos ${MESES} meses y quedarían sin su privilegio`,
    usuarios,
    (f) => {
      const perfiles = f.perfiles.length
        ? f.perfiles.map((p) => `${p.perfil} [${p.despues.join(', ') || 'nada de Requisiciones'}]`).join('; ')
        : 'sin perfil asignado';
      const etiqueta = ACCIONES.find((a) => a.accion === f.accion)?.etiqueta ?? f.accion;
      return `${f.usuario} (${f.usuario_id}): ${f.veces} vez/veces para ${etiqueta}; falta ${f.falta}; perfiles después de la migración: ${perfiles}`;
    },
    'nadie pierde una acción que hace hoy',
  );
  seccion(
    '9. Perfiles de nivel que reciben _APROBAR solo por a4 (hoy no lo tienen; INACTIVO = su nivel no se copia al enviar)',
    soloNivel,
    (f) =>
      `${f.perfil} (${f.perfil_id}): ${f.niveles}; ${Number(f.usuarios)} usuario(s) activo(s)${f.solo_inactivos ? '; TODOS sus niveles están inactivos: ganan _VER y _APROBAR sin poder aprobar nada' : ''}`,
    'ningún perfil de nivel gana _APROBAR solo por a4',
  );

  // 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.accion}: ${u.veces})`));
      }
    }
  }
  if (!usuarios.length) {
    console.log('\nNadie que hoy opera Requisiciones queda sin 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 de la sección 8 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());
