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 { PermissionGuard } from 'src/auth/guards/permission.guard';
import { SubmoduloGuard } from 'src/auth/guards/submodulo.guard';
import { SuperadminGuard } from 'src/auth/guards/superadmin.guard';
import { CondicionesPagoController } from 'src/condiciones-pago/condiciones-pago.controller';
import { MonedasController } from 'src/monedas/monedas.controller';
import { PERFILES_SISTEMA_SEED, SEGURIDAD_SEED } from 'src/seguridad/seeds/seguridad.seed-data';
import { PrivilegioSelector, resolverSelectores } from 'src/seguridad/seeds/selectores';
import { MedioPagoController } from './medio-pago.controller';

/**
 * Configuración › Monedas, Medios de pago y Condiciones de pago (C0). Antes TODAS sus escrituras pedían solo sesión:
 * cualquier cajero cambiaba los medios de cobro de la empresa, borraba condiciones de crédito o agregaba monedas, y
 * cualquier usuario de cualquier empresa tocaba el catálogo GLOBAL de monedas.
 *
 * Criterio (llamadores relevados en el ERP, la app móvil y la tienda):
 * - Escrituras de la empresa: módulo ADMINISTRACION + submódulo de la pantalla + el permiso que ya pide el front
 *   (PagosConfigTab usa ADM_CONDPAGO_* / ADM_MEDPAGO_EDITAR; Monedas no tiene permiso propio de configuración y usa el
 *   de su submódulo, ADM_COTIZ_REGISTRAR, el mismo que ya pedían las cotizaciones).
 * - Catálogo global de monedas (crear, editar, activar): solo superadmin; ninguna pantalla lo llama.
 * - Lecturas: quedan con sesión a propósito, las usan formularios de todos (POS, cobros, OP, presupuestos, viáticos,
 *   inmobiliario, la app móvil: `GET /medio-pago/activos`, `/condiciones-pago`, `/monedas/empresa/configuracion`,
 *   `/monedas/cotizaciones/ultima/:id`, el aviso diario de cotización del Layout).
 */
type Ctl = { prototype: object; name: string };
const handler = (c: Ctl, m: string) => {
  const h = Object.getOwnPropertyDescriptor(c.prototype, m)?.value as object | undefined;
  if (!h) throw new Error(`${c.name}.${m} no existe`);
  return h;
};
const guardsDe = (c: Ctl, m: string) => [...(Reflect.getMetadata(GUARDS_METADATA, c) ?? []), ...(Reflect.getMetadata(GUARDS_METADATA, handler(c, m)) ?? [])];
const permisoDe = (c: Ctl, m: string) => Reflect.getMetadata(REQUIRE_PERMISSION_KEY, handler(c, m)) ?? Reflect.getMetadata(REQUIRE_PERMISSION_KEY, c);
const submoduloDe = (c: Ctl, m: string) => Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, handler(c, m)) ?? Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, c);

/** [controller, método, submódulo, privilegio] */
const ESCRITURAS: Array<[Ctl, string, string, string]> = [
  [MonedasController, 'addEmpresaMoneda', 'ADM_MONEDA_COTIZACION', 'ADM_COTIZ_REGISTRAR'],
  [MonedasController, 'updateEmpresaMoneda', 'ADM_MONEDA_COTIZACION', 'ADM_COTIZ_REGISTRAR'],
  [MonedasController, 'removeEmpresaMoneda', 'ADM_MONEDA_COTIZACION', 'ADM_COTIZ_REGISTRAR'],
  [MonedasController, 'createCotizacion', 'ADM_MONEDA_COTIZACION', 'ADM_COTIZ_REGISTRAR'],
  [MonedasController, 'updateCotizacion', 'ADM_MONEDA_COTIZACION', 'ADM_COTIZ_REGISTRAR'],
  [MonedasController, 'deleteCotizacion', 'ADM_MONEDA_COTIZACION', 'ADM_COTIZ_REGISTRAR'],
  [MedioPagoController, 'toggle', 'ADM_MEDIOS_PAGO', 'ADM_MEDPAGO_EDITAR'],
  [MedioPagoController, 'bulkToggle', 'ADM_MEDIOS_PAGO', 'ADM_MEDPAGO_EDITAR'],
  [CondicionesPagoController, 'create', 'ADM_COND_PAGO', 'ADM_CONDPAGO_CREAR'],
  [CondicionesPagoController, 'update', 'ADM_COND_PAGO', 'ADM_CONDPAGO_EDITAR'],
  [CondicionesPagoController, 'remove', 'ADM_COND_PAGO', 'ADM_CONDPAGO_ELIMINAR'],
];

