import { ValidationPipe } from '@nestjs/common';
import {
  ActualizarLineaConciliacionDto,
  CrearMovimientoDesdeLineaDto,
  FiltroExtractosDto,
  ImportarExtractoDto,
  ImportarExtractoPdfBodyDto,
  LineasDeMovimientosDto,
  MovimientosSinConciliarDto,
} from './tes-conciliacion.dto';

const pipe = new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true });
const UUID = '11111111-1111-4111-8111-111111111111';
const validar = <T>(metatype: new () => T, valor: unknown, type: 'query' | 'body' = 'body') => pipe.transform(valor, { type, metatype }) as Promise<T>;
const x = (n: number) => 'x'.repeat(n);

describe('FiltroExtractosDto', () => {
  it('cuenta_id vacío → undefined', async () => {
    expect((await validar(FiltroExtractosDto, { cuenta_id: '' }, 'query')).cuenta_id).toBeUndefined();
  });
  it('cuenta_id que no es UUID → 400', async () => {
    await expect(validar(FiltroExtractosDto, { cuenta_id: 'x' }, 'query')).rejects.toBeDefined();
  });
});

describe('MovimientosSinConciliarDto (F12)', () => {
  const base = { cuenta_id: UUID, fecha_desde: '2026-06-01', fecha_hasta: '2026-06-30' };
  it('fechas YYYY-MM-DD pasan', async () => {
    await expect(validar(MovimientosSinConciliarDto, base, 'query')).resolves.toMatchObject(base);
  });
  it('sin fecha_desde → 400', async () => {
    await expect(validar(MovimientosSinConciliarDto, { cuenta_id: UUID, fecha_hasta: '2026-06-30' }, 'query')).rejects.toBeDefined();
  });
  it.each(['2026-13-01', '2026-00-10', '2026-02-30', '2026-06-00'])('fecha imposible %s → 400 (daría Invalid Date y 500 en el servicio)', async (fecha) => {
    await expect(validar(MovimientosSinConciliarDto, { ...base, fecha_desde: fecha }, 'query')).rejects.toBeDefined();
    await expect(validar(MovimientosSinConciliarDto, { ...base, fecha_hasta: fecha }, 'query')).rejects.toBeDefined();
  });
  it('fecha con hora → 400 (daría Invalid Date y 500 en el servicio)', async () => {
    await expect(validar(MovimientosSinConciliarDto, { ...base, fecha_desde: '2026-06-01T00:00:00.000Z' }, 'query')).rejects.toBeDefined();
  });
});

describe('LineasDeMovimientosDto (F20)', () => {
  it('tres ids de 36 caracteres pasan: el 404 lo decide el servicio', async () => {
    await expect(validar(LineasDeMovimientosDto, { ids: [UUID, UUID, UUID].join(',') }, 'query')).resolves.toBeDefined();
  });
});

