import { Logger } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { LimiteTokensExcedidoError } from '../../ai-usage/ai-usage.service';
import { armar, CTA, EMP, errorDe, EXT, extracto, LIN, LIN2, linea, MOV, MOV2, USER } from './__helpers__/conciliacion-mock';
import { emparejarLineasConMovimientos } from './conciliacion-matching';

jest.mock('../../common/utils/module-access.util', () => ({
  ...jest.requireActual('../../common/utils/module-access.util'),
  isContabilidadEnabledForEmpresa: jest.fn().mockResolvedValue(false),
}));
jest.mock('../../auth/guards/submodulo.guard', () => ({ submoduloHabilitado: jest.fn() }));
jest.mock('../../utils/utilidades', () => ({ ...jest.requireActual('../../utils/utilidades'), ymdInAsuncion: jest.fn(() => '2026-11-04') }));
jest.mock('pdf-parse/lib/pdf-parse', () => jest.fn());
jest.mock('./conciliacion-matching', () => {
  const real = jest.requireActual('./conciliacion-matching');
  return { ...real, emparejarLineasConMovimientos: jest.fn(real.emparejarLineasConMovimientos) };
});

// eslint-disable-next-line @typescript-eslint/no-require-imports
const pdfParse = require('pdf-parse/lib/pdf-parse') as jest.Mock;
const emparejar = emparejarLineasConMovimientos as jest.Mock;
const dec = (n: number) => new Prisma.Decimal(n);
const CSV = 'fecha;descripcion;debito;credito;referencia\n2026-10-20;COMISION;1000;0;R1\n';
const csv = (o: Record<string, unknown> = {}) => ({ cuenta_id: CTA, csv_content: CSV, ...o });
const respuestaIA = (o: Record<string, unknown> = {}) =>
  JSON.stringify({ banco: 'Itaú', transacciones: [{ fecha: '2026-10-20', concepto: 'X', importe: 1000, tipo: 'DEBITO' }], ...o });
const ia = (contenido: string) => jest.fn().mockResolvedValue({ content: contenido });
const texto = (n: number) => 'a'.repeat(n);

beforeEach(() => {
  pdfParse.mockReset().mockResolvedValue({ text: texto(5000) });
  emparejar.mockClear();
});

describe('importarExtracto (CSV)', () => {
  it('sin saldos → null, no 0 (D5)', async () => {
    const { service, tx } = armar();
    await service.importarExtracto(EMP, csv(), USER);
    expect(tx.tes_extracto_bancario.create.mock.calls[0][0].data).toMatchObject({ saldo_inicial: null, saldo_final: null });
  });
  it('con saldos negativos, se guardan; un 0 sigue siendo 0', async () => {
    const { service, tx } = armar();
    await service.importarExtracto(EMP, csv({ saldo_inicial: -49813966, saldo_final: 0 }), USER);
    expect(tx.tes_extracto_bancario.create.mock.calls[0][0].data).toMatchObject({ saldo_inicial: -49813966, saldo_final: 0 });
  });
  it('cabecera y líneas en la misma transacción', async () => {
    const { service, tx, prisma, orden } = armar();
    await service.importarExtracto(EMP, csv(), USER);
    expect(tx.tes_extracto_bancario.create).toHaveBeenCalledTimes(1);
    expect(tx.tes_extracto_lineas.createMany).toHaveBeenCalledTimes(1);
    expect(orden.indexOf('$transaction')).toBeLessThan(orden.indexOf('extracto.create'));
    expect(prisma.tes_extracto_lineas.findMany).toHaveBeenCalled();
  });
  it('cuenta ajena o cerrada → 400 CUENTA_INVALIDA con campo cuenta_id', async () => {
    expect(await errorDe(armar({ cuenta: null }).service.importarExtracto(EMP, csv(), USER))).toMatchObject({ status: 400, codigo: 'CUENTA_INVALIDA', campo: 'cuenta_id' });
    expect(await errorDe(armar({ cuenta: { id: CTA, moneda: 'PYG', activo: false } }).service.importarExtracto(EMP, csv(), USER))).toMatchObject({
      status: 400,
      codigo: 'CUENTA_INVALIDA',
      campo: 'cuenta_id',
    });
  });
  it('periodo_desde posterior a periodo_hasta → 400 PERIODO_INVALIDO', async () => {
    const { service, prisma } = armar();
    expect(await errorDe(service.importarExtracto(EMP, csv({ periodo_desde: '2026-11-02', periodo_hasta: '2026-11-01' }), USER))).toMatchObject({
      status: 400,
      codigo: 'PERIODO_INVALIDO',
    });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });
  it('CSV sin líneas → 400 CSV_SIN_LINEAS', async () => {
    expect(await errorDe(armar().service.importarExtracto(EMP, csv({ csv_content: 'fecha;descripcion\n' }), USER))).toMatchObject({ status: 400, codigo: 'CSV_SIN_LINEAS' });
  });
});

