/**
 * Revisión de SOLO LECTURA antes de que `POST/PATCH /compras` pidan permiso y la pestaña nueva
 * de Facturas de compra oculte botones por permiso (plan 2026-10-21-facturas-compra, Task 3).
 * Corre en una transacción READ ONLY: no puede escribir nada.
 *
 * Imprime por empresa:
 *  1. Perfiles con algún privilegio activo del módulo COMPRAS (por el submódulo del privilegio o
 *     por el `modulo_id` con que se grabó) a los que les falta, en el módulo COMPRAS (como lo mira
 *     PermissionGuard), lo que les corresponde con el criterio de la migración
 *     20261021099900_compras_facturas_permisos (Ruling P): CMP_FAC_FACTURA_PROV_VER a todos, y
 *     _CREAR / _EDITAR / _ELIMINAR solo a los que operan Compras (algún privilegio de COMPRAS con
 *     acción CREAR, EDITAR o ELIMINAR). Con sus usuarios activos. Aparte lista, informativo, los
 *     perfiles que no operan Compras (solo consultan, exportan, aprueban, pagan, programan o
 *     importan), con sus acciones, que quedan solo con _VER: el usuario decide si alguno debería operar.
 *  2. Usuarios que crearon o editaron compras en los últimos 90 días (`compra_cab.usuario_id`,
 *     que `update` reescribe con quien edita) y no tienen _CREAR o _EDITAR. Los superadmin
 *     pasan el guard y no se listan.
 *  3. Informativo: perfiles con _CREAR sin CMP_PRV_PROVEEDOR_CREAR (COMPRAS) o sin
 *     INV_PRD_PRODUCTO_CREAR (INVENTARIO): en el formulario nuevo verán "Nuevo proveedor" o
 *     "Nuevo producto" deshabilitados.
 * Si 1 o 2 traen filas, imprime el SQL de asignación para que lo aplique el usuario:
 *  A. realinear al módulo COMPRAS lo que el perfil ya tiene en otro módulo (no da nada nuevo);
 *  B. comentado: _CREAR/_EDITAR a quien ya crea o edita compras, solo en sus perfiles que ya
 *     operan Compras;
 *  C. comentado: privilegios que el perfil nunca tuvo.
 * El script NO lo ejecuta. `perfiles_privilegios` no tiene índice único por
 * (perfil, privilegio), así que el SQL evita duplicados con NOT EXISTS (un
 * ON CONFLICT DO NOTHING no frenaría nada).
 *
 * Uso: npx ts-node scripts/revisar-permisos-facturas-compra.ts
 */
import 'dotenv/config';
import { Prisma, PrismaClient } from '@prisma/client';

const MODULO = 'COMPRAS';
const PRIVILEGIOS = [
  'CMP_FAC_FACTURA_PROV_VER',
  'CMP_FAC_FACTURA_PROV_CREAR',
  'CMP_FAC_FACTURA_PROV_EDITAR',
  'CMP_FAC_FACTURA_PROV_ELIMINAR',
];
const PRIVILEGIO_VER = 'CMP_FAC_FACTURA_PROV_VER';
const PRIVILEGIO_CREAR = 'CMP_FAC_FACTURA_PROV_CREAR';
const PRIVILEGIOS_OPERAR = ['CMP_FAC_FACTURA_PROV_CREAR', 'CMP_FAC_FACTURA_PROV_EDITAR'];
/** "Opera Compras" (Ruling P): alguna de estas acciones en un privilegio de COMPRAS. */
const ACCIONES_OPERAR = ['CREAR', 'EDITAR', 'ELIMINAR'];
/** Las altas rápidas del formulario: privilegio y módulo con que las mira el guard. */
const ALTAS_RAPIDAS = [
  { codigo: 'CMP_PRV_PROVEEDOR_CREAR', modulo: 'COMPRAS', boton: 'Nuevo proveedor' },
  { codigo: 'INV_PRD_PRODUCTO_CREAR', modulo: 'INVENTARIO', boton: 'Nuevo producto' },
];
const DIAS_COMPRAS = 90;

