import { ArgumentMetadata, ParseUUIDPipe, RequestMethod, ValidationPipe } from '@nestjs/common';
import { ROUTE_ARGS_METADATA } from '@nestjs/common/constants';
import { CuentaPagoGastoQueryDto } from './dto/cuenta-pago-gasto-query.dto';
import { METHOD_METADATA, PATH_METADATA } from '@nestjs/common/constants';
import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { REQUIRE_PERMISSION_KEY } from '../auth/decorators/require-permission.decorator';
import { AnularGastoDto } from './dto/anular-gasto.dto';
import { CreateGastoDto } from './dto/create-gasto.dto';
import { UpdateGastoDto } from './dto/update-gasto.dto';
import { GastosController } from './gastos.controller';

describe('GastosController', () => {
  const proto = GastosController.prototype as any;

  it('anular pide TES_GAS_GASTO_ANULAR', () => {
    expect(Reflect.getMetadata(PATH_METADATA, proto.anular)).toBe(':id/anular');
    expect(Reflect.getMetadata(METHOD_METADATA, proto.anular)).toBe(RequestMethod.PATCH);
    expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, proto.anular)).toEqual({
      modulo: 'COMPRAS',
      privilegio: 'TES_GAS_GASTO_ANULAR',
    });
  });

  it('anular sin motivo → 400 (DTO); el motivo se recorta', async () => {
    expect((await validate(plainToInstance(AnularGastoDto, {}))).map((e) => e.property)).toEqual(['motivo']);
    expect((await validate(plainToInstance(AnularGastoDto, { motivo: '   ' }))).map((e) => e.property)).toEqual([
      'motivo',
    ]);
    const ok = plainToInstance(AnularGastoDto, { motivo: '  Cargado por error ' });
    expect(await validate(ok)).toEqual([]);
    expect(ok.motivo).toBe('Cargado por error');
  });

  it('GET tipos sin RequirePermission (solo JWT)', () => {
    expect(Reflect.getMetadata(PATH_METADATA, proto.listarTipos)).toBe('tipos');
    expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, proto.listarTipos)).toBeUndefined();
  });

  it('GET :id sigue pidiendo TES_GAS_GASTO_VER', () => {
    expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, proto.findOne)).toEqual({
      modulo: 'COMPRAS',
      privilegio: 'TES_GAS_GASTO_VER',
    });
  });

  it('GET cuenta-pago pide TES_GAS_GASTO_VER y se declara antes de :id', () => {
    expect(Reflect.getMetadata(PATH_METADATA, proto.cuentaPago)).toBe('cuenta-pago');
    expect(Reflect.getMetadata(METHOD_METADATA, proto.cuentaPago)).toBe(RequestMethod.GET);
    expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, proto.cuentaPago)).toEqual({
      modulo: 'COMPRAS',
      privilegio: 'TES_GAS_GASTO_VER',
    });
    // Nest registra las rutas en el orden en que se declaran los métodos.
    const metodos = Object.getOwnPropertyNames(proto);
    expect(metodos.indexOf('cuentaPago')).toBeGreaterThanOrEqual(0);
    expect(metodos.indexOf('cuentaPago')).toBeLessThan(metodos.indexOf('findOne'));
  });

  /** Los pipes de un parámetro de ruta (`@Param('id', …)`) según la metadata de Nest. */
  const pipesDe = (metodo: string, nombre: string) => {
    const args = Reflect.getMetadata(ROUTE_ARGS_METADATA, GastosController, metodo) ?? {};
    const arg = Object.values(args).find((a: any) => a.data === nombre) as any;
    return arg?.pipes ?? [];
  };

  // M1: un id mal formado es 400, no un P2023 de Prisma que sale como 500.
  it.each(['findOne', 'update', 'anular', 'reintentarContabilidad', 'reintentarTesoreria', 'actualizarTipo', 'eliminarTipo'])(
    '%s valida :id con ParseUUIDPipe',
    (metodo) => {
      expect(pipesDe(metodo, 'id').some((p: any) => p === ParseUUIDPipe || p instanceof ParseUUIDPipe)).toBe(true);
    },
  );

  // M2
  const validar = (cls: any, value: object) =>
    new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true }).transform(value, {
      type: 'query',
      metatype: cls,
    } as ArgumentMetadata);

  it('listado: estado fuera de registrado/parcial/pagada/anulado → 400', async () => {
    const [pipe] = pipesDe('findAll', 'estado');
    const meta = { type: 'query', data: 'estado' } as ArgumentMetadata;
    await expect(Promise.resolve().then(() => pipe.transform('borrado', meta))).rejects.toBeDefined();
    await expect(Promise.resolve(pipe.transform('pagada', meta))).resolves.toBe('pagada');
    await expect(Promise.resolve(pipe.transform(undefined, meta))).resolves.toBeUndefined();
  });

  it('cuenta-pago: cotización que no es un número positivo → 400', async () => {
    await expect(validar(CuentaPagoGastoQueryDto, { cotizacion: 'abc' })).rejects.toBeDefined();
    await expect(validar(CuentaPagoGastoQueryDto, { cotizacion: '-1' })).rejects.toBeDefined();
    await expect(validar(CuentaPagoGastoQueryDto, { moneda_id: 'no-uuid' })).rejects.toBeDefined();
    await expect(validar(CuentaPagoGastoQueryDto, { cotizacion: '7312.5' })).resolves.toMatchObject({ cotizacion: 7312.5 });
  });

  describe('GET config', () => {
    it('pide TES_GAS_GASTO_VER (no el de órdenes de pago) y se declara antes de :id', () => {
      expect(Reflect.getMetadata(PATH_METADATA, proto.config)).toBe('config');
      expect(Reflect.getMetadata(METHOD_METADATA, proto.config)).toBe(RequestMethod.GET);
      expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, proto.config)).toEqual({
        modulo: 'COMPRAS',
        privilegio: 'TES_GAS_GASTO_VER',
      });
      const metodos = Object.getOwnPropertyNames(proto);
      expect(metodos.indexOf('config')).toBeGreaterThanOrEqual(0);
      expect(metodos.indexOf('config')).toBeLessThan(metodos.indexOf('findOne'));
    });

    it('devuelve las reglas que usan la pantalla y su guía, leídas con la misma lectura de /pagos-proveedor/config', async () => {
      const getConfigCompras = jest.fn().mockResolvedValue({
        modo_flujo_compra: 'requisicion_opcional',
        permitir_editar_gasto_pagado: true,
        incluir_contado_en_orden_pago: false,
        habilitar_requisicion_compra: true,
        habilitar_orden_compra: false,
        habilitar_recepcion_compra: true,
        habilitar_orden_pago: true,
        permitir_pago_parcial: false,
        generar_cxp_automatico: true,
        requiere_aprobacion: true,
      });
      const controller = new GastosController({} as any, { getConfigCompras } as any);
      await expect(controller.config({ empresa_id: 'emp-1' } as any)).resolves.toEqual({
        modo_flujo_compra: 'requisicion_opcional',
        permitir_editar_gasto_pagado: true,
        incluir_contado_en_orden_pago: false,
        habilitar_requisicion_compra: true,
        habilitar_orden_compra: false,
        habilitar_recepcion_compra: true,
        habilitar_orden_pago: true,
        permitir_pago_parcial: false,
        generar_cxp_automatico: true,
      });
      expect(getConfigCompras).toHaveBeenCalledWith('emp-1');
    });
  });

  describe('fecha_vencimiento (cabecera del alta y de la edición)', () => {
    const erroresDeCabecera = async (cls: any, valor: string) => {
      const dto = plainToInstance(cls, { cabecera: { fecha_vencimiento: valor } }) as any;
      const errores = await validate(dto);
      return (errores.find((e) => e.property === 'cabecera')?.children ?? []).filter(
        (e) => e.property === 'fecha_vencimiento',
      );
    };
    it.each([CreateGastoDto, UpdateGastoDto])('%p: 2026-02-30 es inválida (400)', async (cls) => {
      expect(await erroresDeCabecera(cls, '2026-02-30')).toHaveLength(1);
    });
    it.each([CreateGastoDto, UpdateGastoDto])('%p: una fecha real pasa', async (cls) => {
      expect(await erroresDeCabecera(cls, '2026-02-28')).toHaveLength(0);
    });
  });
});
