/**
 * Revisión de SOLO LECTURA antes de que la pantalla nueva de Gastos oculte botones por
 * permiso (plan 2026-10-19-gastos, Task 10). Corre en una transacción READ ONLY: no
 * puede escribir nada.
 *
 * Imprime por empresa:
 *  1. Perfiles con algún privilegio activo del submódulo TES_GASTOS a los que les falta
 *     alguno de TES_GAS_GASTO_VER / _CREAR / _ANULAR / _IMPORTAR (módulo COMPRAS, como lo
 *     mira PermissionGuard).
 *  2. Usuarios que crearon gastos desde una requisición en los últimos 90 días y no tienen
 *     TES_GAS_GASTO_CREAR (el endpoint `POST /requisiciones/:id/crear-gasto` ahora lo pide).
 *     Los superadmin pasan el guard y no se listan.
 *  3. Empresas con gastos TRANSFERENCIA y sin un medio de pago activo para la empresa
 *     (empresa_medio_pago.activo; medio_pago no tiene columna de activo) cuya descripción
 *     contenga "transfer".
 * 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 a quien ya crea gastos desde requisiciones, solo en sus perfiles que
 *     ya operan Gastos;
 *  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-gastos.ts
 */
import 'dotenv/config';
import { Prisma, PrismaClient } from '@prisma/client';

const MODULO = 'COMPRAS';
const SUBMODULO = 'TES_GASTOS';
const PRIVILEGIOS = ['TES_GAS_GASTO_VER', 'TES_GAS_GASTO_CREAR', 'TES_GAS_GASTO_ANULAR', 'TES_GAS_GASTO_IMPORTAR'];
const PRIVILEGIO_CREAR = 'TES_GAS_GASTO_CREAR';
const DIAS_REQUISICION = 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[];
  faltan: string[];
};
type UsuarioSinCrear = {
  empresa: string;
  usuario_id: string;
  usuario: string;
  gastos: number;
  /** `operaGastos`: el perfil ya tiene algún privilegio activo de TES_GASTOS (en cualquier módulo). */
  perfiles: { id: string; perfil: string; operaGastos: boolean }[];
};
type EmpresaSinTransfer = { empresa: string; gastos_transferencia: number };

const prisma = new PrismaClient();