describe('parseCsv y los montos en texto', () => {
  const parse = (contenido: string) => (armar().service as never as { parseCsv: (c: string) => Array<Record<string, unknown>> }).parseCsv(contenido);
  const normalizar = (v: unknown) => (armar().service as never as { normalizarMonto: (v: unknown) => number | undefined }).normalizarMonto(v);

  it('Continental 1.234.567,89 y Familiar 1,234,567', () => {
    expect(parse('fecha;debito;credito\n2026-10-20;1.234.567,89;0\n')[0]).toMatchObject({ debito: 1234567.89, credito: 0 });
    expect(parse('fecha;debito;credito\n2026-10-20;1,234,567;0\n')[0]).toMatchObject({ debito: 1234567 });
  });
  it('importe con signo', () => {
    expect(parse('fecha;importe\n2026-10-20;-1500\n2026-10-21;2500\n')).toMatchObject([
      { debito: 1500, credito: 0 },
      { debito: 0, credito: 2500 },
    ]);
  });
  it('una descripción de 600 queda en 500 y una referencia de 150 en 100', () => {
    const [l] = parse(`fecha;descripcion;debito;referencia\n2026-10-20;${'d'.repeat(600)};10;${'r'.repeat(150)}\n`);
    expect(l.descripcion).toHaveLength(500);
    expect(l.referencia).toHaveLength(100);
  });
  it.each([
    ['1250.50', 1250.5],
    ['1.250,50', 1250.5],
    ['-49813966', -49813966],
    ['18.500.000', 18500000],
    ['1,234,567', 1234567],
    [1250.5, 1250.5],
  ])('normalizarMonto(%s) → %s (F13)', (v, esperado) => {
    expect(normalizar(v)).toBe(esperado);
  });
  it.each([[null], [undefined], ['abc']])('normalizarMonto(%s) → undefined', (v) => {
    expect(normalizar(v)).toBeUndefined();
  });
});

