import { RequestMethod } from '@nestjs/common';
import { GUARDS_METADATA, METHOD_METADATA, PATH_METADATA } from '@nestjs/common/constants';
import { REQUIRE_PERMISSION_KEY } from '../auth/decorators/require-permission.decorator';
import { REQUIRE_MODULE_KEY } from '../auth/decorators/require-module.decorator';
import { PrivilegioDeModuloGuard, REQUIRE_PRIVILEGIO_ALTERNATIVO_KEY, REQUIRE_PRIVILEGIO_DE_MODULO_KEY } from '../auth/guards/algun-privilegio.guard';
import { ModuleGuard } from '../auth/guards/module.guard';
import { PermissionGuard } from '../auth/guards/permission.guard';
import { ComprasController } from './compras.controller';

describe('ComprasController', () => {
  const proto = ComprasController.prototype as any;
  const permisoDe = (metodo: string) => Reflect.getMetadata(REQUIRE_PERMISSION_KEY, proto[metodo]);
  const guardsDe = (metodo: string) => Reflect.getMetadata(GUARDS_METADATA, proto[metodo]) ?? [];
  // Nest registra las rutas en el orden en que se declaran los métodos.
  const metodos = Object.getOwnPropertyNames(proto);

  // El controller no tiene guard de clase: sin PermissionGuard en el método, el permiso no se mira.
  const esperarPermiso = (metodo: string, path: string, verbo: RequestMethod, privilegio: string) => {
    expect(Reflect.getMetadata(PATH_METADATA, proto[metodo])).toBe(path);
    expect(Reflect.getMetadata(METHOD_METADATA, proto[metodo])).toBe(verbo);
    expect(permisoDe(metodo)).toEqual({ modulo: 'COMPRAS', privilegio });
    expect(guardsDe(metodo)).toContain(PermissionGuard);
  };

  it('POST pide CMP_FAC_FACTURA_PROV_CREAR', () => {
    esperarPermiso('create', '/', RequestMethod.POST, 'CMP_FAC_FACTURA_PROV_CREAR');
  });

  it('PATCH :id pide CMP_FAC_FACTURA_PROV_EDITAR', () => {
    esperarPermiso('update', ':id', RequestMethod.PATCH, 'CMP_FAC_FACTURA_PROV_EDITAR');
  });

  it('PATCH :id/anular pide CMP_FAC_FACTURA_PROV_ELIMINAR', () => {
    esperarPermiso('anular', ':id/anular', RequestMethod.PATCH, 'CMP_FAC_FACTURA_PROV_ELIMINAR');
  });

  describe('GET config-flujo', () => {
    it('lo lee quien tenga cualquier privilegio de COMPRAS (no un permiso fijo) y se declara antes de :id', () => {
      expect(Reflect.getMetadata(PATH_METADATA, proto.configFlujo)).toBe('config-flujo');
      expect(Reflect.getMetadata(METHOD_METADATA, proto.configFlujo)).toBe(RequestMethod.GET);
      expect(Reflect.getMetadata(REQUIRE_PRIVILEGIO_DE_MODULO_KEY, proto.configFlujo)).toBe('COMPRAS');
      expect(Reflect.getMetadata(REQUIRE_MODULE_KEY, proto.configFlujo)).toBe('COMPRAS');
      expect(guardsDe('configFlujo')).toEqual(expect.arrayContaining([ModuleGuard, PrivilegioDeModuloGuard]));
      expect(guardsDe('configFlujo')).not.toContain(PermissionGuard);
      expect(permisoDe('configFlujo')).toBeUndefined();
      expect(metodos.indexOf('configFlujo')).toBeGreaterThanOrEqual(0);
      expect(metodos.indexOf('configFlujo')).toBeLessThan(metodos.indexOf('findOne'));
    });

    it('devuelve lo que arma ComprasService.getConfigFlujo para la empresa del usuario', async () => {
      const config = {
        modo_flujo_compra: 'directo',
        afectar_stock_en_compra_directa: true,
        habilitar_requisicion_compra: false,
        habilitar_orden_compra: true,
        habilitar_recepcion_compra: true,
        habilitar_matching_3_vias: true,
        generar_cxp_automatico: true,
        habilitar_orden_pago: true,
        incluir_contado_en_orden_pago: false,
        permitir_pago_parcial: false,
        requiere_aprobacion: false,
        usar_workflow: false,
        workflow_obligatorio: false,
      };
      const getConfigFlujo = jest.fn().mockResolvedValue(config);
      const controller = new ComprasController({ getConfigFlujo } as any, {} as any);
      await expect(controller.configFlujo({ empresa_id: 'emp-1' } as any)).resolves.toEqual(config);
      expect(getConfigFlujo).toHaveBeenCalledWith('emp-1');
    });
  });

  describe('borradores', () => {
    const rutas: Array<[string, string, RequestMethod]> = [
      ['listarBorradores', 'borradores', RequestMethod.GET],
      ['crearBorrador', 'borradores', RequestMethod.POST],
      ['obtenerBorrador', 'borradores/:borradorId', RequestMethod.GET],
      ['actualizarBorrador', 'borradores/:borradorId', RequestMethod.PUT],
      ['descartarBorrador', 'borradores/:borradorId', RequestMethod.DELETE],
    ];

    it.each(rutas)('%s (%s) pide CMP_FAC_FACTURA_PROV_CREAR', (metodo, path, verbo) => {
      esperarPermiso(metodo, path, verbo, 'CMP_FAC_FACTURA_PROV_CREAR');
    });

    it('las cinco rutas se declaran antes de :id (GET, PATCH y demás), así ":id" no captura "borradores"', () => {
      const primeraConId = Math.min(
        ...['findOne', 'update', 'anular', 'reintentarContabilidad'].map((m) => metodos.indexOf(m)),
      );
      rutas.forEach(([metodo]) => {
        expect(metodos.indexOf(metodo)).toBeGreaterThanOrEqual(0);
        expect(metodos.indexOf(metodo)).toBeLessThan(primeraConId);
      });
    });

    it('pasan empresa y usuario del token al servicio y devuelven su resultado tal cual', async () => {
      const borrador = { id: 'b-1', updated_at: new Date() };
      const servicio = {
        listar: jest.fn().mockResolvedValue([borrador]),
        crear: jest.fn().mockResolvedValue(borrador),
        obtener: jest.fn().mockResolvedValue({ ...borrador, avisos: [] }),
        actualizar: jest.fn().mockResolvedValue(borrador),
        descartar: jest.fn().mockResolvedValue({ id: 'b-1' }),
      };
      const controller = new ComprasController({} as any, servicio as any);
      const user = { empresa_id: 'emp-1', id: 'usr-1' } as any;
      const dto = { datos: {} };

      await expect(controller.listarBorradores(user)).resolves.toEqual([borrador]);
      await expect(controller.crearBorrador(dto, user)).resolves.toBe(borrador);
      await expect(controller.obtenerBorrador('b-1', user)).resolves.toEqual({ ...borrador, avisos: [] });
      await expect(controller.actualizarBorrador('b-1', dto, user)).resolves.toBe(borrador);
      await expect(controller.descartarBorrador('b-1', user)).resolves.toEqual({ id: 'b-1' });
      expect(servicio.listar).toHaveBeenCalledWith('emp-1', 'usr-1');
      expect(servicio.crear).toHaveBeenCalledWith(dto, 'emp-1', 'usr-1');
      expect(servicio.obtener).toHaveBeenCalledWith('b-1', 'emp-1', 'usr-1');
      expect(servicio.actualizar).toHaveBeenCalledWith('b-1', dto, 'emp-1', 'usr-1');
      expect(servicio.descartar).toHaveBeenCalledWith('b-1', 'emp-1', 'usr-1');
    });
  });

  it.each([
    ['findAll', '/'],
    ['findOne', ':id'],
    ['verificarComprobante', 'verificar-comprobante'],
    ['getConfig', 'config'],
    ['searchProveedores', 'proveedores/search'],
    ['getUltimoCostoProveedor', 'ultimo-costo'],
    ['getDashboard', 'dashboard'],
  ])('GET %s (%s) sin RequirePermission (solo JWT)', (metodo, path) => {
    expect(Reflect.getMetadata(PATH_METADATA, proto[metodo])).toBe(path);
    expect(Reflect.getMetadata(METHOD_METADATA, proto[metodo])).toBe(RequestMethod.GET);
    expect(permisoDe(metodo)).toBeUndefined();
  });

  describe('config-moneda (D4)', () => {
    it('GET lo lee cualquier perfil de COMPRAS (Facturas, OC, OP y NC redondean con esto)', () => {
      expect(Reflect.getMetadata(PATH_METADATA, proto.listConfigMoneda)).toBe('config-moneda');
      expect(Reflect.getMetadata(METHOD_METADATA, proto.listConfigMoneda)).toBe(RequestMethod.GET);
      expect(Reflect.getMetadata(REQUIRE_PRIVILEGIO_DE_MODULO_KEY, proto.listConfigMoneda)).toBe('COMPRAS');
      expect(Reflect.getMetadata(REQUIRE_MODULE_KEY, proto.listConfigMoneda)).toBe('COMPRAS');
    });

    it('GET también lo lee quien tenga ADM_CCFG_CONFIG_VER (la pestaña Decimales)', () => {
      expect(Reflect.getMetadata(REQUIRE_PRIVILEGIO_ALTERNATIVO_KEY, proto.listConfigMoneda)).toEqual(['ADM_CCFG_CONFIG_VER']);
      expect(guardsDe('listConfigMoneda')).toContain(PrivilegioDeModuloGuard);
    });

    it('PUT /lote pide ADM_CCFG_CONFIG_EDITAR', () => {
      expect(Reflect.getMetadata(PATH_METADATA, proto.guardarConfigMonedaLote)).toBe('config-moneda/lote');
      expect(Reflect.getMetadata(METHOD_METADATA, proto.guardarConfigMonedaLote)).toBe(RequestMethod.PUT);
      expect(permisoDe('guardarConfigMonedaLote')).toEqual({ modulo: 'ADMINISTRACION', privilegio: 'ADM_CCFG_CONFIG_EDITAR' });
      expect(guardsDe('guardarConfigMonedaLote')).toContain(PermissionGuard);
    });

    it('el PUT y el DELETE sueltos ya no existen (sin guard de permiso, eran una puerta abierta): solo el lote escribe', () => {
      const metodos = Object.getOwnPropertyNames(proto);
      expect(metodos).not.toContain('upsertConfigMoneda');
      expect(metodos).not.toContain('deleteConfigMoneda');
      const rutasDeConfigMoneda = metodos.filter((m) => String(Reflect.getMetadata(PATH_METADATA, proto[m]) ?? '').startsWith('config-moneda'));
      expect(rutasDeConfigMoneda.sort()).toEqual(['guardarConfigMonedaLote', 'listConfigMoneda']);
    });
  });
});
