import { GUARDS_METADATA, METHOD_METADATA } from '@nestjs/common/constants';
import { REQUIRE_MODULE_KEY } from 'src/auth/decorators/require-module.decorator';
import { REQUIRE_PERMISSION_KEY } from 'src/auth/decorators/require-permission.decorator';
import { REQUIRE_SUBMODULO_KEY } from 'src/auth/decorators/require-submodulo.decorator';
import { PrivilegioDeModuloGuard, REQUIRE_PRIVILEGIO_DE_MODULO_KEY } from 'src/auth/guards/algun-privilegio.guard';
import { ModuleGuard } from 'src/auth/guards/module.guard';
import { PermissionGuard } from 'src/auth/guards/permission.guard';
import { SubmoduloGuard } from 'src/auth/guards/submodulo.guard';
import { ThrottlerGuard } from '@nestjs/throttler';
import { GimnasioModule } from './gimnasio.module';

/**
 * Guardas de todo `/gimnasio/*` (AGENTS.md: módulo + submódulo + permiso en cada endpoint, el back es la autoridad).
 * El mapa fija, por método, el submódulo y el privilegio que exige: una ruta nueva sin entrar acá hace fallar el test,
 * y cambiar un permiso obliga a cambiarlo a propósito. «Sin permiso» y «sin submódulo» los rechazan PermissionGuard y
 * SubmoduloGuard (sus specs en src/auth/guards); «otra empresa»: cada handler pasa al servicio la empresa del token,
 * nunca una que venga en el pedido, y cada consulta filtra por ella (gimnasio-multitenancy.spec.ts).
 */
type Ctl = { prototype: object; name: string };
const CONTROLLERS: Ctl[] = Reflect.getMetadata('controllers', GimnasioModule);
const porNombre = (n: string) => CONTROLLERS.find((c) => c.name === n) as Ctl;
const rutasDe = (C: Ctl) =>
  Object.getOwnPropertyNames(C.prototype).filter(
    (m) =>
      m !== 'constructor' &&
      Reflect.getMetadata(METHOD_METADATA, (C.prototype as Record<string, object>)[m]) !== undefined,
  );
const h = (C: Ctl, m: string) => (C.prototype as Record<string, object>)[m];
const guards = (C: Ctl, m: string) => [
  ...(Reflect.getMetadata(GUARDS_METADATA, C) ?? []),
  ...(Reflect.getMetadata(GUARDS_METADATA, h(C, m)) ?? []),
];
const meta = (C: Ctl, m: string, k: string) => Reflect.getMetadata(k, h(C, m)) ?? Reflect.getMetadata(k, C);