describe('fechas imposibles: 400, nunca un 500 de Invalid Date', () => {
  const conFecha = (fecha: string) => `fecha;descripcion;debito;credito\n${fecha};COMISION;1000;0\n`;
  it.each(['31/13/2026', '00/06/2026', '31/02/2026', '2026-13-01', '2026-02-30'])('CSV con «%s» → 400 CSV_FECHA_INVALIDA que la nombra, sin crear nada', async (fecha) => {
    const { service, tx } = armar();
    const e = await errorDe(service.importarExtracto(EMP, csv({ csv_content: conFecha(fecha) }), USER));
    expect(e).toMatchObject({ status: 400, codigo: 'CSV_FECHA_INVALIDA' });
    expect(e?.message).toContain(fecha);
    expect(tx.tes_extracto_bancario.create).not.toHaveBeenCalled();
  });
  it('CSV con una fila sin fecha (totales): se saltea, como hoy', async () => {
    const { service, tx } = armar();
    await service.importarExtracto(EMP, csv({ csv_content: `${conFecha('20/10/2026')}TOTAL;;1000;0\n` }), USER);
    expect(tx.tes_extracto_lineas.createMany.mock.calls[0][0].data).toHaveLength(1);
  });
  it('CSV con el año de 2 dígitos sigue valiendo', async () => {
    const { service, tx } = armar();
    await service.importarExtracto(EMP, csv({ csv_content: conFecha('31/08/26') }), USER);
    expect(tx.tes_extracto_lineas.createMany.mock.calls[0][0].data[0].fecha).toEqual(new Date('2026-08-31T00:00:00.000Z'));
  });

  const pdf = (contenido: string, data: Record<string, unknown> = {}) => {
    const a = armar({ completar: ia(contenido) });
    return { ...a, promesa: a.service.importarExtractoPdf(EMP, Buffer.from('x'), { cuenta_id: CTA, ...data }, USER) };
  };
  it.each(['2026-13-01', '2026-02-30', '20/10/2026'])('una línea de la IA con fecha %s → 400 IA_FECHA_INVALIDA, sin crear nada', async (fecha) => {
    const { promesa, tx } = pdf(respuestaIA({ transacciones: [{ fecha, concepto: 'X', importe: 1000, tipo: 'DEBITO' }] }));
    expect(await errorDe(promesa)).toMatchObject({ status: 400, codigo: 'IA_FECHA_INVALIDA' });
    expect(tx.tes_extracto_bancario.create).not.toHaveBeenCalled();
  });
  it('un período de la IA imposible → 400 IA_FECHA_INVALIDA', async () => {
    const { promesa, tx } = pdf(respuestaIA({ periodo: { desde: '2026-10-00', hasta: '2026-10-31' } }));
    expect(await errorDe(promesa)).toMatchObject({ status: 400, codigo: 'IA_FECHA_INVALIDA' });
    expect(tx.tes_extracto_bancario.create).not.toHaveBeenCalled();
  });
  it('un período de la IA imposible no importa si el usuario mandó el suyo', async () => {
    const { promesa, tx } = pdf(respuestaIA({ periodo: { desde: '2026-10-00', hasta: '2026-13-31' } }), { periodo_desde: '2026-10-01', periodo_hasta: '2026-10-31' });
    await promesa;
    expect(tx.tes_extracto_bancario.create.mock.calls[0][0].data.periodo_desde).toEqual(new Date('2026-10-01T00:00:00.000Z'));
  });
});

