import { ValidationPipe } from '@nestjs/common';
import { FiltroExtractoDto, FiltroTesMovimientosDto, FiltroTesMovimientosExcelDto } from '../dto/filtro-tes-movimientos.dto';
import { whereMovimientos } from './filtro-movimientos';

const pipe = new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true });
const validar = (query: Record<string, unknown>) => pipe.transform(query, { type: 'query', metatype: FiltroTesMovimientosDto }) as Promise<FiltroTesMovimientosDto>;
const UUID = '11111111-1111-4111-8111-111111111111';

describe('whereMovimientos', () => {
  it('sin filtros → solo la empresa', () => {
    expect(whereMovimientos('emp', {})).toEqual({ empresa_id: 'emp' });
  });

  it('cuentaId, tipo (también TRANSFERENCIA) y estado van tal cual', () => {
    expect(whereMovimientos('emp', { cuentaId: 'c1', tipo: 'TRANSFERENCIA', estado: 'ANULADO' })).toEqual({
      empresa_id: 'emp',
      cuenta_id: 'c1',
      tipo: 'TRANSFERENCIA',
      estado: 'ANULADO',
    });
  });

  it('las fechas arman el rango sobre la fecha calendario', () => {
    expect(whereMovimientos('emp', { fechaDesde: '2026-05-01', fechaHasta: '2026-05-31' }).fecha).toEqual({ gte: new Date('2026-05-01'), lte: new Date('2026-05-31') });
  });

  it('un importe escrito como se muestra suma la condición del monto', () => {
    const where = whereMovimientos('emp', { search: 'Gs. 350.000' });
    expect(where.OR).toEqual([
      { descripcion: { contains: 'Gs. 350.000', mode: 'insensitive' } },
      { referencia: { contains: 'Gs. 350.000', mode: 'insensitive' } },
      { cuenta: { nombre: { contains: 'Gs. 350.000', mode: 'insensitive' } } },
      { monto: 350000 },
    ]);
  });

  it('un texto común busca en descripción, referencia y cuenta, sin monto', () => {
    const where = whereMovimientos('emp', { search: ' boleta ' });
    expect(where.OR).toHaveLength(3);
    expect(JSON.stringify(where.OR)).not.toContain('monto');
    expect(JSON.stringify(where.OR)).toContain('"contains":"boleta"');
  });
});

describe('FiltroTesMovimientosDto', () => {
  it('limit 101 → 400; 100 pasa', async () => {
    await expect(validar({ limit: '101' })).rejects.toBeDefined();
    await expect(validar({ limit: '100' })).resolves.toMatchObject({ limit: 100 });
  });
  it('tipo fuera del enum, cuentaId que no es UUID y page 0 → 400', async () => {
    await expect(validar({ tipo: 'OTRO' })).rejects.toBeDefined();
    await expect(validar({ cuentaId: 'x' })).rejects.toBeDefined();
    await expect(validar({ page: '0' })).rejects.toBeDefined();
    await expect(validar({ estado: 'X' })).rejects.toBeDefined();
    await expect(validar({ fechaDesde: 'ayer' })).rejects.toBeDefined();
    await expect(validar({ search: 'x'.repeat(101) })).rejects.toBeDefined();
  });
  it('lo que manda la pantalla vieja con campos vacíos pasa y llega como undefined (F2)', async () => {
    const f = await validar({ cuentaId: '', tipo: '', estado: '', fechaDesde: '', fechaHasta: '', search: '', page: '', limit: '' });
    expect(f.cuentaId).toBeUndefined();
    expect(f.tipo).toBeUndefined();
    expect(f.estado).toBeUndefined();
    expect(f.fechaDesde).toBeUndefined();
    expect(f.fechaHasta).toBeUndefined();
    expect(f.search).toBeUndefined();
    expect(f.page).toBeUndefined();
    expect(f.limit).toBeUndefined();
    await expect(validar({ cuentaId: 'x' })).rejects.toBeDefined();
  });
  it('un filtro completo y válido pasa con page y limit numéricos', async () => {
    const f = await validar({ cuentaId: UUID, tipo: 'INGRESO', estado: 'CONFIRMADO', fechaDesde: '2026-05-01', page: '2', limit: '50' });
    expect(f).toMatchObject({ cuentaId: UUID, page: 2, limit: 50 });
  });
});

describe('FiltroTesMovimientosExcelDto', () => {
  const validarExcel = (query: Record<string, unknown>) => pipe.transform(query, { type: 'query', metatype: FiltroTesMovimientosExcelDto });
  it('page o limit → 400 (el Excel exporta el filtro entero)', async () => {
    await expect(validarExcel({ page: '1' })).rejects.toBeDefined();
    await expect(validarExcel({ limit: '10' })).rejects.toBeDefined();
  });
  it('"" es sin filtro y un filtro válido pasa; uno inválido no', async () => {
    const f: any = await validarExcel({ cuentaId: '', tipo: '', search: '', fechaDesde: '2026-05-01' });
    expect(f.cuentaId).toBeUndefined();
    expect(f.tipo).toBeUndefined();
    expect(f.fechaDesde).toBe('2026-05-01');
    await expect(validarExcel({ tipo: 'OTRO' })).rejects.toBeDefined();
  });
});

describe('FiltroExtractoDto (M4)', () => {
  const validarExtracto = (query: Record<string, unknown>) => pipe.transform(query, { type: 'query', metatype: FiltroExtractoDto }) as Promise<FiltroExtractoDto>;
  it('cuentaId que no es UUID o fechas inválidas → 400; vacíos pasan como undefined', async () => {
    await expect(validarExtracto({ cuentaId: 'x' })).rejects.toBeDefined();
    await expect(validarExtracto({ cuentaId: UUID, fechaDesde: 'ayer' })).rejects.toBeDefined();
    const f = await validarExtracto({ cuentaId: UUID, fechaDesde: '', fechaHasta: '' });
    expect(f).toMatchObject({ cuentaId: UUID });
    expect(f.fechaDesde).toBeUndefined();
    await expect(validarExtracto({ cuentaId: UUID, fechaDesde: '2026-05-01', fechaHasta: '2026-05-31' })).resolves.toBeDefined();
  });
});