/** controller → método → [submódulo, privilegio] */
const PRIVADAS: Record<string, Record<string, [string, string]>> = {
  ImportarSociosController: {
    importar: ['GYM_SOCIOS', 'GYM_SOC_SOCIO_IMPORTAR'],
    preview: ['GYM_SOCIOS', 'GYM_SOC_SOCIO_IMPORTAR'],
  },
  CatalogoGymController: {
    actualizarActividad: ['GYM_CATALOGO', 'GYM_CAT_ACTIVIDAD_EDITAR'],
    actualizarPlan: ['GYM_CATALOGO', 'GYM_CAT_PLAN_EDITAR'],
    actualizarServicio: ['GYM_CATALOGO', 'GYM_CAT_SERVICIO_EDITAR'],
    crearActividad: ['GYM_CATALOGO', 'GYM_CAT_ACTIVIDAD_CREAR'],
    crearPlan: ['GYM_CATALOGO', 'GYM_CAT_PLAN_CREAR'],
    crearServicio: ['GYM_CATALOGO', 'GYM_CAT_SERVICIO_CREAR'],
    darDeBajaActividad: ['GYM_CATALOGO', 'GYM_CAT_ACTIVIDAD_ELIMINAR'],
    darDeBajaPlan: ['GYM_CATALOGO', 'GYM_CAT_PLAN_ELIMINAR'],
    darDeBajaServicio: ['GYM_CATALOGO', 'GYM_CAT_SERVICIO_ELIMINAR'],
    reactivarActividad: ['GYM_CATALOGO', 'GYM_CAT_ACTIVIDAD_ELIMINAR'],
    reactivarPlan: ['GYM_CATALOGO', 'GYM_CAT_PLAN_ELIMINAR'],
    reactivarServicio: ['GYM_CATALOGO', 'GYM_CAT_SERVICIO_ELIMINAR'],
    detallePlan: ['GYM_CATALOGO', 'GYM_CAT_PLAN_VER'],
    listarActividades: ['GYM_CATALOGO', 'GYM_CAT_ACTIVIDAD_VER'],
    listarPlanes: ['GYM_CATALOGO', 'GYM_CAT_PLAN_VER'],
    listarServicios: ['GYM_CATALOGO', 'GYM_CAT_SERVICIO_VER'],
  },
  ClasesGymController: {
    actualizarHorario: ['GYM_CLASES', 'GYM_CLA_HORARIO_EDITAR'],
    agenda: ['GYM_CLASES', 'GYM_CLA_AGENDA_VER'],
    asistencia: ['GYM_CLASES', 'GYM_CLA_RESERVA_CREAR'],
    bajaHorario: ['GYM_CLASES', 'GYM_CLA_HORARIO_EDITAR'],
    buscarSocio: ['GYM_CLASES', 'GYM_CLA_RESERVA_CREAR'],
    cancelarReserva: ['GYM_CLASES', 'GYM_CLA_RESERVA_CREAR'],
    cancelarSesion: ['GYM_CLASES', 'GYM_CLA_HORARIO_EDITAR'],
    crearHorario: ['GYM_CLASES', 'GYM_CLA_HORARIO_EDITAR'],
    listarHorarios: ['GYM_CLASES', 'GYM_CLA_AGENDA_VER'],
    reservar: ['GYM_CLASES', 'GYM_CLA_RESERVA_CREAR'],
    reservasDelSocio: ['GYM_CLASES', 'GYM_CLA_AGENDA_VER'],
    sesion: ['GYM_CLASES', 'GYM_CLA_AGENDA_VER'],
  },
  ConfigGymController: {
    actualizar: ['GYM_CONFIG', 'GYM_CFG_PARAMETROS_EDITAR'],
    obtener: ['GYM_CONFIG', 'GYM_CFG_PARAMETROS_VER'],
    textosAvisos: ['GYM_CONFIG', 'GYM_CFG_PARAMETROS_VER'],
    vistaPreviaAviso: ['GYM_CONFIG', 'GYM_CFG_PARAMETROS_VER'],
    pruebaAviso: ['GYM_CONFIG', 'GYM_CFG_PARAMETROS_EDITAR'],
  },
  RecepcionGymController: {
    buscar: ['GYM_RECEPCION', 'GYM_REC_ACCESO_CREAR'],
    crearTablet: ['GYM_RECEPCION', 'GYM_REC_ACCESO_AUTORIZAR'],
    forzar: ['GYM_RECEPCION', 'GYM_REC_ACCESO_AUTORIZAR'],
    ingresos: ['GYM_RECEPCION', 'GYM_REC_ACCESO_CREAR'],
    listarTablets: ['GYM_RECEPCION', 'GYM_REC_ACCESO_CREAR'],
    revocarTablet: ['GYM_RECEPCION', 'GYM_REC_ACCESO_AUTORIZAR'],
    validar: ['GYM_RECEPCION', 'GYM_REC_ACCESO_CREAR'],
  },
  ReportesGymController: {
    avisosNoEntregados: ['GYM_REPORTES', 'GYM_REP_REPORTE_VER'],
    membresiasSinFactura: ['GYM_REPORTES', 'GYM_REP_REPORTE_VER'],
    ingresosVencidos: ['GYM_REPORTES', 'GYM_REP_REPORTE_VER'],
    tablero: ['GYM_REPORTES', 'GYM_REP_TABLERO_VER'],
  },
  SedesGymController: {
    actualizar: ['GYM_CONFIG', 'GYM_CFG_SEDE_EDITAR'],
    actualizarSala: ['GYM_CONFIG', 'GYM_CFG_SEDE_EDITAR'],
    crear: ['GYM_CONFIG', 'GYM_CFG_SEDE_CREAR'],
    crearSala: ['GYM_CONFIG', 'GYM_CFG_SEDE_CREAR'],
    darDeBaja: ['GYM_CONFIG', 'GYM_CFG_SEDE_ELIMINAR'],
    darDeBajaSala: ['GYM_CONFIG', 'GYM_CFG_SEDE_ELIMINAR'],
    reactivar: ['GYM_CONFIG', 'GYM_CFG_SEDE_ELIMINAR'],
    reactivarSala: ['GYM_CONFIG', 'GYM_CFG_SEDE_ELIMINAR'],
    listar: ['GYM_CONFIG', 'GYM_CFG_SEDE_VER'],
    opciones: ['GYM_CONFIG', 'GYM_CFG_SEDE_VER'],
  },
  SociosGymController: {
    actualizar: ['GYM_SOCIOS', 'GYM_SOC_SOCIO_EDITAR'],
    anularMembresia: ['GYM_SOCIOS', 'GYM_SOC_MEMBRESIA_ANULAR'],
    vigencia: ['GYM_SOCIOS', 'GYM_SOC_MEMBRESIA_ASIGNAR'],
    asignarMembresia: ['GYM_SOCIOS', 'GYM_SOC_MEMBRESIA_ASIGNAR'],
    cambiarEstado: ['GYM_SOCIOS', 'GYM_SOC_SOCIO_ELIMINAR'],
    crear: ['GYM_SOCIOS', 'GYM_SOC_SOCIO_CREAR'],
    detalle: ['GYM_SOCIOS', 'GYM_SOC_SOCIO_VER'],
    listar: ['GYM_SOCIOS', 'GYM_SOC_SOCIO_VER'],
    procesarAvisos: ['GYM_SOCIOS', 'GYM_SOC_AVISO_ENVIAR'],
    qrLink: ['GYM_SOCIOS', 'GYM_SOC_SOCIO_VER'],
    qrRegenerar: ['GYM_SOCIOS', 'GYM_SOC_SOCIO_EDITAR'],
    reenviarAviso: ['GYM_SOCIOS', 'GYM_SOC_AVISO_ENVIAR'],
  },
  StaffGymController: {
    actualizar: ['GYM_STAFF', 'GYM_STF_STAFF_EDITAR'],
    crear: ['GYM_STAFF', 'GYM_STF_STAFF_CREAR'],
    darDeBaja: ['GYM_STAFF', 'GYM_STF_STAFF_ELIMINAR'],
    reactivar: ['GYM_STAFF', 'GYM_STF_STAFF_ELIMINAR'],
    empleados: ['GYM_STAFF', 'GYM_STF_STAFF_VER'],
    listar: ['GYM_STAFF', 'GYM_STF_STAFF_VER'],
  },
  TurnosGymController: {
    actualizar: ['GYM_TURNOS', 'GYM_TUR_TURNO_CREAR'],
    actualizarItem: ['GYM_TURNOS', 'GYM_TUR_TURNO_CREAR'],
    agenda: ['GYM_TURNOS', 'GYM_TUR_AGENDA_VER'],
    agregarItem: ['GYM_TURNOS', 'GYM_TUR_TURNO_CREAR'],
    cancelar: ['GYM_TURNOS', 'GYM_TUR_TURNO_CREAR'],
    cortesia: ['GYM_TURNOS', 'GYM_TUR_CORTESIA'],
    crear: ['GYM_TURNOS', 'GYM_TUR_TURNO_CREAR'],
    delCliente: ['GYM_TURNOS', 'GYM_TUR_AGENDA_VER'],
    marcar: ['GYM_TURNOS', 'GYM_TUR_TURNO_CREAR'],
    pendientes: ['GYM_TURNOS', 'GYM_TUR_TURNO_COBRAR'],
    quitarItem: ['GYM_TURNOS', 'GYM_TUR_TURNO_CREAR'],
    turno: ['GYM_TURNOS', 'GYM_TUR_AGENDA_VER'],
  },
  LiquidacionesGymController: {
    anular: ['GYM_LIQUIDACIONES', 'GYM_LIQ_LIQUIDACION_APROBAR'],
    aprobar: ['GYM_LIQUIDACIONES', 'GYM_LIQ_LIQUIDACION_APROBAR'],
    bajaTarifa: ['GYM_LIQUIDACIONES', 'GYM_LIQ_TARIFA_EDITAR'],
    crear: ['GYM_LIQUIDACIONES', 'GYM_LIQ_LIQUIDACION_CREAR'],
    crearTarifa: ['GYM_LIQUIDACIONES', 'GYM_LIQ_TARIFA_EDITAR'],
    detalle: ['GYM_LIQUIDACIONES', 'GYM_LIQ_LIQUIDACION_VER'],
    listar: ['GYM_LIQUIDACIONES', 'GYM_LIQ_LIQUIDACION_VER'],
    pagada: ['GYM_LIQUIDACIONES', 'GYM_LIQ_LIQUIDACION_APROBAR'],
    previsualizar: ['GYM_LIQUIDACIONES', 'GYM_LIQ_LIQUIDACION_CREAR'],
    tarifas: ['GYM_LIQUIDACIONES', 'GYM_LIQ_TARIFA_VER'],
  },
};
/** Sin sesión: código de tablet o firma HMAC, con throttle; nunca devuelven ids (CLAUDE.md del módulo, regla 10). */
const PUBLICAS = [
  'AvisosPublicoController.baja',
  'AvisosPublicoController.miAcceso',
  'TabletPublicoController.info',
  'TabletPublicoController.ingreso',
  'TabletPublicoController.logo',
];

