import { crearIntegracionMock } from './__helpers__/integracion-mock';

/**
 * S3: `integrarTransferenciaTes` dice qué pasó con el asiento (antes, cada salida era un `return;` mudo) y arma el asiento de
 * moneda extranjera → PYG con la diferencia del lado correcto (D12) y las glosas «TC banco» / «TC sistema» donde van (F10).
 */
const fecha = new Date('2026-10-13');
const mov = (id: string, monto: number, cuenta: Record<string, unknown>) => ({ id, fecha, monto, created_by: null, referencia: null, descripcion: null, cuenta });
const PYG = { cuenta_contable_id: 'cta-banco-gs', moneda: 'PYG', nombre: 'Banco Gs' };
const USD = { cuenta_contable_id: 'cta-banco-usd', moneda: 'USD', nombre: 'Banco USD' };

const integrador = (movs: Record<string, unknown>, tasa: number | null = 7300, faltan: string[] = []) =>
  crearIntegracionMock(
    {
      tes_movimientos: { findUnique: jest.fn().mockImplementation(({ where }: any) => Promise.resolve(movs[where.id] ?? null)) },
      cont_tipo_cambio: { findFirst: jest.fn().mockResolvedValue(tasa === null ? null : { tasa }) },
      // La guarda por estado dentro de la transacción: los dos movimientos siguen CONFIRMADO.
      $queryRaw: jest.fn().mockResolvedValue([{ id: 'mo' }, { id: 'md' }]),
    },
    faltan,
  );
const lineas = (s: any) => s.asientos.crearConfirmado.mock.calls[0][3].lineas as Array<Record<string, any>>;

