import { ParseUUIDPipe, RequestMethod } from '@nestjs/common';
import { GUARDS_METADATA, METHOD_METADATA, PATH_METADATA, ROUTE_ARGS_METADATA } from '@nestjs/common/constants';
import { Reflector } from '@nestjs/core';
import { AuthGuard } from '@nestjs/passport';
import { REQUIRE_PERMISSION_KEY } from '../auth/decorators/require-permission.decorator';
import { REQUIRE_SUBMODULO_KEY } from '../auth/decorators/require-submodulo.decorator';
import { AlgunPrivilegioGuard, REQUIRE_ALGUN_PRIVILEGIO_KEY } from '../auth/guards/algun-privilegio.guard';
import { PermissionGuard } from '../auth/guards/permission.guard';
import { SubmoduloGuard } from '../auth/guards/submodulo.guard';
import { RecepcionesCompraController } from './recepciones-compra.controller';

const reflector = new Reflector();
const VER = 'CMP_REC_RECEPCION_VER';
const CREAR = 'CMP_REC_RECEPCION_CREAR';
const EDITAR = 'CMP_REC_RECEPCION_EDITAR';

/** Tabla de Permisos del plan: handler, ruta, verbo y privilegio (uno solo, o alguno de varios). */
const TABLA: Array<[string, string, RequestMethod, string | string[]]> = [
  ['create', '/', RequestMethod.POST, CREAR],
  ['update', ':id', RequestMethod.PATCH, EDITAR],
  ['findAll', '/', RequestMethod.GET, VER],
  ['getConfigFlujo', 'config-flujo', RequestMethod.GET, VER],
  ['ordenesRecepcionables', 'ordenes-recepcionables', RequestMethod.GET, [CREAR, EDITAR]],
  ['ordenRecepcionable', 'ordenes-recepcionables/:id', RequestMethod.GET, [CREAR, EDITAR]],
  ['depositos', 'depositos', RequestMethod.GET, [CREAR, EDITAR]],
  ['getHistorial', ':id/historial', RequestMethod.GET, VER],
  ['findOne', ':id', RequestMethod.GET, VER],
  ['anular', ':id/anular', RequestMethod.PATCH, 'CMP_REC_RECEPCION_ANULAR'],
];

describe('RecepcionesCompraController: permisos', () => {
  const proto = RecepcionesCompraController.prototype as any;
  const handlers = Object.getOwnPropertyNames(proto).filter((m) => m !== 'constructor');

  it('la clase pide COMP_RECEPCIONES, con JWT, SubmoduloGuard y PermissionGuard', () => {
    const guards = reflector.get(GUARDS_METADATA, RecepcionesCompraController) ?? [];
    expect(guards).toHaveLength(3);
    expect(guards[0]).toBe(AuthGuard('jwt'));
    expect(guards).toContain(SubmoduloGuard);
    expect(guards).toContain(PermissionGuard);
    expect(reflector.get(REQUIRE_SUBMODULO_KEY, RecepcionesCompraController)).toBe('COMP_RECEPCIONES');
  });

  it('la tabla cubre todos los handlers del controller (ninguno queda sin permiso)', () => {
    expect([...handlers].sort()).toEqual(TABLA.map(([m]) => m).sort());
  });

  it.each(TABLA)('cada handler declara su permiso: %s (%s)', (metodo, path, verbo, privilegio) => {
    expect(reflector.get(PATH_METADATA, proto[metodo])).toBe(path);
    expect(reflector.get(METHOD_METADATA, proto[metodo])).toBe(verbo);
    if (Array.isArray(privilegio)) {
      // «Alguno de»: sin RequirePermission y con AlgunPrivilegioGuard en el método (se suma a los de la clase).
      expect(reflector.get(REQUIRE_PERMISSION_KEY, proto[metodo])).toBeUndefined();
      expect(reflector.get(REQUIRE_ALGUN_PRIVILEGIO_KEY, proto[metodo])).toEqual(privilegio);
      expect(reflector.get(GUARDS_METADATA, proto[metodo])).toEqual([AlgunPrivilegioGuard]);
    } else {
      expect(reflector.get(REQUIRE_PERMISSION_KEY, proto[metodo])).toEqual({ modulo: 'COMPRAS', privilegio });
      expect(reflector.get(REQUIRE_ALGUN_PRIVILEGIO_KEY, proto[metodo])).toBeUndefined();
      expect(reflector.get(GUARDS_METADATA, proto[metodo])).toBeUndefined();
    }
  });

  it('las rutas fijas se declaran antes de :id', () => {
    const primeraConId = handlers.indexOf('getHistorial');
    for (const fija of ['getConfigFlujo', 'ordenesRecepcionables', 'ordenRecepcionable', 'depositos']) {
      expect(handlers.indexOf(fija)).toBeLessThan(primeraConId);
    }
  });

  it('findOne y getHistorial pasan el usuario al servicio (alcance por sucursal)', () => {
    const service = { findOne: jest.fn(), getHistorial: jest.fn() };
    const controller = new RecepcionesCompraController(service as any);
    const user = { id: 'u-1', empresa_id: 'emp-1' } as any;
    controller.findOne('rec-1', user);
    controller.getHistorial('rec-1', user);
    expect(service.findOne).toHaveBeenCalledWith('rec-1', 'emp-1', 'u-1');
    expect(service.getHistorial).toHaveBeenCalledWith('rec-1', 'emp-1', 'u-1');
  });

  it.each(['update', 'ordenRecepcionable', 'getHistorial', 'findOne', 'anular'])(
    ':id con ParseUUIDPipe (400 en vez de 500 con un id que no es uuid): %s',
    (metodo) => {
      const args = Reflect.getMetadata(ROUTE_ARGS_METADATA, RecepcionesCompraController, metodo) ?? {};
      const delId = Object.values(args as Record<string, { data?: string; pipes?: unknown[] }>).find((a) => a.data === 'id');
      expect(delId).toBeDefined();
      expect(delId!.pipes).toContain(ParseUUIDPipe);
    },
  );

  it('?recepcion= de ordenes-recepcionables/:id con ParseUUIDPipe opcional (400 con un id que no es uuid; sin él, sigue)', async () => {
    const args = Reflect.getMetadata(ROUTE_ARGS_METADATA, RecepcionesCompraController, 'ordenRecepcionable') ?? {};
    const query = Object.values(args as Record<string, { data?: string; pipes?: any[] }>).find((a) => a.data === 'recepcion');
    const pipe = query?.pipes?.find((p) => p instanceof ParseUUIDPipe);
    expect(pipe).toBeDefined();
    await expect(pipe.transform(undefined, { type: 'query', data: 'recepcion' })).resolves.toBeUndefined();
    await expect(pipe.transform('no-es-uuid', { type: 'query', data: 'recepcion' })).rejects.toThrow();
  });
});
