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

/**
 * Spec OP/CxP (punto 6): una OP pagada con un medio que no mueve dinero (código 11 «Pago por anticipo», o el que la
 * empresa marcó con `empresa_medio_pago.no_mueve_caja`) acredita la cuenta «Al pagar» del medio, como el gasto
 * (`integrarGasto`), nunca un banco ni la caja: ni la cuenta de Tesorería de la línea ni la de la regla
 * «Pago a proveedor». La cuenta sale del mapeo (el contador la decide); sin ella no hay asiento y queda el aviso.
 */
const lineas = (s: any) => s.asientos.crearConfirmado.mock.calls[0][3].lineas;
const haber = (s: any) => lineas(s).filter((l: any) => l.haber_moneda > 0);

const orden = (det: any = {}) => ({
  id: 'op1',
  empresa_id: 'emp',
  sucursal_id: 'suc-1',
  estado: 'PAGADO',
  anulado: false,
  monto_total: 100,
  moneda: { codigo: 'PYG' },
  cotizacion: null,
  fecha_pago: new Date('2026-10-13'),
  numero_orden_pago: 'OP-1',
  proveedor_id: 'p1',
  usuario_id: 'u1',
  orden_pago_proveedor_det: [
    {
      monto: 100,
      medio_pago_id: 'mp-anticipo',
      medio_pago: { codigo: 11 },
      cuenta_bancaria_id: null,
      cuentas_pagar: { cuenta_pasivo_id: 'pas', compra_id: null },
      ...det,
    },
  ],
});

const base = (o: any, sinCajaEmpresa: string[] = []) => ({
  orden_pago_proveedor_cab: { findUnique: jest.fn().mockResolvedValue(o) },
  // La regla general de Tesorería «Pago a proveedor» apunta al banco: no es de donde sale este pago.
  tes_reglas: { findMany: jest.fn().mockResolvedValue([{ medio_pago_id: null, cuenta_id: 'tes-banco' }]) },
  tes_cuentas: {
    findMany: jest.fn().mockResolvedValue([
      { id: 'tes-banco', cuenta_contable_id: 'cta-banco' },
      { id: 'tes-elegida', cuenta_contable_id: 'cta-banco-elegido' },
    ]),
  },
  empresa_medio_pago: {
    findMany: jest.fn().mockResolvedValue(sinCajaEmpresa.map((medio_pago_id) => ({ medio_pago_id }))),
    findFirst: jest.fn().mockResolvedValue(null),
  },
  proveedores: { findFirst: jest.fn().mockResolvedValue({ tipo_entidad: 'PROVEEDOR', cuenta_contable_id: null }) },
});

describe('OP con medio sin caja: el HABER es la cuenta «Al pagar» del medio (regla de Gastos)', () => {
  it('OP con medio sin caja acredita la cuenta Al pagar del medio, no banco (Pago por anticipo, código 11)', async () => {
    const s = crear(base(orden()));
    s.mediosPago.resolverPorMedio.mockResolvedValue(new Map([['mp-anticipo', 'cta-anticipos']]));

    await s.integrarOrdenPago('op1');

    expect(haber(s).map((l: any) => [l.cuenta_id, l.haber_moneda, l.mapeo_nivel])).toEqual([
      ['cta-anticipos', 100, 'MEDIO_PAGO'],
    ]);
    expect(lineas(s).some((l: any) => ['cta-banco', 'cta-CAJA_GENERAL'].includes(l.cuenta_id))).toBe(false);
  });

  it('el medio que la empresa marcó no_mueve_caja tampoco sale del banco, aunque la línea traiga una cuenta de Tesorería', async () => {
    const s = crear(
      base(orden({ medio_pago_id: 'mp-otro', medio_pago: { codigo: 99 }, cuenta_bancaria_id: 'tes-elegida' }), [
        'mp-otro',
      ]),
    );
    s.mediosPago.resolverPorMedio.mockResolvedValue(new Map([['mp-otro', 'cta-otros-acreedores']]));

    await s.integrarOrdenPago('op1');

    expect(haber(s).map((l: any) => l.cuenta_id)).toEqual(['cta-otros-acreedores']);
  });

  it('sin la cuenta «Al pagar» del medio: no hay asiento, queda en borrador y avisa el mapeo (nunca cae a Caja)', async () => {
    const s = crear(base(orden()));
    s.mediosPago.resolverPorMedio.mockResolvedValue(new Map());

    await s.integrarOrdenPago('op1');

    expect(s.asientos.crearConfirmado).not.toHaveBeenCalled();
    expect(s.prisma.cont_documentos.upsert).toHaveBeenCalledWith(
      expect.objectContaining({ create: expect.objectContaining({ estado: 'BORRADOR' }) }),
    );
    expect(s.avisosMapeo.registrarFaltaMapeo).toHaveBeenCalledWith(
      expect.objectContaining({ origenTipo: 'orden_pago_proveedor_cab', origenId: 'op1' }),
    );
    const [[aviso]] = s.avisosMapeo.registrarFaltaMapeo.mock.calls;
    expect(JSON.stringify(aviso)).toContain('MEDIO_PAGO_PAGO');
  });

  it('una OP mixta: la línea sin caja va a su cuenta Al pagar y la de efectivo sigue saliendo de la cuenta de Tesorería', async () => {
    const o = orden();
    o.monto_total = 150;
    o.orden_pago_proveedor_det.push({
      monto: 50,
      medio_pago_id: 'mp-efectivo',
      medio_pago: { codigo: 1 },
      cuenta_bancaria_id: null,
      cuentas_pagar: { cuenta_pasivo_id: 'pas', compra_id: null },
    });
    const s = crear(base(o));
    s.mediosPago.resolverPorMedio.mockResolvedValue(new Map([['mp-anticipo', 'cta-anticipos']]));

    await s.integrarOrdenPago('op1');

    expect(
      haber(s)
        .map((l: any) => [l.cuenta_id, l.haber_moneda])
        .sort(),
    ).toEqual([
      ['cta-anticipos', 100],
      ['cta-banco', 50],
    ]);
  });
});