type PerfilIncompleto = {
  empresa: string;
  perfil_id: string;
  perfil: string;
  usuarios_activos: number;
  tiene: string[];
  /** Grabados con otro `modulo_id`: la pantalla los ve (deriva el módulo del submódulo), el guard no. */
  en_otro_modulo: string[];
  /** Tiene algún privilegio de COMPRAS con acción CREAR, EDITAR o ELIMINAR: le corresponden los cuatro. */
  opera_escritura: boolean;
  /** Las acciones de sus privilegios de COMPRAS (para el informativo de los que no operan). */
  acciones: string[];
  faltan: string[];
};
type UsuarioSinOperar = {
  empresa: string;
  usuario_id: string;
  usuario: string;
  compras: number;
  faltan: string[];
  /** `operaCompras`: el perfil ya tiene algún privilegio activo del módulo COMPRAS. */
  perfiles: { id: string; perfil: string; operaCompras: boolean }[];
};
type PerfilSinAltas = {
  empresa: string;
  perfil_id: string;
  perfil: string;
  usuarios_activos: number;
  faltan: string[];
};

const prisma = new PrismaClient();

const usuariosActivosDe = Prisma.sql`
  (SELECT COUNT(DISTINCT u.id) FROM usuario_perfiles up JOIN usuario u ON u.id = up.user_id
    WHERE up.perfil_id = pf.id AND COALESCE(u.active, true) AND NOT COALESCE(u.is_superadmin, false))`;

/** Los privilegios de Facturas que le corresponden al perfil (criterio de la migración). */
const privilegiosQueCorresponden = (operaEscritura: boolean) =>
  operaEscritura ? PRIVILEGIOS : PRIVILEGIOS.filter((p) => p === PRIVILEGIO_VER);

/** Todos los perfiles que operan Compras, con lo que tienen y lo que les falta. */
async function perfilesCompras(tx: Prisma.TransactionClient): Promise<PerfilIncompleto[]> {
  const filas = await tx.$queryRaw<
    {
      empresa: string | null;
      perfil_id: string;
      perfil: string | null;
      usuarios_activos: bigint;
      tiene: string[] | null;
      en_otro_modulo: string[] | null;
      opera_escritura: boolean;
      acciones: string[] | null;
    }[]
  >`
    SELECT COALESCE(e.razon_social, e.id::text) AS empresa, pf.id AS perfil_id, pf.perfil,
           ${usuariosActivosDe} AS usuarios_activos,
           ARRAY_AGG(DISTINCT pr.codigo) FILTER (WHERE pr.codigo IN (${Prisma.join(PRIVILEGIOS)}) AND m.codigo = ${MODULO}) AS tiene,
           ARRAY_AGG(DISTINCT pr.codigo || ' (' || COALESCE(m.codigo, 'sin módulo') || ')')
             FILTER (WHERE pr.codigo IN (${Prisma.join(PRIVILEGIOS)}) AND m.codigo IS DISTINCT FROM ${MODULO}) AS en_otro_modulo,
           COALESCE(BOOL_OR((ms.codigo = ${MODULO} OR m.codigo = ${MODULO}) AND pr.accion IN (${Prisma.join(ACCIONES_OPERAR)})), false) AS opera_escritura,
           ARRAY_AGG(DISTINCT pr.accion) FILTER (WHERE ms.codigo = ${MODULO} OR m.codigo = ${MODULO}) AS acciones
      FROM perfiles pf
      JOIN perfiles_privilegios pp ON pp.perfil_id = pf.id AND pp.active = true
      JOIN privilegios pr ON pr.id = pp.privilegio_id
      JOIN submodulos s ON s.id = pr.submodulo_id
      JOIN modulos ms ON ms.id = s.modulo_id
      LEFT JOIN modulos m ON m.id = pp.modulo_id
      LEFT JOIN empresas e ON e.id = pf.empresa_id
     GROUP BY e.razon_social, e.id, pf.id, pf.perfil
    -- Opera Compras: algún privilegio del módulo, por su submódulo o por el módulo con que se grabó.
    HAVING BOOL_OR(ms.codigo = ${MODULO} OR m.codigo = ${MODULO})
     ORDER BY 1, 3`;
  return filas.map((f) => {
    const tiene = f.tiene ?? [];
    return {
      empresa: f.empresa ?? '(perfil sin empresa)',
      perfil_id: f.perfil_id,
      perfil: f.perfil ?? f.perfil_id,
      usuarios_activos: Number(f.usuarios_activos),
      tiene,
      // Solo los que no tienen ya su par en COMPRAS: esos son los que el guard rechaza.
      en_otro_modulo: (f.en_otro_modulo ?? []).filter((texto) => !tiene.includes(texto.split(' (')[0])),
      opera_escritura: f.opera_escritura,
      acciones: f.acciones ?? [],
      faltan: privilegiosQueCorresponden(f.opera_escritura).filter((p) => !tiene.includes(p)),
    };
  });
}

