import {
  FACTURAS_PYG,
  NOTAS_PYG,
  PYG_ID,
  USD_ID,
  EUR_ID,
  crearPrismaVentas,
  cumpleMoneda,
  servicioVentas,
  subtotalVenta,
} from './__helpers__/libro-iva-ventas-mock';

/**
 * Liquidación de IVA (carril A, T2). Primero la caracterización: la salida de siempre fijada con el código anterior al
 * cambio, con documentos de una sola moneda. Débito del Libro IVA ventas (150.000), crédito de compras neto de NC y
 * retenciones recibidas declaradas y pendientes.
 */

const filtrar = (docs: any[]) => (a: any) => Promise.resolve(docs.filter((d) => cumpleMoneda(a?.where, d.moneda_id ?? null)));

const compra = (s: Record<string, unknown>) => ({
  moneda_id: PYG_ID,
  cotizacion: 1,
  moneda: { codigo: 'PYG' },
  total_gravado_10: 0,
  total_gravado_5: 0,
  total_exento: 0,
  total_iva_10: 0,
  total_iva_5: 0,
  total: 0,
  ...s,
});

const COMPRAS = [
  compra({ total_gravado_10: 300000, total_iva_10: 30000, total_gravado_5: 100000, total_iva_5: 5000, total_exento: 20000, total: 455000 }),
  compra({ moneda_id: null, moneda: null, total_gravado_10: 100000, total_iva_10: 10000, total: 110000 }),
];
const NC_COMPRAS = [{ moneda_id: PYG_ID, cotizacion: 1, moneda: { codigo: 'PYG' }, total_iva_10: 5000, total_iva_5: 0, total: 55000 }];
const RETENCIONES = [
  { monto: 20000, declarada_set: true, recibo: { moneda_id: PYG_ID, cotizacion: null, moneda: { codigo: 'PYG' } } },
  { monto: 5000, declarada_set: false, recibo: { moneda_id: null, cotizacion: null, moneda: null } },
];

const preparar = (compras = COMPRAS, ncCompras = NC_COMPRAS, retenciones = RETENCIONES, facturas = FACTURAS_PYG) => {
  const prisma: any = crearPrismaVentas(facturas, NOTAS_PYG);
  prisma.compra_cab.findMany = jest.fn(filtrar(compras));
  prisma.nota_credito_compra_cab.findMany = jest.fn(filtrar(ncCompras));
  prisma.recibo_cobro_retenciones.findMany = jest.fn().mockResolvedValue(retenciones);
  return { prisma, service: servicioVentas(prisma) };
};

const DEBITO = {
  cantidad_facturas: 2,
  cantidad_nc: 1,
  gravada_10: 1400000,
  gravada_5: 200000,
  exentas: 50000,
  iva_10: 140000,
  iva_5: 10000,
  total_iva: 150000,
  total_operaciones: 1800000,
};

