import { ComprasService } from './compras.service';

jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  exigirAccesoElevado: jest.fn().mockResolvedValue(undefined),
}));

/**
 * Libro IVA compras por moneda (carril A, T2). Primero la caracterización: la salida de siempre (`resumen`, `detalle`)
 * fijada con el código anterior al cambio, con documentos de una sola moneda. Lo de moneda es aditivo.
 */

const PYG_ID = '11111111-1111-4111-8111-111111111111';
const USD_ID = '22222222-2222-4222-8222-222222222222';
/** Con letras: para probar un `moneda_id` en mayúsculas. */
const EUR_ID = 'abcdefab-cdef-4abc-8def-abcdefabcdef';
const MONEDAS: Record<string, { id: string; codigo: string }> = {
  [PYG_ID]: { id: PYG_ID, codigo: 'PYG' },
  [USD_ID]: { id: USD_ID, codigo: 'USD' },
  [EUR_ID]: { id: EUR_ID, codigo: 'EUR' },
};

/** Filtro de moneda como la base: `moneda_id` directo y los de moneda dentro de `AND`; el resto no se evalúa. */
const cumpleMoneda = (where: any, monedaId: string | null): boolean => {
  const soloMoneda = (o: any) => o && typeof o === 'object' && Object.keys(o).length === 1 && 'moneda_id' in o;
  const cond = (c: any): boolean => {
    if (!c || typeof c !== 'object') return true;
    if (soloMoneda(c)) return c.moneda_id === monedaId;
    if (Array.isArray(c.OR) && c.OR.every(soloMoneda)) return c.OR.some(cond);
    return true;
  };
  if (!where) return true;
  if ('moneda_id' in where && where.moneda_id !== undefined && where.moneda_id !== monedaId) return false;
  return (where.AND ?? []).every(cond);
};
const filtrar = (docs: any[]) => (a: any) => Promise.resolve(docs.filter((d) => cumpleMoneda(a?.where, d.moneda_id ?? null)));

const crear = (docs: { compras: any[]; gastos: any[]; ncs: any[]; despachos: any[] }, baseId = PYG_ID) => {
  const prisma: any = {
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: baseId }) },
    moneda: {
      findUnique: jest.fn((a: any) => Promise.resolve(MONEDAS[String(a.where.id).toLowerCase()] ?? null)),
      findFirst: jest.fn().mockResolvedValue({ id: PYG_ID }),
    },
    compra_cab: { findMany: jest.fn(filtrar(docs.compras)) },
    gasto_cab: { findMany: jest.fn(filtrar(docs.gastos)) },
    nota_credito_compra_cab: { findMany: jest.fn(filtrar(docs.ncs)) },
    imp_despachos: { findMany: jest.fn().mockResolvedValue(docs.despachos) },
  };
  const service = new ComprasService(prisma, {} as any, {} as any, {} as any, {} as any, {} as any, { logEnTransaccion: jest.fn() } as any);
  return { service, prisma };
};

const proveedor = (razon_social: string, ruc: string, dv: string) => ({ personas: { razon_social, ruc, dv } });
const dia = (d: number) => new Date(Date.UTC(2026, 9, d));

