import { BadRequestException } from '@nestjs/common';
import { GUARDS_METADATA } from '@nestjs/common/constants';
import { REQUIRE_PERMISSION_KEY } from 'src/auth/decorators/require-permission.decorator';
import { REQUIRE_SUBMODULO_KEY } from 'src/auth/decorators/require-submodulo.decorator';
import { AlgunPrivilegioGuard, REQUIRE_ALGUN_PRIVILEGIO_KEY } from 'src/auth/guards/algun-privilegio.guard';
import { PermissionGuard } from 'src/auth/guards/permission.guard';
import { SubmoduloGuard } from 'src/auth/guards/submodulo.guard';
import { SuperadminGuard } from 'src/auth/guards/superadmin.guard';
import { PERFILES_SISTEMA_SEED, SEGURIDAD_SEED } from 'src/seguridad/seeds/seguridad.seed-data';
import { PrivilegioSelector, resolverSelectores } from 'src/seguridad/seeds/selectores';
import { SuscripcionesController } from './suscripciones.controller';
import { PRIVILEGIOS_PAGAR_SUSCRIPCION, PRIVILEGIOS_VER_PAGOS_SUSCRIPCION } from './privilegios-suscripcion';
import { SuscripcionesService } from './suscripciones.service';

/**
 * C0 › `/suscripciones`. Antes todas sus rutas pedían solo sesión: cualquier usuario de la holding (un cajero) validaba
 * comprobantes, activaba addons o registraba pagos manuales de las subsidiarias; cualquiera disparaba el cron global de
 * vencimientos; y `holding/comprobantes/:id/documento` devolvía el comprobante de CUALQUIER empresa con el id.
 *
 * - Subsidiaria (Configuración › Mi suscripción y la pantalla de empresa bloqueada): ver pagos y subir comprobantes con
 *   `AlgunPrivilegioGuard`, que NO mira la suscripción: una empresa vencida o bloqueada tiene que poder pagar.
 * - Holding (Suscripciones › Validar comprobantes, Gestión de módulos): PLAN_SUSCRIPCION + submódulo SUS_PLAN +
 *   SUS_PLA_PLAN_VER para leer y SUS_PLA_PLAN_EDITAR para gestionar (la ruta del front ya pide SUS_PLA_PLAN_VER). Qué
 *   suscripción puede tocar lo sigue decidiendo el servicio (`puedeGestionar`: solo una empresa superior).
 * - Cron manual: solo superadmin.
 * - Quedan con sesión a propósito: `mi-suscripcion` y `mis-submodulos-activos` (arranque del menú y pantalla de empresa
 *   bloqueada, siempre la propia empresa) y `preview-primer-cobro` (cálculo de fechas sin datos).
 */
type M = keyof SuscripcionesController;
const handler = (m: string) => Object.getOwnPropertyDescriptor(SuscripcionesController.prototype, m)!.value as object;
const guardsDe = (m: string) => [...(Reflect.getMetadata(GUARDS_METADATA, SuscripcionesController) ?? []), ...(Reflect.getMetadata(GUARDS_METADATA, handler(m)) ?? [])];
const meta = (k: string, m: string) => Reflect.getMetadata(k, handler(m));

const ABIERTAS: M[] = ['previewPrimerCobro', 'getMiSuscripcion', 'getMisSubmodulosActivos'];
const VER_PAGOS: M[] = ['getHistorialPagos', 'getDocumentoComprobante'];
const PAGAR: M[] = ['createComprobante'];
const HOLDING_VER: M[] = ['getComprobantesPendientes', 'getDocumentoComprobanteHolding', 'getAddonsSuscripcionHolding', 'getSubmodulosIncluidosSuscripcionHolding'];
const HOLDING_EDITAR: M[] = [
  'validarComprobante',
  'rechazarComprobante',
  'updateAddonsSuscripcionHolding',
  'updateSubmodulosIncluidosSuscripcionHolding',
  'updateSubmodulosSueltosSuscripcionHolding',
  'registrarPagoManual',
];
const SUPERADMIN: M[] = ['verificarVencimientosManual'];

const privilegios: PrivilegioSelector[] = SEGURIDAD_SEED.flatMap((m) =>
  m.submodulos.flatMap((s) => s.privilegios.map((p) => ({ id: p.codigo, codigo: p.codigo, accion: p.accion, submodulos: { codigo: s.codigo, modulo_id: m.codigo } }))),
);
const modulos = SEGURIDAD_SEED.map((m) => ({ id: m.codigo, codigo: m.codigo }));
const delPerfil = (nombre: string) => new Set(resolverSelectores(PERFILES_SISTEMA_SEED.find((x) => x.perfil === nombre)!.selectores, privilegios, modulos));

