import { ContabilidadIntegracionService } from './integracion.service';
import { FaltaMapeoError } from './falta-mapeo.error';
import { conResolvedor } from './__helpers__/integracion-mock';

/**
 * Asientos de comisiones en la moneda de la liquidación (spec 2026-10-17-comercial-finanzas, 4b).
 * Las líneas van en la moneda de la liquidación o comisión y `crearConfirmado` las pasa a guaraníes
 * con `cont_tipo_cambio` (asientos.service). Si falta la cotización no se asienta y se avisa.
 */

const PYG = { id: 'mon-pyg', codigo: 'PYG' };
const USD = { id: 'mon-usd', codigo: 'USD' };
const cuentaDe = (concepto: string) => `cta-${concepto}`;

const crearServicio = (prisma: any, cotizacion: { tasa: number } | null = { tasa: 7300 }) => {
  const service = Object.create(ContabilidadIntegracionService.prototype) as any;
  service.logger = { log: jest.fn(), warn: jest.fn(), error: jest.fn() };
  service.prisma = {
    cont_documentos: {
      findFirst: jest.fn().mockResolvedValue(null),
      create: jest.fn().mockResolvedValue({ id: 'doc-1' }),
    },
    vendedores_cobradores: {
      findUnique: jest.fn().mockResolvedValue({ nombre: 'Ana', apellido: 'Gómez', regimen_comision: null }),
    },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda: { ...PYG, simbolo: 'Gs.' } }) },
    moneda: { findFirst: jest.fn().mockResolvedValue({ ...PYG, simbolo: 'Gs.' }) },
    $transaction: jest.fn().mockImplementation((fn: any) => fn(service.prisma)),
    ...prisma,
  };
  service.tieneModuloContabilidad = jest.fn().mockResolvedValue(true);
  service.periodos = { resolverPeriodoPorFecha: jest.fn().mockResolvedValue('per-1') };
  // Resolvedor de producción (reglas por dimensión, sin reglas) sobre el mapeo por defecto `cta-<CONCEPTO>`.
  service.mapeo = conResolvedor({ getCuentaPorConcepto: jest.fn().mockImplementation((_e: string, c: string) => Promise.resolve(cuentaDe(c))) });
  service.avisosMapeo = { registrarFaltaMapeo: jest.fn().mockResolvedValue(undefined) };
  service.tipoCambio = {
    getVigente: jest.fn().mockResolvedValue(cotizacion ? { moneda: 'USD', fecha: new Date(), ...cotizacion } : null),
  };
  service.asientos = { crearConfirmado: jest.fn().mockResolvedValue({ id: 'as-1' }) };
  return service;
};

const liquidacion = (over: any = {}) => ({
  id: 'liq-1',
  vendedor_cobrador_id: 'vc-1',
  total_comisiones: '500',
  created_at: new Date('2026-10-05T14:00:00Z'),
  fecha_pago: null,
  moneda_id: USD.id,
  moneda: USD,
  ...over,
});

const dtoAsiento = (service: any) => service.asientos.crearConfirmado.mock.calls[0][3];