const C1 = {
  moneda_id: PYG_ID,
  cotizacion: 1,
  moneda: { codigo: 'PYG' },
  fecha_emision: dia(3),
  establecimiento: '001',
  punto_expedicion: '002',
  numero_factura: '0000123',
  timbrado_proveedor: '12345678',
  proveedores: proveedor('PROVEEDOR SA', '80000002', '3'),
  condicion_operacion: { descripcion: 'Crédito' },
  total_gravado_10: 300000,
  total_gravado_5: 100000,
  total_exento: 20000,
  total_iva_10: 30000,
  total_iva_5: 5000,
  total: 455000,
  es_preimpreso: true,
  tipo_comprobante: 'FACTURA',
};
const C2 = {
  moneda_id: null,
  cotizacion: 1,
  moneda: null,
  fecha_emision: dia(15),
  establecimiento: '001',
  punto_expedicion: null,
  numero_factura: '0000009',
  timbrado_proveedor: null,
  proveedores: null,
  condicion_operacion: null,
  total_gravado_10: 100000,
  total_gravado_5: 0,
  total_exento: 0,
  total_iva_10: 10000,
  total_iva_5: 0,
  total: 110000,
  es_preimpreso: null,
  tipo_comprobante: null,
};
const gasto = (s: Record<string, unknown>) => ({
  moneda_id: PYG_ID,
  cotizacion: 1,
  moneda: { codigo: 'PYG' },
  establecimiento: '001',
  punto_expedicion: '001',
  timbrado: '87654321',
  proveedores: proveedor('ESTACION SRL', '80000003', '4'),
  total_gravado_10: 0,
  total_gravado_5: 0,
  total_exento: 0,
  total_iva_10: 0,
  total_iva_5: 0,
  total: 0,
  deducible: true,
  rendicion_viatico_id: null,
  forma_pago: 'TRANSFERENCIA',
  es_preimpreso: true,
  tipo_comprobante: 'FACTURA',
  ...s,
});
const G1 = gasto({ fecha_emision: dia(5), numero_factura: '0000501', total_gravado_10: 50000, total_iva_10: 5000, total: 55000 });
const G2 = gasto({
  fecha_emision: dia(7),
  numero_factura: '0000502',
  proveedores: null,
  ruc: '4444444-4',
  descripcion: 'Taxi',
  timbrado: null,
  forma_pago: 'CREDITO_30',
  deducible: false,
  total_gravado_5: 40000,
  total_iva_5: 2000,
  total: 42000,
});
const G3 = gasto({
  moneda_id: null,
  moneda: null,
  fecha_emision: dia(9),
  numero_factura: '0000503',
  rendicion_viatico_id: 'rend-1',
  forma_pago: 'ANTICIPO',
  total_exento: 30000,
  total: 30000,
});
const NC1 = {
  moneda_id: PYG_ID,
  cotizacion: 1,
  moneda: { codigo: 'PYG' },
  fecha_emision: dia(20),
  establecimiento: '001',
  punto_expedicion: '002',
  numero: '0000044',
  timbrado: '12345678',
  proveedores: proveedor('PROVEEDOR SA', '80000002', '3'),
  total: 33500,
  detalles: [
    { subtotal: 22000, monto_iva: 2000, porcentaje_iva: 10 },
    { subtotal: 10500, monto_iva: 500, porcentaje_iva: 5 },
    { subtotal: 1000, monto_iva: 0, porcentaje_iva: 0 },
  ],
};
const D1 = {
  fecha_despacho: dia(25),
  numero_despacho: '26001IC04000123X',
  iva_importacion_gs: 120000,
  iva_importacion_5_gs: 20000,
  cotizacion_usada: 7400,
  despachante: proveedor('DESPACHOS SA', '80000004', '5'),
  embarque: { numero: 'EMB-1', proveedores: { personas: { razon_social: 'EXPORTER LLC' } } },
};
const DOCS = { compras: [C1, C2], gastos: [G1, G2, G3], ncs: [NC1], despachos: [D1] };