describe('C0: permisos de /suscripciones', () => {
  it('cada ruta del controller está clasificada', () => {
    const rutas = Object.getOwnPropertyNames(SuscripcionesController.prototype).filter((m) => m !== 'constructor');
    expect(rutas.sort()).toEqual([...ABIERTAS, ...VER_PAGOS, ...PAGAR, ...HOLDING_VER, ...HOLDING_EDITAR, ...SUPERADMIN].sort());
  });

  it.each(ABIERTAS)('%s queda con sesión', (m) => {
    expect(meta(REQUIRE_PERMISSION_KEY, m)).toBeUndefined();
    expect(meta(REQUIRE_ALGUN_PRIVILEGIO_KEY, m)).toBeUndefined();
  });

  it.each(VER_PAGOS)('%s (subsidiaria) pide alguno de los de ver la suscripción, sin mirar si está vencida', (m) => {
    expect(meta(REQUIRE_ALGUN_PRIVILEGIO_KEY, m)).toEqual(PRIVILEGIOS_VER_PAGOS_SUSCRIPCION);
    expect(guardsDe(m)).toContain(AlgunPrivilegioGuard);
    expect(guardsDe(m)).not.toContain(PermissionGuard);
  });

  it.each(PAGAR)('%s (subir comprobante) pide alguno de los de pagar, sin mirar si está vencida', (m) => {
    expect(meta(REQUIRE_ALGUN_PRIVILEGIO_KEY, m)).toEqual(PRIVILEGIOS_PAGAR_SUSCRIPCION);
    expect(guardsDe(m)).toContain(AlgunPrivilegioGuard);
    expect(guardsDe(m)).not.toContain(PermissionGuard);
  });

  it.each([...HOLDING_VER.map((m) => [m, 'SUS_PLA_PLAN_VER']), ...HOLDING_EDITAR.map((m) => [m, 'SUS_PLA_PLAN_EDITAR'])])(
    '%s (holding) pide PLAN_SUSCRIPCION + SUS_PLAN + %s',
    (m, priv) => {
      expect(meta(REQUIRE_PERMISSION_KEY, m)).toEqual({ modulo: 'PLAN_SUSCRIPCION', privilegio: priv });
      expect(meta(REQUIRE_SUBMODULO_KEY, m)).toBe('SUS_PLAN');
      expect(guardsDe(m)).toEqual(expect.arrayContaining([PermissionGuard, SubmoduloGuard]));
    },
  );

  it.each(SUPERADMIN)('%s (cron global) es solo superadmin', (m) => {
    expect(guardsDe(m)).toContain(SuperadminGuard);
  });

  it('los privilegios de las listas existen en el seed', () => {
    const codigos = new Set(privilegios.map((p) => p.codigo));
    expect([...PRIVILEGIOS_VER_PAGOS_SUSCRIPCION, ...PRIVILEGIOS_PAGAR_SUSCRIPCION].filter((c) => !codigos.has(c))).toEqual([]);
  });

  /** perfil → [ve sus pagos, sube comprobante, gestiona como holding] */
  const TABLA: Record<string, [boolean, boolean, boolean]> = {
    Administrador: [true, true, true],
    Supervisor: [true, false, false],
    'Solo Lectura': [true, false, false],
  };
  it.each(PERFILES_SISTEMA_SEED.map((p) => p.perfil))('perfil de fábrica %s', (perfil) => {
    const suyos = delPerfil(perfil);
    const esperado = TABLA[perfil] ?? [false, false, false];
    expect([
      PRIVILEGIOS_VER_PAGOS_SUSCRIPCION.some((c) => suyos.has(c)),
      PRIVILEGIOS_PAGAR_SUSCRIPCION.some((c) => suyos.has(c)),
      suyos.has('SUS_PLA_PLAN_EDITAR'),
    ]).toEqual(esperado);
  });
});

describe('documento de comprobante por la ruta de la holding', () => {
  const padres: Record<string, string | null> = { holding: null, kety: 'holding', ajena: null };
  const servicio = (empresaComprobante: string) => {
    const s = Object.create(SuscripcionesService.prototype) as any;
    s.prisma = {
      comprobante_pago_recibidos: {
        findUnique: jest.fn().mockResolvedValue({ id: 'c1', documento: Buffer.from('x'), mime_type: 'application/pdf', empresa_id: empresaComprobante, created_at: null }),
      },
      empresas: { findUnique: jest.fn(async ({ where }: any) => (where.id in padres ? { parent_id: padres[where.id] } : null)) },
    };
    return s as SuscripcionesService;
  };

  it('la holding ve el de su subsidiaria', async () => {
    await expect(servicio('kety').getDocumentoComprobante('c1', 'holding', true)).resolves.toMatchObject({ mimeType: 'application/pdf' });
  });

  it('no ve el de una empresa que no es de su red', async () => {
    await expect(servicio('ajena').getDocumentoComprobante('c1', 'holding', true)).rejects.toBeInstanceOf(BadRequestException);
  });
});