async function usuariosSinOperar(tx: Prisma.TransactionClient): Promise<UsuarioSinOperar[]> {
  const filas = await tx.$queryRaw<
    { empresa: string; usuario_id: string; usuario: string; compras: bigint; tiene: string[] | null }[]
  >`
    SELECT COALESCE(e.razon_social, e.id::text) AS empresa, u.id AS usuario_id,
           COALESCE(NULLIF(TRIM(CONCAT_WS(' ', u.nombres, u.apellidos)), ''), u.username, u.id::text) AS usuario,
           COUNT(*) AS compras,
           (SELECT ARRAY_AGG(DISTINCT pr.codigo)
              FROM usuario_perfiles up
              JOIN perfiles_privilegios pp ON pp.perfil_id = up.perfil_id AND pp.active = true
              JOIN privilegios pr ON pr.id = pp.privilegio_id AND pr.codigo IN (${Prisma.join(PRIVILEGIOS_OPERAR)})
              JOIN modulos m ON m.id = pp.modulo_id AND m.codigo = ${MODULO}
             WHERE up.user_id = u.id) AS tiene
      FROM compra_cab c
      JOIN usuario u ON u.id = c.usuario_id
      JOIN empresas e ON e.id = c.empresa_id
     WHERE GREATEST(c.created_at, c.updated_at) >= NOW() - (${DIAS_COMPRAS} * INTERVAL '1 day')
       AND COALESCE(u.is_superadmin, false) = false
     GROUP BY e.razon_social, e.id, u.id
     ORDER BY 1, 3`;
  const resultado: UsuarioSinOperar[] = [];
  for (const f of filas) {
    const faltan = PRIVILEGIOS_OPERAR.filter((p) => !(f.tiene ?? []).includes(p));
    if (!faltan.length) continue;
    const perfiles = await tx.usuario_perfiles.findMany({
      where: { user_id: f.usuario_id, perfil_id: { not: null } },
      select: {
        perfiles: {
          select: {
            id: true,
            perfil: true,
            _count: {
              select: {
                perfiles_privilegios: {
                  where: {
                    active: true,
                    OR: [
                      { modulos: { codigo: MODULO } },
                      { privilegios: { submodulos: { modulos: { codigo: MODULO } } } },
                    ],
                  },
                },
              },
            },
          },
        },
      },
    });
    resultado.push({
      empresa: f.empresa,
      usuario_id: f.usuario_id,
      usuario: f.usuario,
      compras: Number(f.compras),
      faltan,
      perfiles: perfiles.flatMap((p) =>
        p.perfiles
          ? [
              {
                id: p.perfiles.id,
                perfil: p.perfiles.perfil ?? p.perfiles.id,
                operaCompras: p.perfiles._count.perfiles_privilegios > 0,
              },
            ]
          : [],
      ),
    });
  }
  return resultado;
}

async function perfilesSinAltasRapidas(tx: Prisma.TransactionClient): Promise<PerfilSinAltas[]> {
  const filas = await tx.$queryRaw<
    {
      empresa: string | null;
      perfil_id: string;
      perfil: string | null;
      usuarios_activos: bigint;
      tiene: string[] | null;
    }[]
  >`
    SELECT COALESCE(e.razon_social, e.id::text) AS empresa, pf.id AS perfil_id, pf.perfil,
           ${usuariosActivosDe} AS usuarios_activos,
           (SELECT ARRAY_AGG(DISTINCT pr.codigo || '@' || m.codigo)
              FROM perfiles_privilegios pp
              JOIN privilegios pr ON pr.id = pp.privilegio_id
              JOIN modulos m ON m.id = pp.modulo_id
             WHERE pp.perfil_id = pf.id AND pp.active = true
               AND pr.codigo IN (${Prisma.join(ALTAS_RAPIDAS.map((a) => a.codigo))})) AS tiene
      FROM perfiles pf
      LEFT JOIN empresas e ON e.id = pf.empresa_id
     WHERE EXISTS (
       SELECT 1
         FROM perfiles_privilegios pp
         JOIN privilegios pr ON pr.id = pp.privilegio_id AND pr.codigo = ${PRIVILEGIO_CREAR}
         JOIN modulos m ON m.id = pp.modulo_id AND m.codigo = ${MODULO}
        WHERE pp.perfil_id = pf.id AND pp.active = true)
     ORDER BY 1, 3`;
  return filas
    .map((f) => ({
      empresa: f.empresa ?? '(perfil sin empresa)',
      perfil_id: f.perfil_id,
      perfil: f.perfil ?? f.perfil_id,
      usuarios_activos: Number(f.usuarios_activos),
      faltan: ALTAS_RAPIDAS.filter((a) => !(f.tiene ?? []).includes(`${a.codigo}@${a.modulo}`)).map(
        (a) => `${a.codigo} (${a.modulo}) → "${a.boton}" deshabilitado`,
      ),
    }))
    .filter((f) => f.faltan.length > 0);
}

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