const FILAS = {
  C1: {
    tipo: 'FACTURA_COMPRA',
    fecha: '2026-10-03',
    numero: '001-002-0000123',
    timbrado: '12345678',
    proveedor: 'PROVEEDOR SA',
    ruc: '80000002-3',
    condicion: 'Crédito',
    moneda: 'PYG',
    gravada_10: 300000,
    gravada_5: 100000,
    exentas: 20000,
    iva_10: 30000,
    iva_5: 5000,
    total: 455000,
    es_preimpreso: true,
    tipo_comprobante: 'FACTURA',
  },
  C2: {
    tipo: 'FACTURA_COMPRA',
    fecha: '2026-10-15',
    numero: '001-0000009',
    timbrado: '',
    proveedor: 'Sin nombre',
    ruc: '',
    condicion: 'Contado',
    moneda: 'PYG',
    gravada_10: 100000,
    gravada_5: 0,
    exentas: 0,
    iva_10: 10000,
    iva_5: 0,
    total: 110000,
    es_preimpreso: true,
    tipo_comprobante: null,
  },
  G1: {
    tipo: 'GASTO',
    fecha: '2026-10-05',
    numero: '001-001-0000501',
    timbrado: '87654321',
    proveedor: 'ESTACION SRL',
    ruc: '80000003-4',
    condicion: 'Contado',
    moneda: 'PYG',
    gravada_10: 50000,
    gravada_5: 0,
    exentas: 0,
    iva_10: 5000,
    iva_5: 0,
    total: 55000,
    deducible: true,
    es_preimpreso: true,
    tipo_comprobante: 'FACTURA',
  },
  G2: {
    tipo: 'GASTO',
    fecha: '2026-10-07',
    numero: '001-001-0000502',
    timbrado: '',
    proveedor: 'Taxi',
    ruc: '4444444-4',
    condicion: 'Crédito',
    moneda: 'PYG',
    gravada_10: 0,
    gravada_5: 40000,
    exentas: 0,
    iva_10: 0,
    iva_5: 2000,
    total: 42000,
    deducible: false,
    es_preimpreso: true,
    tipo_comprobante: 'FACTURA',
  },
  G3: {
    tipo: 'VIATICO',
    fecha: '2026-10-09',
    numero: '001-001-0000503',
    timbrado: '87654321',
    proveedor: 'ESTACION SRL',
    ruc: '80000003-4',
    condicion: 'Contado',
    moneda: 'PYG',
    gravada_10: 0,
    gravada_5: 0,
    exentas: 30000,
    iva_10: 0,
    iva_5: 0,
    total: 30000,
    deducible: true,
    es_preimpreso: true,
    tipo_comprobante: 'FACTURA',
  },
  NC1: {
    tipo: 'NOTA_CREDITO_COMPRA',
    fecha: '2026-10-20',
    numero: '001-002-0000044',
    timbrado: '12345678',
    proveedor: 'PROVEEDOR SA',
    ruc: '80000002-3',
    condicion: 'Nota de crédito',
    moneda: 'PYG',
    gravada_10: -20000,
    gravada_5: -10000,
    exentas: -1000,
    iva_10: -2000,
    iva_5: -500,
    total: -33500,
  },
  D1: {
    tipo: 'DESPACHO_IMPORTACION',
    fecha: '2026-10-25',
    numero: '26001IC04000123X',
    timbrado: '',
    proveedor: 'DESPACHOS SA',
    ruc: '80000004-5',
    condicion: 'Despacho — embarque EMB-1',
    moneda: 'PYG',
    gravada_10: 1000000,
    gravada_5: 400000,
    exentas: 0,
    iva_10: 100000,
    iva_5: 20000,
    total: 1520000,
    es_preimpreso: true,
  },
};

/** Las filas sin lo que suma el contrato de moneda (`cotizacion`): los campos de siempre, tal cual. */
const filasDeSiempre = (detalle: any[]) => detalle.map((f) => Object.fromEntries(Object.entries(f).filter(([k]) => k !== 'cotizacion')));

describe('ComprasService.getLibroIvaCompras — caracterización de los campos de siempre', () => {
  it('compras, gastos (no deducible fuera del crédito), viáticos, despachos y NC restando; filas ordenadas por fecha', async () => {
    const { service } = crear(DOCS);
    const r = await service.getLibroIvaCompras('emp-1', 10, 2026, undefined, 'preimpresos', 'usr-1');

    expect(r.periodo).toEqual({
      mes: 10,
      anio: 2026,
      desde: new Date(Date.UTC(2026, 9, 1, 0, 0, 0, 0)),
      hasta: new Date(Date.UTC(2026, 10, 0, 23, 59, 59, 999)),
    });
    expect(r.resumen).toEqual({
      compras: { cantidad: 2, gravada_10: 400000, gravada_5: 100000, exentas: 20000, iva_10: 40000, iva_5: 5000, total: 565000 },
      gastos: {
        cantidad: 3,
        gravada_10: 50000,
        gravada_5: 40000,
        exentas: 30000,
        iva_10: 5000,
        iva_5: 0,
        total: 127000,
        cantidad_no_deducibles: 1,
        iva_no_deducible: 2000,
      },
      despachos_importacion: { cantidad: 1, gravada_10: 1000000, gravada_5: 400000, exentas: 0, iva_10: 100000, iva_5: 20000, total: 1520000 },
      notas_credito: { cantidad: 1, gravada_10: 20000, gravada_5: 10000, exentas: 1000, iva_10: 2000, iva_5: 500, total: 33500 },
      credito_fiscal: { iva_10: 143000, iva_5: 24500, total: 167500 },
    });
    expect(filasDeSiempre(r.detalle)).toEqual([FILAS.C1, FILAS.G1, FILAS.G2, FILAS.G3, FILAS.C2, FILAS.NC1, FILAS.D1]);
  });

  it('con moneda_id filtra compras, gastos y NC por esa moneda exacta (sin moneda no entra); los despachos no se filtran', async () => {
    const { service } = crear(DOCS);
    const r = await service.getLibroIvaCompras('emp-1', 10, 2026, PYG_ID, 'preimpresos', 'usr-1');

    expect(r.resumen.compras).toMatchObject({ cantidad: 1, iva_10: 30000, iva_5: 5000, total: 455000 });
    expect(r.resumen.gastos).toMatchObject({ cantidad: 2, exentas: 0, total: 97000 });
    expect(r.resumen.despachos_importacion).toMatchObject({ cantidad: 1, iva_10: 100000 });
    expect(r.resumen.credito_fiscal).toEqual({ iva_10: 133000, iva_5: 24500, total: 157500 });
    expect(filasDeSiempre(r.detalle)).toEqual([FILAS.C1, FILAS.G1, FILAS.G2, FILAS.NC1, FILAS.D1]);
  });

  it('electrónicos: sin despachos', async () => {
    const { service, prisma } = crear(DOCS);
    const r = await service.getLibroIvaCompras('emp-1', 10, 2026, undefined, 'electronicos', 'usr-1');

    expect(prisma.imp_despachos.findMany).not.toHaveBeenCalled();
    expect(r.resumen.despachos_importacion.cantidad).toBe(0);
  });
});