describe('autoMatch', () => {
  const pares = (): Array<Record<string, unknown>> => [
    linea({ id: LIN, debito: dec(1000), fecha: new Date('2026-10-20T00:00:00.000Z') }),
    linea({ id: LIN2, debito: dec(2000), fecha: new Date('2026-10-20T00:00:00.000Z') }),
  ];
  const movs = (): Array<Record<string, unknown>> => [
    { id: MOV, fecha: new Date('2026-10-20T00:00:00.000Z'), tipo: 'EGRESO', origen_tipo: null, monto: dec(1000), referencia: null, descripcion: null },
    { id: MOV2, fecha: new Date('2026-10-20T00:00:00.000Z'), tipo: 'EGRESO', origen_tipo: null, monto: dec(2000), referencia: null, descripcion: null },
  ];
  const conLineas = (a: ReturnType<typeof armar>, lineas: Array<Record<string, unknown>>) => {
    // La primera lectura son las líneas pendientes; la segunda, las ya conciliadas de la cuenta.
    a.prisma.tes_extracto_lineas.findMany.mockReset();
    a.prisma.tes_extracto_lineas.findMany.mockResolvedValueOnce(lineas).mockResolvedValue([]);
  };

  it('por par: transacción con el bloqueo del extracto y del movimiento, relectura y updateMany con la guarda (F15)', async () => {
    const a = armar({ movimientos: movs() });
    conLineas(a, pares());
    await a.service.importarExtracto(EMP, csv(), USER);
    // una de la importación + una por par
    expect(a.prisma.$transaction).toHaveBeenCalledTimes(3);
    const iBloqueo = a.orden.indexOf('bloqueo-extracto');
    expect(iBloqueo).toBeLessThan(a.orden.indexOf('bloqueo-movimiento'));
    expect(a.orden.indexOf('bloqueo-movimiento')).toBeLessThan(a.orden.indexOf('lineas.otra'));
    expect(a.orden.indexOf('lineas.otra')).toBeLessThan(a.orden.indexOf('lineas.updateMany'));
    expect(a.tx.tes_extracto_lineas.updateMany.mock.calls[0][0]).toEqual({
      where: { id: LIN, conciliado: false, sin_correspondencia: false, debito: dec(1000), credito: dec(0) },
      data: { conciliado: true, movimiento_id: MOV },
    });
    expect(a.tx.tes_extracto_lineas.updateMany).toHaveBeenCalledTimes(2);
    expect(a.prisma.tes_extracto_lineas.update).not.toHaveBeenCalled();
  });
  it('si otra línea tomó el movimiento, esa línea queda pendiente y el siguiente par sigue', async () => {
    const a = armar({ movimientos: movs() });
    conLineas(a, pares());
    a.tx.tes_extracto_lineas.findFirst.mockImplementationOnce(() => Promise.resolve({ id: 'otra' }));
    await a.service.importarExtracto(EMP, csv(), USER);
    expect(a.tx.tes_extracto_lineas.updateMany).toHaveBeenCalledTimes(1);
    expect(a.tx.tes_extracto_lineas.updateMany.mock.calls[0][0].where.id).toBe(LIN2);
  });
  it('un movimiento anulado entre medio tampoco se toma', async () => {
    const a = armar({ movimientos: movs() });
    conLineas(a, pares());
    a.tx.tes_movimientos.findFirst.mockImplementationOnce(() => Promise.resolve(null));
    await a.service.importarExtracto(EMP, csv(), USER);
    expect(a.tx.tes_extracto_lineas.updateMany).toHaveBeenCalledTimes(1);
  });
  it.each([
    ['USD', 0.01],
    ['PYG', 1],
  ])('en %s, tolerancia %s y los mismos 2 días (RC H26)', async (moneda, tolerancia) => {
    const a = armar({ cuenta: { id: CTA, moneda, activo: true }, movimientos: movs() });
    conLineas(a, pares());
    await a.service.importarExtracto(EMP, csv(), USER);
    expect(emparejar.mock.calls[0][2]).toEqual({ toleranciaDias: 2, toleranciaMonto: tolerancia });
  });
  it('una línea editada entre la lectura y el par queda pendiente: la guarda lleva el débito y el crédito leídos', async () => {
    const a = armar({ movimientos: movs(), guarda: 0 });
    conLineas(a, [pares()[1]]);
    await a.service.importarExtracto(EMP, csv(), USER);
    expect(a.tx.tes_extracto_lineas.updateMany.mock.calls[0][0].where).toMatchObject({ id: LIN2, debito: dec(2000), credito: dec(0) });
  });
  it('una TRANSFERENCIA_ORIGEN llega al emparejado con tipo EGRESO (D7)', async () => {
    const a = armar({
      movimientos: [
        { id: MOV, fecha: new Date('2026-10-20T00:00:00.000Z'), tipo: 'TRANSFERENCIA', origen_tipo: 'TRANSFERENCIA_ORIGEN', monto: dec(1000), referencia: null, descripcion: null },
      ],
    });
    conLineas(a, [pares()[0]]);
    await a.service.importarExtracto(EMP, csv(), USER);
    expect(emparejar.mock.calls[0][1][0]).toMatchObject({ id: MOV, tipo: 'EGRESO' });
    expect(a.tx.tes_extracto_lineas.updateMany).toHaveBeenCalledTimes(1);
  });
});

