import { BadRequestException, PipeTransform, RequestMethod } from '@nestjs/common';
import { GUARDS_METADATA, METHOD_METADATA, PATH_METADATA, ROUTE_ARGS_METADATA } from '@nestjs/common/constants';
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 { RequisicionesController } from './requisiciones.controller';

/**
 * Pipes reales del controller (no los del servicio): un `estado` u `origen_tipo` desconocido → 400 antes de llegar
 * al servicio (F10e), y las rutas fijas de lectura declaradas antes de `:id` con el permiso de VER.
 */
describe('RequisicionesController - lecturas', () => {
  const proto = RequisicionesController.prototype as any;
  const metodos = Object.getOwnPropertyNames(proto);

  const pipesDe = (handler: string, nombre: string): PipeTransform[] => {
    const args = Reflect.getMetadata(ROUTE_ARGS_METADATA, RequisicionesController, handler) as Record<string, { data?: string; pipes: PipeTransform[] }>;
    const arg = Object.values(args).find((a) => a.data === nombre);
    if (!arg) throw new Error(`${handler} no tiene @Query('${nombre}')`);
    return arg.pipes;
  };
  const pasa = async (handler: string, nombre: string, valor: unknown) => {
    let v = valor;
    for (const p of pipesDe(handler, nombre)) v = await p.transform(v, { type: 'query', data: nombre });
    return v;
  };

  describe('findAll: filtros con ParseEnumPipe', () => {
    it('estado=foo → 400; las siete claves y la ausencia pasan', async () => {
      for (const e of ['borrador', 'pendiente_aprobacion', 'aprobada', 'ejecutada_parcial', 'ejecutada_total', 'rechazada', 'cancelada']) {
        await expect(pasa('findAll', 'estado', e)).resolves.toBe(e);
      }
      await expect(pasa('findAll', 'estado', undefined)).resolves.toBeUndefined();
      await expect(pasa('findAll', 'estado', 'foo')).rejects.toBeInstanceOf(BadRequestException);
      await expect(pasa('findAll', 'estado', 'Aprobada')).rejects.toBeInstanceOf(BadRequestException);
    });

    it('origen_tipo=foo → 400; compra y gasto pasan', async () => {
      await expect(pasa('findAll', 'origen_tipo', 'compra')).resolves.toBe('compra');
      await expect(pasa('findAll', 'origen_tipo', 'gasto')).resolves.toBe('gasto');
      await expect(pasa('findAll', 'origen_tipo', undefined)).resolves.toBeUndefined();
      await expect(pasa('findAll', 'origen_tipo', 'foo')).rejects.toBeInstanceOf(BadRequestException);
    });

    it('sucursal_id con UUID y esperan_mi_aprobacion booleano; otro valor → 400', async () => {
      await expect(pasa('findAll', 'sucursal_id', 'aaaaaaaa-0000-4000-8000-000000000001')).resolves.toBe('aaaaaaaa-0000-4000-8000-000000000001');
      await expect(pasa('findAll', 'sucursal_id', 'no-uuid')).rejects.toBeInstanceOf(BadRequestException);
      await expect(pasa('findAll', 'esperan_mi_aprobacion', 'true')).resolves.toBe(true);
      await expect(pasa('findAll', 'esperan_mi_aprobacion', undefined)).resolves.toBeUndefined();
      await expect(pasa('findAll', 'esperan_mi_aprobacion', 'quizas')).rejects.toBeInstanceOf(BadRequestException);
    });

    it('pasa empresa, usuario y los filtros al servicio', async () => {
      const findAll = jest.fn().mockResolvedValue({ data: [] });
      const controller = new RequisicionesController({ findAll } as any, {} as any);
      await controller.findAll({ empresa_id: 'emp-1', id: 'u-1' } as any, '2', '10', 'compra', 'aprobada', '2026-10-01', '2026-10-31', 'tinta', 'suc-1', true);
      expect(findAll).toHaveBeenCalledWith('emp-1', 'u-1', {
        page: '2',
        limit: '10',
        origen_tipo: 'compra',
        estado: 'aprobada',
        fecha_desde: '2026-10-01',
        fecha_hasta: '2026-10-31',
        search: 'tinta',
        sucursal_id: 'suc-1',
        esperan_mi_aprobacion: true,
      });
    });
  });

  describe('contexto y niveles-aplicables', () => {
    it.each(['contexto', 'nivelesAplicables'])('%s es GET, va antes de :id y pide CMP_REQ_REQUISICION_VER', (handler) => {
      expect(Reflect.getMetadata(METHOD_METADATA, proto[handler])).toBe(RequestMethod.GET);
      expect(Reflect.getMetadata(PATH_METADATA, proto[handler])).toBe(handler === 'contexto' ? 'contexto' : 'niveles-aplicables');
      expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, proto[handler])).toEqual({ modulo: 'COMPRAS', privilegio: 'CMP_REQ_REQUISICION_VER' });
      expect(Reflect.getMetadata(GUARDS_METADATA, RequisicionesController)).toContain(PermissionGuard);
      expect(metodos.indexOf(handler)).toBeLessThan(metodos.indexOf('findOne'));
    });

    it('niveles-aplicables: origen con ParseEnumPipe (otro valor → 400) y monto numérico', async () => {
      await expect(pasa('nivelesAplicables', 'origen', 'gasto')).resolves.toBe('gasto');
      await expect(pasa('nivelesAplicables', 'origen', 'foo')).rejects.toBeInstanceOf(BadRequestException);
      await expect(pasa('nivelesAplicables', 'origen', undefined)).rejects.toBeInstanceOf(BadRequestException);
      await expect(pasa('nivelesAplicables', 'monto', '1000000.5')).resolves.toBe(1000000.5);
      await expect(pasa('nivelesAplicables', 'monto', 'mucho')).rejects.toBeInstanceOf(BadRequestException);
      await expect(pasa('nivelesAplicables', 'monto', undefined)).rejects.toBeInstanceOf(BadRequestException);
    });

    it('pasan empresa y usuario al servicio', async () => {
      const contexto = jest.fn().mockResolvedValue({ habilitada: true });
      const nivelesAplicables = jest.fn().mockResolvedValue([]);
      const controller = new RequisicionesController({ contexto, nivelesAplicables } as any, {} as any);
      await controller.contexto({ empresa_id: 'emp-1', id: 'u-1' } as any);
      expect(contexto).toHaveBeenCalledWith('emp-1', 'u-1');
      await controller.nivelesAplicables({ empresa_id: 'emp-1', id: 'u-1' } as any, 'compra', 500);
      expect(nivelesAplicables).toHaveBeenCalledWith('emp-1', 'compra', 500);
    });
  });
});