/** INSERT de los privilegios que faltan a un perfil, sin duplicar filas (no hay índice único). */
function sqlAsignar(perfilId: string, privilegios: 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 submodulos s ON s.id = pr.submodulo_id',
    `  JOIN modulos m ON m.id = s.modulo_id AND m.codigo = ${literal(MODULO)}`,
    ` WHERE pr.codigo IN (${privilegios.map(literal).join(', ')})`,
    '   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 imprimir(
  perfiles: PerfilIncompleto[],
  soloLectura: PerfilIncompleto[],
  usuarios: UsuarioSinOperar[],
  sinAltas: PerfilSinAltas[],
) {
  console.log(`Revisión de permisos de Facturas de compra (solo lectura) — ${new Date().toISOString()}\n`);

  console.log(
    `1. Perfiles con privilegios de ${MODULO} a los que les falta, en el módulo ${MODULO} (lo que mira PermissionGuard), ${PRIVILEGIO_VER} o, si operan ${MODULO} (acción ${ACCIONES_OPERAR.join('/')}), alguno de ${PRIVILEGIOS.join(', ')}: ${perfiles.length}`,
  );
  const enOtroModulo = perfiles.filter((f) => f.en_otro_modulo.length > 0).length;
  if (enOtroModulo) {
    console.log(
      `   Ojo: ${enOtroModulo} de ellos tienen privilegios de Facturas grabados con otro modulo_id. La pantalla (login) los cuenta como ${MODULO} y muestra los botones, pero el backend responde 403.`,
    );
  }
  for (const [empresa, filas] of porEmpresa(perfiles)) {
    console.log(`   ${empresa}`);
    for (const f of filas) {
      const otro = f.en_otro_modulo.length
        ? `; grabados en otro módulo (el guard no los acepta) [${f.en_otro_modulo.join(', ')}]`
        : '';
      console.log(
        `     - ${f.perfil} (${f.perfil_id}, ${f.usuarios_activos} usuario(s) activo(s) no superadmin): tiene [${f.tiene.join(', ')}], faltan [${f.faltan.join(', ')}]${otro}`,
      );
    }
  }

  console.log(
    `\n   Informativo: perfiles que no operan ${MODULO} (ninguna acción ${ACCIONES_OPERAR.join('/')}: solo consultan, exportan, aprueban, pagan, programan, importan o anulan en otros circuitos: anular una factura pide _ELIMINAR, no ANULAR), a los que les corresponde solo ${PRIVILEGIO_VER}: ${soloLectura.length}`,
  );
  for (const [empresa, filas] of porEmpresa(soloLectura)) {
    console.log(`   ${empresa}`);
    for (const f of filas) {
      console.log(
        `     - ${f.perfil} (${f.perfil_id}, ${f.usuarios_activos} usuario(s) activo(s) no superadmin): acciones en ${MODULO} [${f.acciones.join(', ')}]; tiene [${f.tiene.join(', ')}]`,
      );
    }
  }

  console.log(
    `\n2. Usuarios que crearon o editaron compras en ${DIAS_COMPRAS} días sin ${PRIVILEGIOS_OPERAR.join(' o ')}: ${usuarios.length}`,
  );
  for (const [empresa, filas] of porEmpresa(usuarios)) {
    console.log(`   ${empresa}`);
    for (const f of filas) {
      const perfiles = f.perfiles.length ? f.perfiles.map((p) => p.perfil).join(', ') : 'sin perfil asignado';
      console.log(
        `     - ${f.usuario} (${f.usuario_id}): ${f.compras} compra(s); faltan [${f.faltan.join(', ')}]; perfiles: ${perfiles}`,
      );
    }
  }

  console.log(
    `\n3. Informativo: perfiles con ${PRIVILEGIO_CREAR} sin alguna de las altas rápidas (verán el botón deshabilitado con la razón): ${sinAltas.length}`,
  );
  for (const [empresa, filas] of porEmpresa(sinAltas)) {
    console.log(`   ${empresa}`);
    for (const f of filas) {
      console.log(
        `     - ${f.perfil} (${f.perfil_id}, ${f.usuarios_activos} usuario(s) activo(s)): ${f.faltan.join('; ')}`,
      );
    }
  }

  // A (recomendado): los mismos privilegios que el perfil ya tiene, grabados con el módulo
  // que mira el guard. No le da a nadie algo que no tenía.
  const realinear = perfiles.flatMap((f) => {
    const codigos = privilegiosRealineables(f);
    return codigos.length
      ? [sqlAsignar(f.perfil_id, codigos, `${f.empresa} · perfil ${f.perfil} (realinear a ${MODULO})`)]
      : [];
  });
  // B: CREAR/EDITAR para quien ya crea o edita compras. Solo en los perfiles del usuario que
  // ya operan Compras (no en un "Solo Lectura" de otra área).
  const operarCompras = usuarios.flatMap((u) =>
    u.perfiles
      .filter((p) => p.operaCompras)
      .map((p) =>
        sqlAsignar(p.id, u.faltan, `${u.empresa} · ${u.usuario} · perfil ${p.perfil} (crea o edita compras)`),
      ),
  );
  // C: privilegios que el perfil nunca tuvo. Un "Solo Lectura" sin CREAR suele ser lo buscado.
  const nuevos = perfiles.flatMap((f) => {
    const realineables = privilegiosRealineables(f);
    const codigos = f.faltan.filter((c) => !realineables.includes(c));
    return codigos.length
      ? [sqlAsignar(f.perfil_id, codigos, `${f.empresa} · perfil ${f.perfil} (privilegio nuevo)`)]
      : [];
  });

  if (!realinear.length && !operarCompras.length && !nuevos.length) {
    console.log('\nNo hace falta asignar nada.');
    return;
  }
  console.log('\n-- SQL de asignación (NO se ejecutó; revisarlo y aplicarlo a mano).');
  if (realinear.length) {
    console.log(
      `-- A. Recomendado: no da privilegios nuevos; realinea al módulo ${MODULO}, que es el que mira el guard.`,
    );
    console.log('BEGIN;');
    console.log(realinear.join('\n\n'));
    console.log('COMMIT;');
  }
  imprimirComentado(
    `B. ${PRIVILEGIOS_OPERAR.join(' / ')} (privilegios nuevos) para quien ya crea o edita compras, solo en sus perfiles que operan Compras.`,
    operarCompras,
  );
  imprimirComentado('C. Privilegios que el perfil nunca tuvo: descomentar solo los que correspondan.', nuevos);
}

/** Bloque de sentencias que dan privilegios nuevos: se imprime comentado para decidirlo una por una. */
function imprimirComentado(titulo: string, sentencias: string[]) {
  if (!sentencias.length) return;
  console.log(`\n-- ${titulo}`);
  console.log(sentencias.map((sql) => sql.replace(/^/gm, '-- ')).join('\n\n'));
}

/** Los privilegios que faltan en el módulo del guard pero el perfil ya tiene en otro módulo. */
function privilegiosRealineables(f: PerfilIncompleto): string[] {
  const enOtro = f.en_otro_modulo.map((texto) => texto.split(' (')[0]);
  return f.faltan.filter((c) => enOtro.includes(c));
}

async function main() {
  const { perfiles, usuarios, sinAltas } = await prisma.$transaction(async (tx) => {
    await tx.$executeRawUnsafe('SET TRANSACTION READ ONLY');
    return {
      perfiles: await perfilesCompras(tx),
      usuarios: await usuariosSinOperar(tx),
      sinAltas: await perfilesSinAltasRapidas(tx),
    };
  });
  imprimir(
    perfiles.filter((f) => f.faltan.length > 0),
    perfiles.filter((f) => !f.opera_escritura),
    usuarios,
    sinAltas,
  );
}

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