/** Compra USD a 7400 y gasto USD con la cotización por defecto (1 = sin cotización: queda fuera de lo convertido). */
const C_USD = {
  ...C1,
  moneda_id: USD_ID,
  cotizacion: 7400,
  moneda: { codigo: 'USD' },
  fecha_emision: dia(12),
  numero_factura: '0000777',
  total_gravado_10: 100,
  total_gravado_5: 0,
  total_exento: 0,
  total_iva_10: 10,
  total_iva_5: 0,
  total: 110,
};
const G_USD = gasto({
  moneda_id: USD_ID,
  cotizacion: 1,
  moneda: { codigo: 'USD' },
  fecha_emision: dia(13),
  numero_factura: '0000888',
  total_gravado_10: 50,
  total_iva_10: 5,
  total: 55,
});
const MIX = { compras: [C1, C2, C_USD], gastos: [G1, G2, G3, G_USD], ncs: [NC1], despachos: [D1] };

describe('ComprasService.getLibroIvaCompras — moneda como el Tablero', () => {
  it('sin moneda_id: en_moneda convierte cada documento con su cotización; por_moneda crudo; sin cotización queda fuera', async () => {
    const { service } = crear(MIX);
    const r = await service.getLibroIvaCompras('emp-1', 10, 2026, undefined, 'preimpresos', 'usr-1');

    expect(r.moneda).toEqual({ id: PYG_ID, codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.sin_cotizacion).toBe(1);
    expect(r.en_moneda.resumen).toEqual({
      compras: { cantidad: 3, gravada_10: 1140000, gravada_5: 100000, exentas: 20000, iva_10: 114000, iva_5: 5000, total: 1379000 },
      gastos: {
        cantidad: 3,
        gravada_10: 50000,
        gravada_5: 40000,
        exentas: 30000,
        iva_10: 5000,
        iva_5: 0,
        total: 127000,
        cantidad_no_deducibles: 1,
        iva_no_deducible: 2000,
      },
      despachos_importacion: { cantidad: 1, gravada_10: 1000000, gravada_5: 400000, exentas: 0, iva_10: 100000, iva_5: 20000, total: 1520000 },
      notas_credito: { cantidad: 1, gravada_10: 20000, gravada_5: 10000, exentas: 1000, iva_10: 2000, iva_5: 500, total: 33500 },
      credito_fiscal: { iva_10: 217000, iva_5: 24500, total: 241500 },
    });
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', gravada_10: '1430000.00', gravada_5: '530000.00', exentas: '49000.00', iva_10: '143000.00', iva_5: '24500.00', credito_fiscal: '167500.00', total: '2178500.00' },
      { codigo: 'USD', gravada_10: '150.00', gravada_5: '0.00', exentas: '0.00', iva_10: '15.00', iva_5: '0.00', credito_fiscal: '15.00', total: '165.00' },
    ]);
  });

  it('los campos de siempre no cambian: suman crudo, como hoy; cada fila suma su cotización (null en la base o sin cotización)', async () => {
    const { service } = crear(MIX);
    const r = await service.getLibroIvaCompras('emp-1', 10, 2026, undefined, 'preimpresos', 'usr-1');

    expect(r.resumen.compras).toEqual({ cantidad: 3, gravada_10: 400100, gravada_5: 100000, exentas: 20000, iva_10: 40010, iva_5: 5000, total: 565110 });
    expect(r.resumen.credito_fiscal).toEqual({ iva_10: 143015, iva_5: 24500, total: 167515 });
    expect(r.detalle.map((f: any) => [f.numero, f.cotizacion])).toEqual([
      ['001-002-0000123', null],
      ['001-001-0000501', null],
      ['001-001-0000502', null],
      ['001-001-0000503', null],
      ['001-002-0000777', 7400],
      ['001-001-0000888', null],
      ['001-0000009', null],
      ['001-002-0000044', null],
      ['26001IC04000123X', null],
    ]);
  });

  it('con moneda_id USD: en_moneda solo USD sin convertir; los despachos en guaraníes no entran a ningún lado (un filtro por moneda muestra solo esa moneda)', async () => {
    const { service } = crear(MIX);
    const r = await service.getLibroIvaCompras('emp-1', 10, 2026, USD_ID, 'preimpresos', 'usr-1');

    expect(r.moneda).toEqual({ id: USD_ID, codigo: 'USD' });
    expect(r.convertido).toBe(false);
    expect(r.sin_cotizacion).toBe(0);
    expect(r.en_moneda.resumen.compras).toMatchObject({ cantidad: 1, iva_10: 10, total: 110 });
    expect(r.en_moneda.resumen.gastos).toMatchObject({ cantidad: 1, iva_10: 5, total: 55 });
    expect(r.en_moneda.resumen.despachos_importacion.cantidad).toBe(0);
    expect(r.en_moneda.resumen.credito_fiscal).toEqual({ iva_10: 15, iva_5: 0, total: 15 });
    // Cambio a propósito (ruling T10): antes el despacho en Gs entraba al detalle y al resumen del libro USD y sumaba
    // guaraníes con dólares. Un filtro por moneda muestra solo esa moneda.
    expect(r.resumen.despachos_importacion).toEqual({ cantidad: 0, gravada_10: 0, gravada_5: 0, exentas: 0, iva_10: 0, iva_5: 0, total: 0 });
    expect(r.resumen.credito_fiscal).toEqual({ iva_10: 15, iva_5: 0, total: 15 });
    expect(r.detalle.map((f: any) => f.moneda)).toEqual(['USD', 'USD']);
    expect(r.detalle.some((f: any) => f.tipo === 'DESPACHO_IMPORTACION')).toBe(false);
    expect(r.por_moneda).toEqual([{ codigo: 'USD', gravada_10: '150.00', gravada_5: '0.00', exentas: '0.00', iva_10: '15.00', iva_5: '0.00', credito_fiscal: '15.00', total: '165.00' }]);
  });

  it('con moneda_id de la base: en_moneda incluye los documentos sin moneda; los de siempre siguen con el id exacto', async () => {
    const { service } = crear(MIX);
    const r = await service.getLibroIvaCompras('emp-1', 10, 2026, PYG_ID, 'preimpresos', 'usr-1');

    expect(r.resumen.compras.cantidad).toBe(1);
    expect(r.resumen.gastos.cantidad).toBe(2);
    expect(r.en_moneda.resumen.compras.cantidad).toBe(2);
    expect(r.en_moneda.resumen.gastos.cantidad).toBe(3);
    expect(r.en_moneda.resumen.credito_fiscal).toEqual({ iva_10: 143000, iva_5: 24500, total: 167500 });
  });

  it('empresa con base USD: el despacho (guaraníes) pasa con su cotización usada; la compra PYG con cotización 1 queda fuera', async () => {
    const { service } = crear({ compras: [C1], gastos: [], ncs: [], despachos: [D1] }, USD_ID);
    const r = await service.getLibroIvaCompras('emp-1', 10, 2026, undefined, 'preimpresos', 'usr-1');

    expect(r.moneda).toEqual({ id: USD_ID, codigo: 'USD' });
    expect(r.sin_cotizacion).toBe(1);
    expect(r.en_moneda.resumen.compras.cantidad).toBe(0);
    expect(r.en_moneda.resumen.despachos_importacion).toEqual({
      cantidad: 1,
      gravada_10: 135.14,
      gravada_5: 54.05,
      exentas: 0,
      iva_10: 13.51,
      iva_5: 2.7,
      total: 205.41,
    });
    expect(r.en_moneda.resumen.credito_fiscal).toEqual({ iva_10: 13.51, iva_5: 2.7, total: 16.21 });
    expect(r.detalle.find((f: any) => f.tipo === 'DESPACHO_IMPORTACION').cotizacion).toBe(7400);
  });

  it('por_moneda trae bases y exentas netas de NC e IVA 10/5 deducible en su moneda: lo mismo que el libro de esa sola moneda', async () => {
    const neto = (r: any) => {
      const { compras: c, gastos: g, despachos_importacion: d, notas_credito: n, credito_fiscal: cf } = r.en_moneda.resumen;
      const base = (k: string) => (c[k] + g[k] + d[k] - n[k]).toFixed(2);
      return {
        gravada_10: base('gravada_10'),
        gravada_5: base('gravada_5'),
        exentas: base('exentas'),
        iva_10: cf.iva_10.toFixed(2),
        iva_5: cf.iva_5.toFixed(2),
        credito_fiscal: cf.total.toFixed(2),
        total: base('total'),
      };
    };
    const pyg = await crear(MIX).service.getLibroIvaCompras('emp-1', 10, 2026, PYG_ID, 'preimpresos', 'usr-1');
    const usd = await crear(MIX).service.getLibroIvaCompras('emp-1', 10, 2026, USD_ID, 'preimpresos', 'usr-1');
    const todas = await crear(MIX).service.getLibroIvaCompras('emp-1', 10, 2026, undefined, 'preimpresos', 'usr-1');

    expect(pyg.por_moneda).toEqual([{ codigo: 'PYG', ...neto(pyg) }]);
    expect(usd.por_moneda).toEqual([{ codigo: 'USD', ...neto(usd) }]);
    expect(todas.por_moneda).toEqual([...pyg.por_moneda, ...usd.por_moneda]);
    // El IVA del gasto no deducible (G3) no suma, como en el crédito fiscal.
    expect(pyg.por_moneda[0].iva_10).toBe('143000.00');
  });

  it('moneda_id que no existe → 400 MONEDA_INVALIDA', async () => {
    const { service } = crear(MIX);
    await expect(
      service.getLibroIvaCompras('emp-1', 10, 2026, '33333333-3333-4333-8333-333333333333', 'preimpresos', 'usr-1'),
    ).rejects.toMatchObject({ status: 400, response: { codigo: 'MONEDA_INVALIDA' } });
  });
});