/** Permisos por acción (T11, spec punto 2 y R3): ningún handler queda solo con JWT. */
describe('RequisicionesController - permisos', () => {
  const proto = RequisicionesController.prototype as any;
  const handlers = Object.getOwnPropertyNames(proto).filter((m) => m !== 'constructor' && typeof proto[m] === 'function');
  const permiso = (h: string) => Reflect.getMetadata(REQUIRE_PERMISSION_KEY, proto[h]);
  const VER = { modulo: 'COMPRAS', privilegio: 'CMP_REQ_REQUISICION_VER' };
  const req = (a: string) => ({ modulo: 'COMPRAS', privilegio: `CMP_REQ_REQUISICION_${a}` });
  const oc = { modulo: 'COMPRAS', privilegio: 'CMP_OC_ORDEN_COMPRA_CREAR' };
  const cfg = (a: string) => ({ modulo: 'ADMINISTRACION', privilegio: `ADM_CCFG_CONFIG_${a}` });

  it('la clase pide el submódulo COMP_REQUISICIONES (con SubmoduloGuard y PermissionGuard)', () => {
    expect(Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, RequisicionesController)).toBe('COMP_REQUISICIONES');
    const guards = Reflect.getMetadata(GUARDS_METADATA, RequisicionesController) as unknown[];
    expect(guards).toEqual(expect.arrayContaining([SubmoduloGuard, PermissionGuard]));
  });

  it.each([
    ['findAll', VER],
    ['findOne', VER],
    ['contexto', VER],
    ['nivelesAplicables', VER],
    ['create', req('CREAR')],
    ['update', req('EDITAR')],
    ['enviarAprobacion', req('CREAR')],
    ['aprobar', req('APROBAR')],
    ['rechazar', req('APROBAR')],
    ['cancelar', req('ELIMINAR')],
    ['lineasParaOc', oc],
    ['crearOrdenCompra', oc],
    ['generarOrdenesCompraDistribuidas', oc],
    ['getAprobacionesConfig', cfg('VER')],
    ['getPresupuestos', cfg('VER')],
    ['putAprobacionesConfig', cfg('EDITAR')],
    ['putPresupuestos', cfg('EDITAR')],
    ['aplicarConfigRecomendada', cfg('EDITAR')],
    ['getAprobadores', cfg('VER')],
    ['asignarAprobadores', cfg('EDITAR')],
  ])('%s declara su permiso', (handler, esperado) => {
    expect(permiso(handler)).toEqual(esperado);
  });

  it('aprobadores: rutas propias, con el submódulo de la clase y antes de cualquier ruta con :id', () => {
    expect(Reflect.getMetadata(PATH_METADATA, proto.getAprobadores)).toBe('aprobaciones-config/aprobadores');
    expect(Reflect.getMetadata(PATH_METADATA, proto.asignarAprobadores)).toBe('aprobaciones-config/aprobadores');
    expect(Reflect.getMetadata(METHOD_METADATA, proto.getAprobadores)).toBe(RequestMethod.GET);
    expect(Reflect.getMetadata(METHOD_METADATA, proto.asignarAprobadores)).toBe(RequestMethod.PUT);
    expect(Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, RequisicionesController)).toBe('COMP_REQUISICIONES');
    const orden = Object.getOwnPropertyNames(proto);
    expect(orden.indexOf('getAprobadores')).toBeLessThan(orden.indexOf('findOne'));
    expect(orden.indexOf('asignarAprobadores')).toBeLessThan(orden.indexOf('findOne'));
  });

  it('referenciaProducto pide _CREAR o _EDITAR con AlgunPrivilegioGuard', () => {
    expect(Reflect.getMetadata(REQUIRE_ALGUN_PRIVILEGIO_KEY, proto.referenciaProducto)).toEqual([
      'CMP_REQ_REQUISICION_CREAR',
      'CMP_REQ_REQUISICION_EDITAR',
    ]);
    expect(Reflect.getMetadata(GUARDS_METADATA, proto.referenciaProducto)).toContain(AlgunPrivilegioGuard);
  });

  it('ningún handler queda solo con JWT (R3): todos tienen permiso o lista de privilegios', () => {
    const sinPermiso = handlers.filter(
      (h) => !permiso(h) && !Reflect.getMetadata(REQUIRE_ALGUN_PRIVILEGIO_KEY, proto[h]),
    );
    expect(sinPermiso).toEqual([]);
    expect(handlers.length).toBeGreaterThanOrEqual(19);
  });

  it('ningún handler agrega guards propios salvo referenciaProducto (solo AlgunPrivilegioGuard): los de la clase valen', () => {
    const conGuards = handlers
      .map((h) => [h, (Reflect.getMetadata(GUARDS_METADATA, proto[h]) as unknown[] | undefined) ?? []] as const)
      .filter(([, g]) => g.length > 0);
    expect(conGuards).toEqual([['referenciaProducto', [AlgunPrivilegioGuard]]]);
  });
});