describe('asientos de comisiones en la moneda de la liquidación', () => {
  it('devengamiento USD usa la cotización de la fecha de la liquidación', async () => {
    const service = crearServicio({ liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) } });

    const r = await service.integrarDevengamientoComisiones('liq-1', 'emp-1');

    expect(r).toEqual({});
    expect(service.tipoCambio.getVigente).toHaveBeenCalledWith('emp-1', 'USD', new Date('2026-10-05'));
    const dto = dtoAsiento(service);
    expect(dto).toMatchObject({ fecha: '2026-10-05', moneda_origen: 'USD' });
    // Las líneas van en USD (crearConfirmado las convierte) y las cuentas no cambian.
    expect(dto.lineas).toMatchObject([
      { cuenta_id: cuentaDe('GASTO_COMISIONES_VENTAS'), debe_moneda: 500, haber_moneda: 0, descripcion: 'Gasto comisiones' },
      { cuenta_id: cuentaDe('COMISIONES_A_PAGAR'), debe_moneda: 0, haber_moneda: 500, descripcion: 'Comisiones a pagar' },
    ]);
  });

  // Pago en otra moneda (Ruling 6): las líneas van en guaraníes. La deuda se cancela a la cotización del
  // devengamiento (el haber_pyg de su asiento) y la salida de fondos sale a la del día de pago; la
  // diferencia es diferencia de cambio, como en la orden de pago.
  const conDevengamiento = (service: any, asiento: { haber_moneda: number; haber_pyg: number } | null) => {
    service.prisma.cont_documentos.findFirst.mockImplementation(({ where }: any) =>
      Promise.resolve(
        where.origen_tipo === 'liquidacion_comisiones_deveng' && where.estado === 'CONFIRMADO' && asiento
          ? { id: 'doc-dev', asiento: { moneda_origen: 'USD', lineas: [{ haber_moneda: 0, haber_pyg: 0 }, { haber_moneda: asiento.haber_moneda, haber_pyg: asiento.haber_pyg }] } }
          : null,
      ),
    );
  };
  const tasasPorDia = (service: any, tasas: Record<string, number>) => {
    service.tipoCambio.getVigente.mockImplementation((_e: string, moneda: string, f: Date) => {
      const tasa = tasas[f.toISOString().substring(0, 10)];
      return Promise.resolve(tasa ? { moneda, tasa, fecha: f } : null);
    });
  };
  const sumas = (lineas: any[]) => ({
    debe: lineas.reduce((t, l) => t + l.debe_moneda, 0),
    haber: lineas.reduce((t, l) => t + l.haber_moneda, 0),
  });

  it('pago USD usa la de la fecha de pago', async () => {
    const service = crearServicio({ liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) } });
    conDevengamiento(service, { haber_moneda: 500, haber_pyg: 500 * 7300 });

    const r = await service.integrarPagoComisiones('liq-1', 'emp-1', new Date('2026-10-20T00:00:00Z'));

    expect(r).toEqual({});
    expect(service.tipoCambio.getVigente).toHaveBeenCalledWith('emp-1', 'USD', new Date('2026-10-20'));
    const dto = dtoAsiento(service);
    expect(dto).toMatchObject({ fecha: '2026-10-20', moneda_origen: 'PYG' });
    expect(dto.lineas.map((l: any) => [l.cuenta_id, l.debe_moneda, l.haber_moneda])).toEqual([
      [cuentaDe('COMISIONES_A_PAGAR'), 3650000, 0],
      [cuentaDe('PAGO_COMISIONES_FONDOS'), 0, 3650000],
    ]);
  });

  it('pago USD con la cotización en suba (7000 → 7300): diferencia de cambio perdida de 300 × monto', async () => {
    const service = crearServicio({ liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) } });
    conDevengamiento(service, { haber_moneda: 500, haber_pyg: 500 * 7000 });
    tasasPorDia(service, { '2026-10-20': 7300 });

    await service.integrarPagoComisiones('liq-1', 'emp-1', new Date('2026-10-20T00:00:00Z'));

    const lineas = dtoAsiento(service).lineas;
    expect(dtoAsiento(service).moneda_origen).toBe('PYG');
    expect(lineas.map((l: any) => [l.cuenta_id, l.debe_moneda, l.haber_moneda])).toEqual([
      [cuentaDe('COMISIONES_A_PAGAR'), 3500000, 0],
      [cuentaDe('PAGO_COMISIONES_FONDOS'), 0, 3650000],
      [cuentaDe('DIFERENCIA_CAMBIO_PERDIDA'), 150000, 0],
    ]);
    const t = sumas(lineas);
    expect(t.debe).toBe(t.haber);
  });

  it('pago USD con la cotización en baja (7300 → 7000): diferencia de cambio ganada', async () => {
    const service = crearServicio({ liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) } });
    conDevengamiento(service, { haber_moneda: 500, haber_pyg: 500 * 7300 });
    tasasPorDia(service, { '2026-10-20': 7000 });

    await service.integrarPagoComisiones('liq-1', 'emp-1', new Date('2026-10-20T00:00:00Z'));

    const lineas = dtoAsiento(service).lineas;
    expect(lineas.map((l: any) => [l.cuenta_id, l.debe_moneda, l.haber_moneda])).toEqual([
      [cuentaDe('COMISIONES_A_PAGAR'), 3650000, 0],
      [cuentaDe('PAGO_COMISIONES_FONDOS'), 0, 3500000],
      [cuentaDe('DIFERENCIA_CAMBIO_GANADA'), 0, 150000],
    ]);
    const t = sumas(lineas);
    expect(t.debe).toBe(t.haber);
  });

  it('pago USD sin asiento de devengamiento: la deuda se valúa a la cotización del día de la liquidación', async () => {
    const service = crearServicio({ liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) } });
    conDevengamiento(service, null);
    tasasPorDia(service, { '2026-10-05': 7000, '2026-10-20': 7300 });

    await service.integrarPagoComisiones('liq-1', 'emp-1', new Date('2026-10-20T00:00:00Z'));

    expect(dtoAsiento(service).lineas.map((l: any) => [l.cuenta_id, l.debe_moneda, l.haber_moneda])).toEqual([
      [cuentaDe('COMISIONES_A_PAGAR'), 3500000, 0],
      [cuentaDe('PAGO_COMISIONES_FONDOS'), 0, 3650000],
      [cuentaDe('DIFERENCIA_CAMBIO_PERDIDA'), 150000, 0],
    ]);
  });

  it('pago USD sin devengamiento ni cotización de ese día: todo a la del pago, sin diferencia', async () => {
    const service = crearServicio({ liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) } });
    conDevengamiento(service, null);
    tasasPorDia(service, { '2026-10-20': 7300 });

    await service.integrarPagoComisiones('liq-1', 'emp-1', new Date('2026-10-20T00:00:00Z'));

    expect(dtoAsiento(service).lineas.map((l: any) => [l.cuenta_id, l.debe_moneda, l.haber_moneda])).toEqual([
      [cuentaDe('COMISIONES_A_PAGAR'), 3650000, 0],
      [cuentaDe('PAGO_COMISIONES_FONDOS'), 0, 3650000],
    ]);
  });

  it('pago PYG sigue igual que hoy: sin diferencia de cambio ni búsqueda del devengamiento', async () => {
    const service = crearServicio({
      liquidaciones_comisiones: {
        findUnique: jest.fn().mockResolvedValue(liquidacion({ total_comisiones: '150000', moneda_id: PYG.id, moneda: PYG })),
      },
    });

    await service.integrarPagoComisiones('liq-1', 'emp-1', new Date('2026-10-20T00:00:00Z'));

    expect(service.tipoCambio.getVigente).not.toHaveBeenCalled();
    expect(service.prisma.cont_documentos.findFirst).toHaveBeenCalledTimes(1);
    const dto = dtoAsiento(service);
    expect(dto).toMatchObject({ fecha: '2026-10-20', moneda_origen: 'PYG', glosa: 'Pago comisiones — Ana Gómez' });
    expect(dto.lineas).toMatchObject([
      { cuenta_id: cuentaDe('COMISIONES_A_PAGAR'), debe_moneda: 150000, haber_moneda: 0, descripcion: 'Cancelación comisiones a pagar' },
      { cuenta_id: cuentaDe('PAGO_COMISIONES_FONDOS'), debe_moneda: 0, haber_moneda: 150000, descripcion: 'Salida de fondos' },
    ]);
  });

  it("sin cotización: no asienta y devuelve 'Sin asiento: falta la cotización USD del 05/10/2026'", async () => {
    const service = crearServicio({ liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) } }, null);

    const r = await service.integrarDevengamientoComisiones('liq-1', 'emp-1');

    expect(r).toEqual({ advertencia: 'Sin asiento: falta la cotización USD del 05/10/2026' });
    expect(service.asientos.crearConfirmado).not.toHaveBeenCalled();
    expect(service.prisma.cont_documentos.create).not.toHaveBeenCalled();
  });

  it('sin cotización en el pago: avisa con la fecha de pago', async () => {
    const service = crearServicio({ liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) } }, null);

    const r = await service.integrarPagoComisiones('liq-1', 'emp-1', new Date('2026-10-20T00:00:00Z'));

    expect(r).toEqual({ advertencia: 'Sin asiento: falta la cotización USD del 20/10/2026' });
    expect(service.asientos.crearConfirmado).not.toHaveBeenCalled();
  });

  it('PYG sigue igual que hoy', async () => {
    const service = crearServicio({
      liquidaciones_comisiones: {
        findUnique: jest.fn().mockResolvedValue(liquidacion({ total_comisiones: '150000', moneda_id: PYG.id, moneda: PYG })),
      },
    });

    const r = await service.integrarDevengamientoComisiones('liq-1', 'emp-1');

    expect(r).toEqual({});
    expect(service.tipoCambio.getVigente).not.toHaveBeenCalled();
    const dto = dtoAsiento(service);
    expect(dto).toMatchObject({ fecha: '2026-10-05', moneda_origen: 'PYG' });
    expect(dto.lineas.map((l: any) => [l.debe_moneda, l.haber_moneda])).toEqual([
      [150000, 0],
      [0, 150000],
    ]);
  });

  it('liquidación vieja sin moneda: PYG como hoy', async () => {
    const service = crearServicio({
      liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion({ moneda_id: null, moneda: null })) },
    });

    await service.integrarPagoComisiones('liq-1', 'emp-1', new Date('2026-10-20T00:00:00Z'));

    expect(service.tipoCambio.getVigente).not.toHaveBeenCalled();
    expect(dtoAsiento(service).moneda_origen).toBe('PYG');
  });

  // C1 de la revisión final: la moneda funcional contable es PYG aunque la empresa tenga USD como principal.
  it('empresa con base USD: una liquidación en USD se asienta en USD con la cotización', async () => {
    const service = crearServicio({
      liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) },
      empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda: { ...USD, simbolo: 'US$' } }) },
    });

    const r = await service.integrarDevengamientoComisiones('liq-1', 'emp-1');

    expect(r).toEqual({});
    expect(service.tipoCambio.getVigente).toHaveBeenCalledWith('emp-1', 'USD', new Date('2026-10-05'));
    expect(dtoAsiento(service).moneda_origen).toBe('USD');
  });

  it('empresa con base USD: el pago en USD también va a la cotización (no como guaraníes)', async () => {
    const service = crearServicio({
      liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) },
      empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda: { ...USD, simbolo: 'US$' } }) },
    });
    conDevengamiento(service, { haber_moneda: 500, haber_pyg: 500 * 7300 });

    await service.integrarPagoComisiones('liq-1', 'emp-1', new Date('2026-10-20T00:00:00Z'));

    expect(dtoAsiento(service).lineas.map((l: any) => [l.debe_moneda, l.haber_moneda])).toEqual([
      [3650000, 0],
      [0, 3650000],
    ]);
  });

  // I4 de la revisión final: sin la cuenta de diferencia de cambio, no asienta y avisa.
  it('pago USD con diferencia de cambio y sin la cuenta mapeada: no asienta y avisa', async () => {
    const service = crearServicio({ liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) } });
    conDevengamiento(service, { haber_moneda: 500, haber_pyg: 500 * 7000 });
    tasasPorDia(service, { '2026-10-20': 7300 });
    service.mapeo.getCuentaPorConcepto.mockImplementation((e: string, c: string) =>
      c.startsWith('DIFERENCIA_CAMBIO') ? Promise.reject(new FaltaMapeoError(e, [c])) : Promise.resolve(cuentaDe(c)),
    );

    const r = await service.integrarPagoComisiones('liq-1', 'emp-1', new Date('2026-10-20T00:00:00Z'));

    // Como todo el motor (spec 2026-10-13): queda el aviso de mapeo y vuelve la advertencia.
    expect(r).toEqual({ advertencia: 'Sin asiento: falta mapear DIFERENCIA_CAMBIO_PERDIDA (Contabilidad → Mapeo de cuentas)' });
    expect(service.avisosMapeo.registrarFaltaMapeo).toHaveBeenCalledWith(
      expect.objectContaining({ empresaId: 'emp-1', origenTipo: 'liquidacion_comisiones_pago', origenId: 'liq-1', conceptos: ['DIFERENCIA_CAMBIO_PERDIDA'] }),
    );
    expect(service.asientos.crearConfirmado).not.toHaveBeenCalled();
    expect(service.prisma.cont_documentos.create).not.toHaveBeenCalled();
  });

  // Merge con pos (reglas de cuenta por dimensión): la dimensión MONEDA es la de la liquidación, no PYG fijo.
  it('las reglas por dimensión MONEDA se evalúan con la moneda de la liquidación', async () => {
    const service = crearServicio({ liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) } });
    const regla = {
      id: 'r-usd', concepto: 'GASTO_COMISIONES_VENTAS', orden: 1, modo: 'CUENTA', cuenta_id: 'cta-COM_USD', estado: 'ACTIVA',
      vigente_desde: new Date('2026-01-01'), vigente_hasta: null, condiciones: [{ dimension: 'MONEDA', operador: 'EN', valores: ['USD'] }],
    } as any;
    service.mapeo = conResolvedor({ getCuentaPorConcepto: jest.fn().mockImplementation((_e: string, c: string) => Promise.resolve(cuentaDe(c))) }, [regla]);

    await service.integrarDevengamientoComisiones('liq-1', 'emp-1');

    expect(dtoAsiento(service).lineas.map((l: any) => [l.cuenta_id, l.mapeo_nivel])).toEqual([
      ['cta-COM_USD', 'REGLA'],
      [cuentaDe('COMISIONES_A_PAGAR'), 'DEFECTO'],
    ]);
  });

  describe('comisión de supervisor', () => {
    const comision = (over: any = {}) => ({
      id: 'cs-1',
      total_comision: '80',
      updated_at: new Date('2026-10-17T13:00:00Z'),
      created_at: new Date('2026-10-01T13:00:00Z'),
      supervisor: { nombre: 'Luis', apellido: 'Paz' },
      moneda_id: USD.id,
      moneda: USD,
      ...over,
    });

    it('USD usa la cotización de la fecha en que se liquida', async () => {
      const service = crearServicio({ comisiones_supervisores: { findUnique: jest.fn().mockResolvedValue(comision()) } });

      const r = await service.integrarComisionSupervisor('cs-1', 'emp-1');

      expect(r).toEqual({});
      expect(service.tipoCambio.getVigente).toHaveBeenCalledWith('emp-1', 'USD', new Date('2026-10-17'));
      const dto = dtoAsiento(service);
      expect(dto).toMatchObject({ fecha: '2026-10-17', moneda_origen: 'USD' });
      expect(dto.lineas.map((l: any) => [l.cuenta_id, l.debe_moneda, l.haber_moneda])).toEqual([
        [cuentaDe('GASTO_COMISIONES_VENTAS'), 80, 0],
        [cuentaDe('PAGO_COMISIONES_FONDOS'), 0, 80],
      ]);
    });

    // I3 de la revisión final: liquidar de nuevo tras anular no puede asentar otra vez (índice único).
    it('con el asiento anterior revertido: no asienta y avisa', async () => {
      const service = crearServicio({ comisiones_supervisores: { findUnique: jest.fn().mockResolvedValue(comision()) } });
      service.prisma.cont_documentos.findFirst.mockResolvedValue({ id: 'doc-viejo', estado: 'REVERTIDO' });

      const r = await service.integrarComisionSupervisor('cs-1', 'emp-1');

      expect(r).toEqual({ advertencia: 'Sin asiento: esta comisión ya tuvo un asiento que se revirtió; asentala a mano en Contabilidad' });
      expect(service.asientos.crearConfirmado).not.toHaveBeenCalled();
    });

    it('con el asiento ya confirmado: no lo repite ni avisa', async () => {
      const service = crearServicio({ comisiones_supervisores: { findUnique: jest.fn().mockResolvedValue(comision()) } });
      service.prisma.cont_documentos.findFirst.mockResolvedValue({ id: 'doc-viejo', estado: 'CONFIRMADO' });

      expect(await service.integrarComisionSupervisor('cs-1', 'emp-1')).toEqual({});
      expect(service.asientos.crearConfirmado).not.toHaveBeenCalled();
    });

    it('sin cotización: no asienta y avisa', async () => {
      const service = crearServicio({ comisiones_supervisores: { findUnique: jest.fn().mockResolvedValue(comision()) } }, null);

      const r = await service.integrarComisionSupervisor('cs-1', 'emp-1');

      expect(r).toEqual({ advertencia: 'Sin asiento: falta la cotización USD del 17/10/2026' });
      expect(service.asientos.crearConfirmado).not.toHaveBeenCalled();
    });

    it('PYG sigue igual que hoy', async () => {
      const service = crearServicio({
        comisiones_supervisores: { findUnique: jest.fn().mockResolvedValue(comision({ moneda_id: PYG.id, moneda: PYG })) },
      });

      await service.integrarComisionSupervisor('cs-1', 'emp-1');

      expect(service.tipoCambio.getVigente).not.toHaveBeenCalled();
      expect(dtoAsiento(service).moneda_origen).toBe('PYG');
    });
  });
});