async function perfilesIncompletos(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;
    }[]
  >`
    SELECT COALESCE(e.razon_social, e.id::text) AS empresa, pf.id AS perfil_id, pf.perfil,
           (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)) AS usuarios_activos,
           ARRAY_AGG(DISTINCT pr.codigo) FILTER (WHERE m.codigo = ${MODULO}) AS tiene,
           ARRAY_AGG(DISTINCT pr.codigo || ' (' || COALESCE(m.codigo, 'sin módulo') || ')')
             FILTER (WHERE m.codigo IS DISTINCT FROM ${MODULO}) AS en_otro_modulo
      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 AND s.codigo = ${SUBMODULO}
      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
     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])),
        faltan: PRIVILEGIOS.filter((p) => !tiene.includes(p)),
      };
    })
    .filter((f) => f.faltan.length > 0);
}

async function usuariosSinCrear(tx: Prisma.TransactionClient): Promise<UsuarioSinCrear[]> {
  const filas = await tx.$queryRaw<{ empresa: string; usuario_id: string; usuario: string; gastos: bigint }[]>`
    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 gastos
      FROM gasto_cab g
      JOIN usuario u ON u.id = g.usuario_id
      JOIN empresas e ON e.id = g.empresa_id
     WHERE g.requisicion_id IS NOT NULL
       AND g.created_at >= NOW() - (${DIAS_REQUISICION} * INTERVAL '1 day')
       AND COALESCE(u.is_superadmin, false) = false
       AND NOT EXISTS (
         SELECT 1
           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 = ${PRIVILEGIO_CREAR}
           JOIN modulos m ON m.id = pp.modulo_id AND m.codigo = ${MODULO}
          WHERE up.user_id = u.id)
     GROUP BY e.razon_social, e.id, u.id
     ORDER BY 1, 3`;
  const resultado: UsuarioSinCrear[] = [];
  for (const f of filas) {
    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, privilegios: { submodulos: { codigo: SUBMODULO } } } },
              },
            },
          },
        },
      },
    });
    resultado.push({
      empresa: f.empresa,
      usuario_id: f.usuario_id,
      usuario: f.usuario,
      gastos: Number(f.gastos),
      perfiles: perfiles.flatMap((p) =>
        p.perfiles
          ? [
              {
                id: p.perfiles.id,
                perfil: p.perfiles.perfil ?? p.perfiles.id,
                operaGastos: p.perfiles._count.perfiles_privilegios > 0,
              },
            ]
          : [],
      ),
    });
  }
  return resultado;
}

async function empresasSinMedioTransferencia(tx: Prisma.TransactionClient): Promise<EmpresaSinTransfer[]> {
  const filas = await tx.$queryRaw<{ empresa: string; gastos_transferencia: bigint }[]>`
    SELECT COALESCE(e.razon_social, e.id::text) AS empresa, COUNT(*) AS gastos_transferencia
      FROM gasto_cab g
      JOIN empresas e ON e.id = g.empresa_id
     WHERE g.forma_pago = 'TRANSFERENCIA'
       AND NOT EXISTS (
         SELECT 1
           FROM empresa_medio_pago emp
           JOIN medio_pago mp ON mp.id = emp.medio_pago_id
          WHERE emp.empresa_id = g.empresa_id
            -- medio_pago no tiene columna de activo: el único "activo" es el de la empresa.
            AND COALESCE(emp.activo, true) = true
            AND mp.descripcion ILIKE '%transfer%')
     GROUP BY e.razon_social, e.id
     ORDER BY 1`;
  return filas.map((f) => ({ empresa: f.empresa, gastos_transferencia: Number(f.gastos_transferencia) }));
}

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[], usuarios: UsuarioSinCrear[], empresas: EmpresaSinTransfer[]) {
  console.log(`Revisión de permisos de Gastos (solo lectura) — ${new Date().toISOString()}\n`);

  console.log(
    `1. Perfiles con algún privilegio de ${SUBMODULO} a los que les falta alguno de ${PRIVILEGIOS.join(', ')} en el módulo ${MODULO} (lo que mira PermissionGuard): ${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 ${SUBMODULO} 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(
    `\n2. Usuarios que crearon gastos desde una requisición en ${DIAS_REQUISICION} días sin ${PRIVILEGIO_CREAR}: ${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.gastos} gasto(s); perfiles: ${perfiles}`);
    }
  }

  console.log(`\n3. Empresas con gastos TRANSFERENCIA y sin un medio de pago activo "transfer…": ${empresas.length}`);
  for (const f of empresas) console.log(`   - ${f.empresa}: ${f.gastos_transferencia} gasto(s) TRANSFERENCIA`);

  // 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 es un privilegio nuevo para quien ya crea gastos desde requisiciones. Solo en
  // los perfiles del usuario que ya operan Gastos (no en un "Solo Lectura" de otra área).
  const crearDesdeRequisicion = usuarios.flatMap((u) =>
    u.perfiles
      .filter((p) => p.operaGastos)
      .map((p) =>
        sqlAsignar(
          p.id,
          [PRIVILEGIO_CREAR],
          `${u.empresa} · ${u.usuario} · perfil ${p.perfil} (crea gastos desde requisiciones)`,
        ),
      ),
  );
  // 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 && !crearDesdeRequisicion.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. ${PRIVILEGIO_CREAR} (privilegio nuevo) para quien ya crea gastos desde requisiciones, solo en sus perfiles que operan Gastos.`,
    crearDesdeRequisicion,
  );
  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, empresas } = await prisma.$transaction(async (tx) => {
    await tx.$executeRawUnsafe('SET TRANSACTION READ ONLY');
    return {
      perfiles: await perfilesIncompletos(tx),
      usuarios: await usuariosSinCrear(tx),
      empresas: await empresasSinMedioTransferencia(tx),
    };
  });
  imprimir(perfiles, usuarios, empresas);
}

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