describe('integrarTransferenciaTes — resultado', () => {
  const pygUsd = () => ({ mo: mov('mo', 7_446_000, PYG), md: mov('md', 1_000, USD) });

  it('sin el módulo → SIN_MODULO', async () => {
    const s = integrador(pygUsd());
    s.tieneModuloContabilidad.mockResolvedValue(false);
    expect(await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp')).toEqual({ generado: false, motivo: 'SIN_MODULO' });
  });

  it('documento existente → { generado: true } sin crear otro', async () => {
    const s = integrador(pygUsd());
    s.prisma.cont_documentos.findFirst.mockResolvedValue({ id: 'doc' });
    expect(await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp')).toEqual({ generado: true });
    expect(s.asientos.crearConfirmado).not.toHaveBeenCalled();
  });

  it('la cuenta destino «Banco USD» sin cuenta contable → CUENTA_SIN_CUENTA_CONTABLE con su nombre', async () => {
    const s = integrador({ mo: mov('mo', 7_446_000, PYG), md: mov('md', 1_000, { ...USD, cuenta_contable_id: null }) });
    expect(await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp')).toEqual({ generado: false, motivo: 'CUENTA_SIN_CUENTA_CONTABLE', cuenta: 'Banco USD' });
  });

  it('las dos sin cuenta contable → la de origen primero', async () => {
    const s = integrador({ mo: mov('mo', 7_446_000, { ...PYG, cuenta_contable_id: null }), md: mov('md', 1_000, { ...USD, cuenta_contable_id: null }) });
    expect(await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp')).toMatchObject({ cuenta: 'Banco Gs' });
  });

  it('sin período abierto → SIN_PERIODO_ABIERTO', async () => {
    const s = integrador(pygUsd());
    s.periodos.resolverPeriodoPorFecha.mockRejectedValue(new Error('No hay período'));
    expect(await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp')).toEqual({ generado: false, motivo: 'SIN_PERIODO_ABIERTO' });
  });

  it('crea el asiento → { generado: true }', async () => {
    const s = integrador(pygUsd());
    expect(await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp')).toEqual({ generado: true });
    expect(s.asientos.crearConfirmado).toHaveBeenCalledTimes(1);
  });

  it('un movimiento que no existe → lanza con MOVIMIENTO_NO_ENCONTRADO', async () => {
    const s = integrador({ mo: mov('mo', 7_446_000, PYG) });
    await expect(s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp')).rejects.toMatchObject({ response: { codigo: 'MOVIMIENTO_NO_ENCONTRADO' } });
  });

  it('falta el concepto de la diferencia → undefined (constancia de falta de mapeo)', async () => {
    const s = integrador(pygUsd(), 7300, ['DIFERENCIA_CAMBIO_PERDIDA']);
    expect(await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp')).toBeUndefined();
    expect(s.avisosMapeo.registrarFaltaMapeo).toHaveBeenCalledTimes(1);
  });
});

describe('integrarTransferenciaTes — asiento con diferencia de cambio (D12, F10)', () => {
  it('USD → PYG: US$ 1.000, Gs. 7.446.000 y TC del sistema 7.300 → origen al haber por 7.300.000, destino al debe por 7.446.000 y ganancia de 146.000', async () => {
    const s = integrador({ mo: mov('mo', 1_000, USD), md: mov('md', 7_446_000, PYG) });
    await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp');
    const [origen, destino, dif] = lineas(s);
    expect(origen).toMatchObject({ cuenta_id: 'cta-banco-usd', debe_moneda: 0, haber_moneda: 7_300_000 });
    expect(destino).toMatchObject({ cuenta_id: 'cta-banco-gs', debe_moneda: 7_446_000, haber_moneda: 0 });
    expect(dif).toMatchObject({ cuenta_id: 'cta-DIFERENCIA_CAMBIO_GANADA', debe_moneda: 0, haber_moneda: 146_000, mapeo_concepto: 'DIFERENCIA_CAMBIO_GANADA' });
  });

  it('PYG → USD con los mismos números → origen al haber por 7.446.000, destino al debe por 7.300.000 y pérdida de 146.000 (sin cambio)', async () => {
    const s = integrador({ mo: mov('mo', 7_446_000, PYG), md: mov('md', 1_000, USD) });
    await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp');
    const [origen, destino, dif] = lineas(s);
    expect(origen).toMatchObject({ cuenta_id: 'cta-banco-gs', debe_moneda: 0, haber_moneda: 7_446_000 });
    expect(destino).toMatchObject({ cuenta_id: 'cta-banco-usd', debe_moneda: 7_300_000, haber_moneda: 0 });
    expect(dif).toMatchObject({ cuenta_id: 'cta-DIFERENCIA_CAMBIO_PERDIDA', debe_moneda: 146_000, haber_moneda: 0, mapeo_concepto: 'DIFERENCIA_CAMBIO_PERDIDA' });
  });

  it('glosas: en USD → PYG «TC banco» va en el destino (el importe real) y «TC sistema» en el origen', async () => {
    const s = integrador({ mo: mov('mo', 1_000, USD), md: mov('md', 7_446_000, PYG) });
    await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp');
    const [origen, destino] = lineas(s);
    expect(destino.descripcion).toContain('TC banco');
    expect(origen.descripcion).toContain('TC sistema');
    expect(origen.descripcion).not.toContain('TC banco');
  });

  it('glosas: en PYG → USD al revés («TC banco» en el origen, «TC sistema» en el destino)', async () => {
    const s = integrador({ mo: mov('mo', 7_446_000, PYG), md: mov('md', 1_000, USD) });
    await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp');
    const [origen, destino] = lineas(s);
    expect(origen.descripcion).toContain('TC banco');
    expect(destino.descripcion).toContain('TC sistema');
  });

  it('el asiento cuadra en los dos sentidos', async () => {
    for (const movs of [
      { mo: mov('mo', 1_000, USD), md: mov('md', 7_446_000, PYG) },
      { mo: mov('mo', 7_446_000, PYG), md: mov('md', 1_000, USD) },
    ]) {
      const s = integrador(movs);
      await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp');
      const ls = lineas(s);
      const debe = ls.reduce((a, l) => a + l.debe_moneda, 0);
      const haber = ls.reduce((a, l) => a + l.haber_moneda, 0);
      expect(debe).toBe(haber);
    }
  });

  it('sin TC del sistema: dos líneas por los guaraníes reales', async () => {
    const s = integrador({ mo: mov('mo', 1_000, USD), md: mov('md', 7_446_000, PYG) }, null);
    await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp');
    const ls = lineas(s);
    expect(ls).toHaveLength(2);
    expect(ls[0]).toMatchObject({ haber_moneda: 7_446_000 });
    expect(ls[1]).toMatchObject({ debe_moneda: 7_446_000 });
  });
});

describe('integrarTransferenciaTes — misma moneda extranjera (ronda 1)', () => {
  const USD2 = { cuenta_contable_id: 'cta-banco-usd-2', moneda: 'USD', nombre: 'Banco USD 2' };

  it('USD → USD de US$ 1.000 con la cotización 7.300 → dos líneas por Gs. 7.300.000, en guaraníes y sin diferencia', async () => {
    const s = integrador({ mo: mov('mo', 1_000, USD), md: mov('md', 1_000, USD2) });
    s.tipoCambio.getTasa.mockResolvedValue(7300);
    expect(await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp')).toEqual({ generado: true });
    expect(s.tipoCambio.getTasa).toHaveBeenCalledWith('emp', 'USD', fecha);
    const ls = lineas(s);
    expect(ls).toHaveLength(2);
    expect(ls[0]).toMatchObject({ cuenta_id: 'cta-banco-usd', debe_moneda: 0, haber_moneda: 7_300_000 });
    expect(ls[1]).toMatchObject({ cuenta_id: 'cta-banco-usd-2', debe_moneda: 7_300_000, haber_moneda: 0 });
    expect(s.asientos.crearConfirmado.mock.calls[0][3].moneda_origen).toBe('PYG');
  });

  it('USD → USD sin cotización → TIPO_CAMBIO_NO_REGISTRADO con el mensaje de getTasa, sin asiento', async () => {
    const s = integrador({ mo: mov('mo', 1_000, USD), md: mov('md', 1_000, USD2) });
    s.tipoCambio.getTasa.mockRejectedValue(new Error('No hay tipo de cambio registrado para USD en la fecha 2026-10-13'));
    await expect(s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp')).rejects.toMatchObject({
      status: 404,
      response: { codigo: 'TIPO_CAMBIO_NO_REGISTRADO', message: 'No hay tipo de cambio registrado para USD en la fecha 2026-10-13' },
    });
    expect(s.asientos.crearConfirmado).not.toHaveBeenCalled();
  });

  it('PYG → PYG no pide cotización', async () => {
    const s = integrador({ mo: mov('mo', 5_000, PYG), md: mov('md', 5_000, { ...PYG, cuenta_contable_id: 'cta-banco-gs-2' }) });
    await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp');
    expect(s.tipoCambio.getTasa).not.toHaveBeenCalled();
    expect(lineas(s)[0]).toMatchObject({ haber_moneda: 5_000 });
  });
});

describe('integrarTransferenciaTes — guarda por estado en la transacción (ronda 1)', () => {
  const pygUsd = () => ({ mo: mov('mo', 7_446_000, PYG), md: mov('md', 1_000, USD) });

  it('bloquea los dos movimientos CONFIRMADO con FOR UPDATE antes de crear el documento', async () => {
    const s = integrador(pygUsd());
    await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp');
    const sql = (s.prisma.$queryRaw.mock.calls[0][0] as string[]).join('?');
    expect(sql).toContain("estado = 'CONFIRMADO'");
    expect(sql).toMatch(/ORDER BY id\s+FOR UPDATE/);
    expect(s.prisma.$queryRaw.mock.calls[0].slice(1)).toEqual(['mo', 'md']);
  });

  it('anulada entre la lectura y el asiento → 400 TRANSFERENCIA_ANULADA y sin documento', async () => {
    const s = integrador(pygUsd());
    s.prisma.$queryRaw.mockResolvedValue([]);
    await expect(s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp')).rejects.toMatchObject({ status: 400, response: { codigo: 'TRANSFERENCIA_ANULADA' } });
    expect(s.prisma.cont_documentos.create).not.toHaveBeenCalled();
    expect(s.asientos.crearConfirmado).not.toHaveBeenCalled();
  });

  it('otro reintento lo creó mientras esperaba el bloqueo → no crea un segundo documento', async () => {
    const s = integrador(pygUsd());
    s.prisma.cont_documentos.findFirst.mockResolvedValueOnce(null).mockResolvedValueOnce({ id: 'doc-del-otro' });
    expect(await s.integrarTransferenciaTes('mo', 'md', 'tr1', 'emp')).toEqual({ generado: true });
    expect(s.prisma.cont_documentos.create).not.toHaveBeenCalled();
  });
});