describe('ImportarExtractoDto', () => {
  const base = { cuenta_id: UUID, csv_content: 'a;b' };
  it('sin saldos pasa (D5)', async () => {
    const r = await validar(ImportarExtractoDto, base);
    expect(r.saldo_inicial).toBeUndefined();
    expect(r.saldo_final).toBeUndefined();
  });
  it('saldo "" → undefined, no 0 (F14)', async () => {
    const r = await validar(ImportarExtractoDto, { ...base, saldo_inicial: '', saldo_final: '' });
    expect(r.saldo_inicial).toBeUndefined();
    expect(r.saldo_final).toBeUndefined();
  });
  it('un saldo en 0 sigue siendo 0, y uno negativo pasa', async () => {
    const r = await validar(ImportarExtractoDto, { ...base, saldo_inicial: 0, saldo_final: -49813966 });
    expect(r.saldo_inicial).toBe(0);
    expect(r.saldo_final).toBe(-49813966);
  });
  it.each(['abc', '0x10', '1e3'])('saldo %s → 400: solo un número escrito en decimal', async (saldo) => {
    await expect(validar(ImportarExtractoDto, { ...base, saldo_final: saldo })).rejects.toBeDefined();
  });
  it('saldo en texto decimal pasa', async () => {
    expect((await validar(ImportarExtractoDto, { ...base, saldo_final: '1250.5' })).saldo_final).toBe(1250.5);
  });
  it('período imposible → 400', async () => {
    await expect(validar(ImportarExtractoDto, { ...base, periodo_desde: '2026-13-01' })).rejects.toBeDefined();
    await expect(validar(ImportarExtractoDto, { ...base, periodo_hasta: '2026-02-30' })).rejects.toBeDefined();
  });
  it('archivo_nombre de 256 → 400; de 255 pasa', async () => {
    await expect(validar(ImportarExtractoDto, { ...base, archivo_nombre: x(256) })).rejects.toBeDefined();
    await expect(validar(ImportarExtractoDto, { ...base, archivo_nombre: x(255) })).resolves.toBeDefined();
  });
  it('periodo_desde con hora → 400 (F12); vacío → undefined', async () => {
    await expect(validar(ImportarExtractoDto, { ...base, periodo_desde: '2026-06-01T00:00:00.000Z' })).rejects.toBeDefined();
    expect((await validar(ImportarExtractoDto, { ...base, periodo_desde: '' })).periodo_desde).toBeUndefined();
  });
});

describe('ImportarExtractoPdfBodyDto', () => {
  it('período con hora → 400 y vacío → undefined, como el CSV', async () => {
    await expect(validar(ImportarExtractoPdfBodyDto, { cuenta_id: UUID, periodo_hasta: '2026-06-01T00:00:00.000Z' })).rejects.toBeDefined();
    expect((await validar(ImportarExtractoPdfBodyDto, { cuenta_id: UUID, periodo_hasta: '' })).periodo_hasta).toBeUndefined();
  });
});

describe('ImportarExtractoPdfBodyDto, fecha imposible', () => {
  it('período imposible → 400', async () => {
    await expect(validar(ImportarExtractoPdfBodyDto, { cuenta_id: UUID, periodo_desde: '2026-00-10' })).rejects.toBeDefined();
  });
});

describe('CrearMovimientoDesdeLineaDto', () => {
  it('descripcion de 501 → 400; de 500 pasa', async () => {
    await expect(validar(CrearMovimientoDesdeLineaDto, { categoria_id: UUID, descripcion: x(501) })).rejects.toBeDefined();
    await expect(validar(CrearMovimientoDesdeLineaDto, { categoria_id: UUID, descripcion: x(500) })).resolves.toBeDefined();
  });
});

describe('ActualizarLineaConciliacionDto', () => {
  it('debito con 3 decimales → 400; con 2 pasa', async () => {
    await expect(validar(ActualizarLineaConciliacionDto, { debito: 10.123 })).rejects.toBeDefined();
    await expect(validar(ActualizarLineaConciliacionDto, { debito: 10.12 })).resolves.toMatchObject({ debito: 10.12 });
  });
  it('credito con 3 decimales → 400', async () => {
    await expect(validar(ActualizarLineaConciliacionDto, { credito: 10.123 })).rejects.toBeDefined();
  });
  it('descripcion de 501 → 400', async () => {
    await expect(validar(ActualizarLineaConciliacionDto, { descripcion: x(501) })).rejects.toBeDefined();
  });
  it('fecha imposible → 400', async () => {
    await expect(validar(ActualizarLineaConciliacionDto, { fecha: '2026-13-01' })).rejects.toBeDefined();
  });
  it('fecha con hora → 400 (F12); YYYY-MM-DD pasa', async () => {
    await expect(validar(ActualizarLineaConciliacionDto, { fecha: '2026-06-01T00:00:00.000Z' })).rejects.toBeDefined();
    await expect(validar(ActualizarLineaConciliacionDto, { fecha: '2026-06-01' })).resolves.toMatchObject({ fecha: '2026-06-01' });
  });
});