// Minor 1 de la revisión: el circuito completo con el `crearConfirmado` real y `TipoCambioService` real
// (solo Prisma mockeado), para ver los guaraníes y el tipo_cambio_id que quedan grabados.
describe('asientos de comisiones con el motor real', () => {
  const { AsientosService } = jest.requireActual('./asientos.service');
  const { TipoCambioService } = jest.requireActual('./tipo-cambio.service');

  const motor = (tasas: Record<string, number>) => {
    const grabados: any[] = [];
    const tcPorDia = (where: any) => {
      const dia = (where.fecha.lte as Date).toISOString().substring(0, 10);
      return tasas[dia] ? { id: `tc-${dia}`, moneda: where.moneda, fecha: where.fecha.lte, tasa: tasas[dia] } : null;
    };
    const prisma: any = {
      cont_tipo_cambio: { findFirst: jest.fn().mockImplementation(({ where }: any) => Promise.resolve(tcPorDia(where))) },
      cont_asientos: {
        findFirst: jest.fn().mockResolvedValue(null),
        create: jest.fn().mockImplementation(({ data }: any) => {
          grabados.push(data);
          return Promise.resolve({ id: 'as-1', numero: 1 });
        }),
      },
    };
    const tipoCambio = new TipoCambioService(prisma, { log: jest.fn() });
    const asientos = new AsientosService(prisma, {}, tipoCambio, { log: jest.fn() });
    return { prisma, tipoCambio, asientos, grabados };
  };

  it('devengamiento USD: graba los guaraníes a la cotización del día y su tipo_cambio_id', async () => {
    const m = motor({ '2026-10-05': 7000 });
    const service = crearServicio({ liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) } });
    service.tipoCambio = m.tipoCambio;
    service.asientos = m.asientos;
    service.prisma.cont_tipo_cambio = m.prisma.cont_tipo_cambio;
    service.prisma.cont_asientos = m.prisma.cont_asientos;

    await service.integrarDevengamientoComisiones('liq-1', 'emp-1');

    const a = m.grabados[0];
    expect(a).toMatchObject({ moneda_origen: 'USD', tipo_cambio_id: 'tc-2026-10-05', total_debe_pyg: 3500000, total_haber_pyg: 3500000 });
    expect(a.lineas.create.map((l: any) => [l.debe_moneda, l.haber_moneda, l.debe_pyg, l.haber_pyg])).toEqual([
      [500, 0, 3500000, 0],
      [0, 500, 0, 3500000],
    ]);
  });

  it('pago USD: el asiento grabado cuadra en guaraníes con la diferencia de cambio', async () => {
    const m = motor({ '2026-10-20': 7300 });
    const service = crearServicio({ liquidaciones_comisiones: { findUnique: jest.fn().mockResolvedValue(liquidacion()) } });
    service.tipoCambio = m.tipoCambio;
    service.asientos = m.asientos;
    service.prisma.cont_tipo_cambio = m.prisma.cont_tipo_cambio;
    service.prisma.cont_asientos = m.prisma.cont_asientos;
    service.prisma.cont_documentos.findFirst.mockImplementation(({ where }: any) =>
      Promise.resolve(
        where.estado === 'CONFIRMADO'
          ? { id: 'doc-dev', asiento: { moneda_origen: 'USD', lineas: [{ haber_moneda: 500, haber_pyg: 3500000 }] } }
          : null,
      ),
    );

    await service.integrarPagoComisiones('liq-1', 'emp-1', new Date('2026-10-20T00:00:00Z'));

    const a = m.grabados[0];
    expect(a).toMatchObject({ moneda_origen: 'PYG', total_debe_pyg: 3650000, total_haber_pyg: 3650000 });
    expect(a.lineas.create.map((l: any) => [l.cuenta_id, l.debe_pyg, l.haber_pyg])).toEqual([
      [cuentaDe('COMISIONES_A_PAGAR'), 3500000, 0],
      [cuentaDe('PAGO_COMISIONES_FONDOS'), 0, 3650000],
      [cuentaDe('DIFERENCIA_CAMBIO_PERDIDA'), 150000, 0],
    ]);
  });
});