describe('ComprasService.getLibroIvaCompras — NC de compra con moneda_id', () => {
  it('la NC de compra filtra por el id exacto: su moneda_id es NOT NULL y Prisma rechaza `moneda_id: null`', async () => {
    const { service, prisma } = crear(DOCS);
    await service.getLibroIvaCompras('emp-1', 10, 2026, PYG_ID, 'preimpresos', 'usr-1');

    const where = prisma.nota_credito_compra_cab.findMany.mock.calls[0][0].where;
    expect(where.AND).toEqual([{ moneda_id: PYG_ID }]);
    expect(JSON.stringify(where)).not.toContain('"moneda_id":null');
  });
});

describe('ComprasService.getLibroIvaCompras — moneda_id en mayúsculas', () => {
  it('los campos de siempre filtran por el id resuelto: un UUID en mayúsculas trae lo mismo que en minúsculas', async () => {
    const eur = { moneda_id: EUR_ID, moneda: { codigo: 'EUR' }, cotizacion: 8000 };
    const { service } = crear({
      compras: [C1, { ...C_USD, ...eur }],
      gastos: [G1, { ...G_USD, ...eur }],
      ncs: [NC1, { ...NC1, ...eur }],
      despachos: [],
    });
    const r = await service.getLibroIvaCompras('emp-1', 10, 2026, EUR_ID.toUpperCase(), 'preimpresos', 'usr-1');

    expect(r.moneda).toEqual({ id: EUR_ID, codigo: 'EUR' });
    expect(r.resumen.compras).toMatchObject({ cantidad: 1, iva_10: 10 });
    expect(r.resumen.gastos).toMatchObject({ cantidad: 1, iva_10: 5 });
    expect(r.resumen.notas_credito.cantidad).toBe(1);
  });
});