describe('Guardas de /gimnasio', () => {
  const casos = Object.entries(PRIVADAS).flatMap(([c, rutas]) =>
    Object.entries(rutas).map(([m, [sub, priv]]) => [`${c}.${m}`, sub, priv] as const),
  );

  it.each(casos)('%s pide el submódulo %s y %s', (ruta, sub, priv) => {
    const [c, m] = ruta.split('.');
    const C = porNombre(c);
    expect(meta(C, m, REQUIRE_SUBMODULO_KEY)).toBe(sub);
    expect(meta(C, m, REQUIRE_PERMISSION_KEY)).toEqual({ modulo: 'GIMNASIO', privilegio: priv });
    const g = guards(C, m);
    expect(g).toEqual(expect.arrayContaining([SubmoduloGuard, PermissionGuard]));
    expect(g).toHaveLength(3); // JWT + submódulo + permiso
  });

  it.each(casos)('%s le pasa al servicio la empresa del token', async (ruta) => {
    const [c, m] = ruta.split('.');
    const C = porNombre(c) as unknown as new (...deps: unknown[]) => Record<string, (...a: unknown[]) => unknown>;
    const llamadas: unknown[][] = [];
    // Cualquier dependencia: cada método registra sus argumentos y devuelve algo neutro.
    const dep = new Proxy(
      {},
      {
        get:
          () =>
          (...args: unknown[]) => (llamadas.push(args), Promise.resolve({})),
      },
    );
    const ctl = new C(...Array(8).fill(dep));
    // El mismo objeto hace de usuario, de DTO y de parámetro: si un handler leyera la empresa del pedido, la que
    // llegaría al servicio sería OTRA_EMPRESA.
    const arg = { id: 'USR', empresa_id: 'EMPRESA_TOKEN', body_empresa_id: 'OTRA_EMPRESA' };
    await ctl[m](...Array(6).fill(arg));
    expect(llamadas.some((a) => a.includes('EMPRESA_TOKEN'))).toBe(true);
  });

  it('opciones: módulo GIMNASIO contratado y algún privilegio del módulo', () => {
    const C = porNombre('OpcionesGymController');
    expect(meta(C, 'obtener', REQUIRE_MODULE_KEY)).toBe('GIMNASIO');
    expect(meta(C, 'obtener', REQUIRE_PRIVILEGIO_DE_MODULO_KEY)).toBe('GIMNASIO');
    expect(guards(C, 'obtener')).toEqual(expect.arrayContaining([ModuleGuard, PrivilegioDeModuloGuard]));
  });

  it.each(PUBLICAS)('%s es pública con throttle', (ruta) => {
    const [c, m] = ruta.split('.');
    expect(guards(porNombre(c), m)).toEqual([ThrottlerGuard]);
  });

  it('el mapa cubre todas las rutas de todos los controllers del módulo', () => {
    const todas = CONTROLLERS.flatMap((C) => rutasDe(C).map((m) => `${C.name}.${m}`)).sort();
    const mapa = [...casos.map(([r]) => r), ...PUBLICAS, 'OpcionesGymController.obtener'].sort();
    expect(todas).toEqual(mapa);
  });
});