describe('FacturasService.getLiquidacionIva — caracterización de los campos de siempre', () => {
  it('A_PAGAR: débito del libro de ventas, crédito de compras menos NC y retenciones declaradas/pendientes', async () => {
    const { service } = preparar();
    const r = await service.getLiquidacionIva('emp-1', 10, 2026, undefined, '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.debito_fiscal).toEqual(DEBITO);
    expect(r.credito_fiscal).toEqual({
      cantidad_compras: 2,
      cantidad_nc: 1,
      gravada_10: 400000,
      gravada_5: 100000,
      exentas: 20000,
      iva_10: 35000,
      iva_5: 5000,
      total_iva: 40000,
      total_operaciones: 510000,
    });
    expect(r.retenciones_recibidas).toEqual({ cantidad: 2, monto_total: 25000, monto_declaradas: 20000, monto_pendientes: 5000 });
    expect(r.liquidacion).toEqual({
      saldo_iva_10: 105000,
      saldo_iva_5: 5000,
      saldo_antes_retenciones: 110000,
      retenciones_iva: 25000,
      saldo_total: 85000,
      resultado: 'A_PAGAR',
      es_a_pagar: true,
      es_a_favor: false,
    });
  });

  it('A_FAVOR cuando el crédito y las retenciones superan al débito', async () => {
    const { service } = preparar([compra({ total_gravado_10: 2000000, total_iva_10: 200000, total: 2200000 })], []);
    const r = await service.getLiquidacionIva('emp-1', 10, 2026, undefined, 'usr-1');

    expect(r.credito_fiscal).toMatchObject({ cantidad_compras: 1, cantidad_nc: 0, iva_10: 200000, iva_5: 0, total_iva: 200000 });
    expect(r.liquidacion).toEqual({
      saldo_iva_10: -60000,
      saldo_iva_5: 10000,
      saldo_antes_retenciones: -50000,
      retenciones_iva: 25000,
      saldo_total: -75000,
      resultado: 'A_FAVOR',
      es_a_pagar: false,
      es_a_favor: true,
    });
  });

  it('CERO cuando débito = crédito + retenciones', async () => {
    const { service } = preparar([compra({ total_gravado_10: 1300000, total_iva_10: 130000, total: 1430000 })]);
    const r = await service.getLiquidacionIva('emp-1', 10, 2026, undefined, 'usr-1');

    expect(r.liquidacion).toMatchObject({ saldo_antes_retenciones: 25000, saldo_total: 0, resultado: 'CERO', es_a_pagar: false, es_a_favor: false });
  });

  it('con moneda_id filtra ventas y compras por esa moneda exacta y las retenciones no se filtran (como hoy)', async () => {
    const { service } = preparar();
    const r = await service.getLiquidacionIva('emp-1', 10, 2026, PYG_ID, 'usr-1');

    expect(r.debito_fiscal).toMatchObject({ cantidad_facturas: 1, cantidad_nc: 1, iva_10: 90000, iva_5: 10000, total_iva: 100000 });
    expect(r.credito_fiscal).toMatchObject({ cantidad_compras: 1, cantidad_nc: 1, iva_10: 25000, iva_5: 5000, total_iva: 30000 });
    expect(r.retenciones_recibidas).toEqual({ cantidad: 2, monto_total: 25000, monto_declaradas: 20000, monto_pendientes: 5000 });
    expect(r.liquidacion).toMatchObject({ saldo_antes_retenciones: 70000, saldo_total: 45000, resultado: 'A_PAGAR' });
  });
});

/** Venta USD a 7500; compra USD a 7400 y otra USD con la cotización por defecto (1 = sin cotización); retención USD a 7500. */
const FAC_USD = {
  ...FACTURAS_PYG[0],
  id: 'fac-usd',
  moneda_id: USD_ID,
  dticam: 7500,
  moneda: { codigo: 'USD' },
  factura_subtotales: [subtotalVenta({ dbasegrav10: 100, diva10: 10, dtotope: 110, dtotalgs: 825000 })],
};
const COMPRAS_MIX = [
  ...COMPRAS,
  compra({ moneda_id: USD_ID, cotizacion: 7400, moneda: { codigo: 'USD' }, total_gravado_10: 100, total_iva_10: 10, total: 110 }),
  compra({ moneda_id: USD_ID, cotizacion: 1, moneda: { codigo: 'USD' }, total_gravado_10: 50, total_iva_10: 5, total: 55 }),
];
const RETENCIONES_MIX = [
  ...RETENCIONES,
  { monto: 2, declarada_set: false, recibo: { moneda_id: USD_ID, cotizacion: 7500, moneda: { codigo: 'USD' } } },
];
const mixto = () => preparar(COMPRAS_MIX, NC_COMPRAS, RETENCIONES_MIX, [...FACTURAS_PYG, FAC_USD]);

describe('FacturasService.getLiquidacionIva — moneda como el Tablero', () => {
  it('sin moneda_id: débito, crédito y retenciones convertidos con la cotización de cada documento; la liquidación sobre esos totales', async () => {
    const r = await mixto().service.getLiquidacionIva('emp-1', 10, 2026, undefined, '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).toEqual({
      debito_fiscal: {
        cantidad_facturas: 3,
        cantidad_nc: 1,
        gravada_10: 2150000,
        gravada_5: 200000,
        exentas: 50000,
        iva_10: 215000,
        iva_5: 10000,
        total_iva: 225000,
        total_operaciones: 2625000,
      },
      credito_fiscal: {
        cantidad_compras: 3,
        cantidad_nc: 1,
        gravada_10: 1140000,
        gravada_5: 100000,
        exentas: 20000,
        iva_10: 109000,
        iva_5: 5000,
        total_iva: 114000,
        total_operaciones: 1324000,
      },
      retenciones_recibidas: { cantidad: 3, monto_total: 40000, monto_declaradas: 20000, monto_pendientes: 20000 },
      liquidacion: {
        saldo_iva_10: 106000,
        saldo_iva_5: 5000,
        saldo_antes_retenciones: 111000,
        retenciones_iva: 40000,
        saldo_total: 71000,
        resultado: 'A_PAGAR',
        es_a_pagar: true,
        es_a_favor: false,
      },
    });
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', debito_fiscal: '150000.00', credito_fiscal: '40000.00', retenciones_recibidas: '25000.00', saldo_total: '85000.00' },
      { codigo: 'USD', debito_fiscal: '10.00', credito_fiscal: '15.00', retenciones_recibidas: '2.00', saldo_total: '-7.00' },
    ]);
  });

  it('los campos de siempre no cambian: suman crudo y las retenciones no se filtran, como hoy', async () => {
    const r = await mixto().service.getLiquidacionIva('emp-1', 10, 2026, undefined, 'usr-1');

    expect(r.debito_fiscal).toMatchObject({ cantidad_facturas: 3, iva_10: 140010, total_iva: 150010 });
    expect(r.credito_fiscal).toMatchObject({ cantidad_compras: 4, iva_10: 35015, total_iva: 40015 });
    expect(r.retenciones_recibidas).toEqual({ cantidad: 3, monto_total: 25002, monto_declaradas: 20000, monto_pendientes: 5002 });
    expect(r.liquidacion).toMatchObject({ saldo_antes_retenciones: 109995, saldo_total: 84993, resultado: 'A_PAGAR' });
  });

  it('con moneda_id USD: en_moneda solo con USD sin convertir; la retención en guaraníes y la sin moneda no entran', async () => {
    const r = await mixto().service.getLiquidacionIva('emp-1', 10, 2026, USD_ID, 'usr-1');

    expect(r.convertido).toBe(false);
    expect(r.moneda).toEqual({ id: USD_ID, codigo: 'USD' });
    expect(r.sin_cotizacion).toBe(0);
    expect(r.en_moneda.debito_fiscal).toMatchObject({ cantidad_facturas: 1, iva_10: 10, total_iva: 10 });
    expect(r.en_moneda.credito_fiscal).toMatchObject({ cantidad_compras: 2, cantidad_nc: 0, iva_10: 15, total_iva: 15 });
    expect(r.en_moneda.retenciones_recibidas).toEqual({ cantidad: 1, monto_total: 2, monto_declaradas: 0, monto_pendientes: 2 });
    expect(r.en_moneda.liquidacion).toMatchObject({ saldo_antes_retenciones: -5, saldo_total: -7, resultado: 'A_FAVOR', es_a_favor: true });
    // Los de siempre: filtrados por el id exacto, retenciones sin filtrar (como hoy).
    expect(r.credito_fiscal).toMatchObject({ cantidad_compras: 2, iva_10: 15 });
    expect(r.retenciones_recibidas.cantidad).toBe(3);
    expect(r.por_moneda).toEqual([
      { codigo: 'USD', debito_fiscal: '10.00', credito_fiscal: '15.00', retenciones_recibidas: '2.00', saldo_total: '-7.00' },
    ]);
  });

  it('con moneda_id de la base: la retención sin moneda cuenta como base; la USD no entra', async () => {
    const r = await mixto().service.getLiquidacionIva('emp-1', 10, 2026, PYG_ID, 'usr-1');

    expect(r.en_moneda.retenciones_recibidas).toEqual({ cantidad: 2, monto_total: 25000, monto_declaradas: 20000, monto_pendientes: 5000 });
    expect(r.en_moneda.credito_fiscal).toMatchObject({ cantidad_compras: 2, iva_10: 35000, iva_5: 5000, total_iva: 40000 });
    expect(r.en_moneda.debito_fiscal).toMatchObject({ cantidad_facturas: 2, total_iva: 150000 });
    expect(r.en_moneda.liquidacion).toMatchObject({ saldo_total: 85000, resultado: 'A_PAGAR' });
  });
});

describe('FacturasService.getLiquidacionIva — 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 { prisma, service } = mixto();
    await service.getLiquidacionIva('emp-1', 10, 2026, PYG_ID, 'usr-1');

    const where = prisma.nota_credito_compra_cab.findMany.mock.calls[0][0].where;
    expect(where.AND).toEqual([{ moneda_id: PYG_ID }]);
  });
});

describe('FacturasService.getLiquidacionIva — 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' } };
    const { service } = preparar(
      [...COMPRAS, compra({ ...eur, cotizacion: 8000, total_gravado_10: 100, total_iva_10: 10, total: 110 })],
      [...NC_COMPRAS, { ...eur, cotizacion: 8000, total_iva_10: 1, total_iva_5: 0, total: 11 }],
    );
    const r = await service.getLiquidacionIva('emp-1', 10, 2026, EUR_ID.toUpperCase(), 'usr-1');

    expect(r.credito_fiscal).toMatchObject({ cantidad_compras: 1, cantidad_nc: 1, iva_10: 9, total_iva: 9 });
  });
});