const CATALOGO_GLOBAL: Array<[Ctl, string]> = [
  [MonedasController, 'create'],
  [MonedasController, 'update'],
  [MonedasController, 'toggle'],
];

const LECTURAS_ABIERTAS: Array<[Ctl, string]> = [
  [MonedasController, 'findAll'],
  [MonedasController, 'getCotizacionVigente'],
  [MonedasController, 'findOne'],
  [MonedasController, 'findEmpresaMonedas'],
  [MonedasController, 'findCotizaciones'],
  [MonedasController, 'findCotizacionByFecha'],
  [MonedasController, 'cotizacionesPendientesHoy'],
  [MonedasController, 'getUltimaCotizacion'],
  [MedioPagoController, 'findAllCatalogo'],
  [MedioPagoController, 'findByEmpresa'],
  [MedioPagoController, 'findActiveByEmpresa'],
  [CondicionesPagoController, 'findAll'],
  [CondicionesPagoController, 'findOne'],
];

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) => {
  const p = PERFILES_SISTEMA_SEED.find((x) => x.perfil === nombre);
  if (!p) throw new Error(`no existe el perfil ${nombre}`);
  return new Set(resolverSelectores(p.selectores, privilegios, modulos));
};

/** Perfiles de fábrica que configuran (monedas, medios, condiciones): solo el Administrador. */
const CONFIGURAN = new Set(['Administrador']);

describe('C0: permisos de Monedas, Medios de pago y Condiciones de pago', () => {
  it.each(ESCRITURAS)('%p.%s exige ADMINISTRACION + submódulo %s + %s', (c, m, sub, priv) => {
    expect(permisoDe(c, m)).toEqual({ modulo: 'ADMINISTRACION', privilegio: priv });
    expect(submoduloDe(c, m)).toBe(sub);
    expect(guardsDe(c, m)).toEqual(expect.arrayContaining([PermissionGuard, SubmoduloGuard]));
  });

  it('cada privilegio pedido existe en el seed y pertenece al submódulo pedido', () => {
    for (const [, , sub, priv] of ESCRITURAS) {
      expect(privilegios.find((p) => p.codigo === priv)?.submodulos?.codigo).toBe(sub);
    }
  });

  it.each(CATALOGO_GLOBAL)('%p.%s (catálogo global de monedas) es solo superadmin', (c, m) => {
    expect(guardsDe(c, m)).toContain(SuperadminGuard);
  });

  it.each(LECTURAS_ABIERTAS)('%p.%s queda con sesión (lectura de formularios de todos)', (c, m) => {
    expect(permisoDe(c, m)).toBeUndefined();
    expect(guardsDe(c, m)).not.toContain(SuperadminGuard);
  });

  it.each(PERFILES_SISTEMA_SEED.map((p) => p.perfil))('perfil de fábrica %s: configura solo si es Administrador', (perfil) => {
    const suyos = delPerfil(perfil);
    const puede = ESCRITURAS.map(([, , , priv]) => suyos.has(priv));
    expect(puede.every((x) => x === CONFIGURAN.has(perfil))).toBe(true);
  });

  it('GET /condiciones-pago/:id no devuelve la condición de otra empresa', async () => {
    const service = { findOneDeEmpresa: jest.fn().mockResolvedValue({ id: 'c1' }) } as any;
    const controller = new CondicionesPagoController(service);
    await controller.findOne('c1', { empresa_id: 'e1' } as any);
    expect(service.findOneDeEmpresa).toHaveBeenCalledWith('c1', 'e1');
  });
});