describe('importarExtractoPdf', () => {
  const importar = (e: Parameters<typeof armar>[0] = {}, data: Record<string, unknown> = {}) => {
    const a = armar({ completar: ia(respuestaIA()), ...e });
    return { ...a, promesa: a.service.importarExtractoPdf(EMP, Buffer.from('x'), { cuenta_id: CTA, archivo_nombre: 'x.pdf', ...data }, USER) };
  };

  it('cabecera y líneas en la misma transacción, después de la IA (F14)', async () => {
    const { promesa, aiProvider, tx, prisma } = importar();
    await promesa;
    expect(aiProvider.completar.mock.invocationCallOrder[0]).toBeLessThan(prisma.$transaction.mock.invocationCallOrder[0]);
    expect(tx.tes_extracto_bancario.create).toHaveBeenCalledTimes(1);
    expect(tx.tes_extracto_lineas.createMany).toHaveBeenCalledTimes(1);
  });
  it('si crear las líneas falla, la transacción propaga el error (no queda cabecera)', async () => {
    const a = armar({ completar: ia(respuestaIA()) });
    a.tx.tes_extracto_lineas.createMany.mockRejectedValue(new Error('fallo'));
    await expect(a.service.importarExtractoPdf(EMP, Buffer.from('x'), { cuenta_id: CTA }, USER)).rejects.toThrow('fallo');
    expect(a.prisma.tes_extracto_bancario.findFirst).not.toHaveBeenCalled();
  });
  it('recorta el concepto a 500 y la referencia a 100', async () => {
    const { promesa, tx } = importar({
      completar: ia(respuestaIA({ transacciones: [{ fecha: '2026-10-20', concepto: 'c'.repeat(600), referencia: 'r'.repeat(150), importe: 10, tipo: 'CREDITO' }] })),
    });
    await promesa;
    const [l] = tx.tes_extracto_lineas.createMany.mock.calls[0][0].data;
    expect(l.descripcion).toHaveLength(500);
    expect(l.referencia).toHaveLength(100);
  });
  it('el importe que devuelve la IA como "1250.50" → 1250.5, no 125050 (F13)', async () => {
    const { promesa, tx } = importar({ completar: ia(respuestaIA({ transacciones: [{ fecha: '2026-10-20', concepto: 'c', importe: '1250.50', tipo: 'CREDITO' }] })) });
    await promesa;
    expect(tx.tes_extracto_lineas.createMany.mock.calls[0][0].data[0].credito).toBe(1250.5);
  });
  it('texto de 6500 → truncado, 6000 de 6500', async () => {
    pdfParse.mockResolvedValue({ text: texto(6500) });
    const r = await importar().promesa;
    expect(r.ia_meta).toMatchObject({ truncado: true, caracteres_leidos: 6000, caracteres_total: 6500 });
  });
  it('texto de 5000 → sin truncar', async () => {
    const r = await importar().promesa;
    expect(r.ia_meta).toMatchObject({ truncado: false, caracteres_leidos: 5000, caracteres_total: 5000 });
  });
  it('por el reintento con 6500 → 4000 leídos', async () => {
    pdfParse.mockResolvedValue({ text: texto(6500) });
    const completar = jest
      .fn()
      .mockResolvedValueOnce({ content: 'no es json' })
      .mockResolvedValueOnce({ content: JSON.stringify([{ fecha: '2026-10-20', concepto: 'x', importe: 10, tipo: 'DEBITO' }]) });
    const r = await importar({ completar }).promesa;
    expect(r.ia_meta).toMatchObject({ truncado: true, caracteres_leidos: 4000, caracteres_total: 6500 });
  });
  it('por el reintento con 3000 → 3000 leídos y sin truncar', async () => {
    pdfParse.mockResolvedValue({ text: texto(3000) });
    const completar = jest
      .fn()
      .mockResolvedValueOnce({ content: 'no es json' })
      .mockResolvedValueOnce({ content: JSON.stringify([{ fecha: '2026-10-20', concepto: 'x', importe: 10, tipo: 'DEBITO' }]) });
    const r = await importar({ completar }).promesa;
    expect(r.ia_meta).toMatchObject({ truncado: false, caracteres_leidos: 3000, caracteres_total: 3000 });
  });
  it('sin saldos ni detectados → null', async () => {
    const { promesa, tx } = importar();
    await promesa;
    expect(tx.tes_extracto_bancario.create.mock.calls[0][0].data).toMatchObject({ saldo_inicial: null, saldo_final: null });
  });
  it('con detectados → esos, y en ia_meta', async () => {
    const { promesa, tx } = importar({ completar: ia(respuestaIA({ saldo_inicial: '1.500,50', saldo_final: 2300 })) });
    const r = await promesa;
    expect(tx.tes_extracto_bancario.create.mock.calls[0][0].data).toMatchObject({ saldo_inicial: 1500.5, saldo_final: 2300 });
    expect(r.ia_meta).toMatchObject({ saldo_inicial_detectado: 1500.5, saldo_final_detectado: 2300 });
  });
  it('con el dato del usuario → el del usuario, también un 0', async () => {
    const { promesa, tx } = importar({ completar: ia(respuestaIA({ saldo_inicial: 5, saldo_final: 6 })) }, { saldo_inicial: 0, saldo_final: 99 });
    await promesa;
    expect(tx.tes_extracto_bancario.create.mock.calls[0][0].data).toMatchObject({ saldo_inicial: 0, saldo_final: 99 });
  });
  it('[Sin API key configurada] → IA_SIN_CONFIGURAR', async () => {
    expect(await errorDe(importar({ completar: ia('[Sin API key configurada]') }).promesa)).toMatchObject({ status: 400, codigo: 'IA_SIN_CONFIGURAR' });
  });
  it('error del proveedor en los dos intentos → IA_ERROR con el mensaje amigable', async () => {
    const e = await errorDe(importar({ completar: jest.fn().mockRejectedValue(new Error('invalid x-api-key')) }).promesa);
    expect(e).toMatchObject({ status: 400, codigo: 'IA_ERROR' });
    expect(String(e!.message)).not.toContain('x-api-key');
  });
  it('sin proveedor en el mensaje amigable no queda «de de IA» ni «con de IA»', async () => {
    expect(await errorDe(importar({ completar: jest.fn().mockRejectedValue(new Error('invalid api key')) }).promesa)).toMatchObject({
      message: 'La API key de IA es inválida o expiró. Verificá la clave en Configuración de IA.',
    });
    expect(await errorDe(importar({ completar: jest.fn().mockRejectedValue(new Error('algo raro')) }).promesa)).toMatchObject({
      message: 'No se pudo completar la solicitud con IA. Intentá de nuevo; si el problema persiste, revisá la configuración de IA.',
    });
  });
  describe('cuota de IA agotada (I2)', () => {
    const CUOTA = 'Tu empresa alcanzó el límite de tokens. Se renueva el 1° del próximo mes.';
    it('en el primer intento → 400 IA_LIMITE con el mensaje de la cuota, sin reintentar ni crear nada', async () => {
      const completar = jest.fn().mockRejectedValue(new LimiteTokensExcedidoError(CUOTA));
      const { promesa, prisma } = importar({ completar });
      expect(await errorDe(promesa)).toMatchObject({ status: 400, codigo: 'IA_LIMITE', message: CUOTA });
      expect(completar).toHaveBeenCalledTimes(1);
      expect(prisma.$transaction).not.toHaveBeenCalled();
    });
    it('si se agota en el reintento → también IA_LIMITE, no el genérico', async () => {
      const completar = jest.fn().mockResolvedValueOnce({ content: 'no es json' }).mockRejectedValueOnce(new LimiteTokensExcedidoError(CUOTA));
      const { promesa, prisma } = importar({ completar });
      expect(await errorDe(promesa)).toMatchObject({ status: 400, codigo: 'IA_LIMITE', message: CUOTA });
      expect(completar).toHaveBeenCalledTimes(2);
      expect(prisma.$transaction).not.toHaveBeenCalled();
    });
  });
  it.each([
    ['otro texto', 'TRANSFERENCIA'],
    ['en minúsculas', 'debito'],
    ['sin tipo', undefined],
  ])('una línea de la IA con tipo inválido (%s) → 400 IA_TIPO_INVALIDO, sin crear nada', async (_n, tipo) => {
    const { promesa, prisma } = importar({ completar: ia(respuestaIA({ transacciones: [{ fecha: '2026-10-20', concepto: 'X', importe: 1000, tipo }] })) });
    expect(await errorDe(promesa)).toMatchObject({ status: 400, codigo: 'IA_TIPO_INVALIDO' });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });
  describe('los logs no guardan datos bancarios', () => {
    const SECRETO = 'CUENTA-SECRETA-123';
    let espias: jest.SpyInstance[];
    beforeEach(() => {
      espias = (['log', 'warn', 'error'] as const).map((m) => jest.spyOn(Logger.prototype, m).mockImplementation(() => undefined));
      pdfParse.mockResolvedValue({ text: `${SECRETO} `.repeat(50) });
    });
    afterEach(() => espias.forEach((e) => e.mockRestore()));
    const escrito = () => JSON.stringify(espias.flatMap((e) => e.mock.calls), (_k, v: unknown) => (v instanceof Error ? `${v.message} ${v.stack}` : v));

    it('una importación que sale bien: ni el texto del PDF ni la respuesta; sí largos y cantidad', async () => {
      const { promesa } = importar({ completar: ia(respuestaIA({ banco: SECRETO })) });
      await promesa;
      expect(escrito()).not.toContain(SECRETO);
      expect(escrito()).toMatch(/1 transacciones/);
    });
    it('una respuesta que no es JSON en los dos intentos: el error de JSON tampoco la repite', async () => {
      const { promesa } = importar({ completar: ia(`${SECRETO} no es json`) });
      expect(await errorDe(promesa)).toMatchObject({ codigo: 'IA_ERROR' });
      expect(escrito()).not.toContain(SECRETO);
      expect(escrito()).toContain('no es JSON');
    });
    it('un error del proveedor se sigue viendo en el log', async () => {
      await errorDe(importar({ completar: jest.fn().mockRejectedValue(new Error('invalid x-api-key')) }).promesa);
      expect(escrito()).toContain('invalid x-api-key');
    });
  });
  it('sin transacciones → IA_SIN_TRANSACCIONES', async () => {
    expect(await errorDe(importar({ completar: ia(respuestaIA({ transacciones: [] })) }).promesa)).toMatchObject({ status: 400, codigo: 'IA_SIN_TRANSACCIONES' });
  });
  it('PDF ilegible → PDF_ILEGIBLE', async () => {
    pdfParse.mockRejectedValue(new Error('roto'));
    expect(await errorDe(importar().promesa)).toMatchObject({ status: 400, codigo: 'PDF_ILEGIBLE' });
  });
  it('sin texto → PDF_SIN_TEXTO', async () => {
    pdfParse.mockResolvedValue({ text: ' ' });
    expect(await errorDe(importar().promesa)).toMatchObject({ status: 400, codigo: 'PDF_SIN_TEXTO' });
  });
  it('cuenta cerrada → CUENTA_INVALIDA, sin leer el PDF ni llamar a la IA', async () => {
    const { promesa, aiProvider } = importar({ cuenta: { id: CTA, moneda: 'PYG', activo: false } });
    expect(await errorDe(promesa)).toMatchObject({ status: 400, codigo: 'CUENTA_INVALIDA', campo: 'cuenta_id' });
    expect(aiProvider.completar).not.toHaveBeenCalled();
    expect(pdfParse).not.toHaveBeenCalled();
  });
  it('período invertido → PERIODO_INVALIDO, sin gastar la IA', async () => {
    const { promesa, aiProvider } = importar({}, { periodo_desde: '2026-11-02', periodo_hasta: '2026-11-01' });
    expect(await errorDe(promesa)).toMatchObject({ status: 400, codigo: 'PERIODO_INVALIDO' });
    expect(aiProvider.completar).not.toHaveBeenCalled();
  });
});

// El detalle que devuelve la importación sale de getExtractoDetalle con su extracto.
it('la importación devuelve el detalle del extracto creado', async () => {
  const { service, prisma } = armar({ extracto: extracto() });
  const r = await service.importarExtracto(EMP, csv(), USER);
  expect(prisma.tes_extracto_bancario.findFirst.mock.calls[0][0].where).toEqual({ id: EXT, empresa_id: EMP });
  expect(r.id).toBe(EXT);
});
