import * as XLSX from 'xlsx';
import { hoyComoFechaPY } from 'src/lotes/hoy-py';
import { CuentasPagarReportesService } from './cuentas-pagar-reportes.service';

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

const DIA = 86_400_000;
const hoyUtc = () => hoyComoFechaPY().getTime();
const enDias = (d: number) => new Date(hoyUtc() + d * DIA);

const persona = (razon_social: string) => ({ personas: { razon_social, ruc: '800', dv: '1' } });

function cuenta(o: Record<string, unknown>) {
  return {
    id: 'cp-x',
    proveedor_id: 'prov-1',
    compra_id: null,
    origen_tipo: 'gasto',
    origen_id: 'g-1',
    numero_cuota: 1,
    total_cuotas: 1,
    fecha_emision: enDias(-60),
    compra_cab: null,
    moneda: { codigo: 'PYG' },
    proveedores: persona('BALBINO'),
    ...o,
  };
}

function crear(cuentas: unknown[], pagos: unknown[] = [], notas: unknown[] = []) {
  const prisma = {
    cuentas_pagar: { findMany: jest.fn().mockResolvedValue(cuentas) },
    gasto_cab: {
      findMany: jest.fn().mockResolvedValue([
        {
          id: 'g-1',
          numero_factura: '001-001-0000356',
          fecha_emision: enDias(-60),
          sucursal_id: 's-1',
          descripcion: 'Importado desde Libro de Compras SET',
          gasto_det: [{ tipo_gasto: { descripcion: 'HONORARIOS PROFESIONALES' } }],
        },
      ]),
    },
    pagos_proveedor: { findMany: jest.fn().mockResolvedValue(pagos) },
    nota_credito_compra_cab: { findMany: jest.fn().mockResolvedValue(notas) },
    empresas: { findUnique: jest.fn().mockResolvedValue({ razon_social: 'DOBA S.A.' }) },
  };
  return new CuentasPagarReportesService(prisma as never);
}

describe('CuentasPagarReportesService', () => {
  it('detalle: agrupa por comprobante, pone los pagos bajo su cuota y arma la antigüedad', async () => {
    const s = crear(
      [
        cuenta({ id: 'cp-1', numero_cuota: 1, total_cuotas: 2, fecha_vencimiento: enDias(-40), monto_original: 9_167_000, saldo_pendiente: 4_167_000 }),
        cuenta({ id: 'cp-2', numero_cuota: 2, total_cuotas: 2, fecha_vencimiento: enDias(10), monto_original: 9_167_000, saldo_pendiente: 9_167_000 }),
      ],
      [{ cuenta_pagar_id: 'cp-1', fecha_pago: enDias(-20), numero_recibo: '001-001-0000027', monto: 5_000_000, medio_pago: { descripcion: 'TRANSFERENCIA' } }],
    );
    const d = await s.detalle('emp', undefined);

    expect(d.proveedores).toHaveLength(1);
    const p = d.proveedores[0];
    expect(p.ruc).toBe('800-1');
    expect(p.documentos).toHaveLength(1);
    const doc = p.documentos[0];
    // El concepto sale del tipo de gasto, no de la descripción genérica.
    expect(doc.concepto).toBe('HONORARIOS PROFESIONALES');
    expect(doc.cuotas.map((q) => [q.nro, q.de, q.estado, q.pagado])).toEqual([
      [1, 2, 'Vencida', 5_000_000],
      [2, 2, 'Por vencer', 0],
    ]);
    expect(doc.cuotas[0].dias).toBe(40);
    expect(doc.cuotas[1].dias).toBe(-10);
    expect(doc.cuotas[0].pagos).toEqual([expect.objectContaining({ numero: '001-001-0000027', medio: 'TRANSFERENCIA', monto: 5_000_000 })]);
    expect(p.saldo).toBe(13_334_000);
    expect(p.vencido).toBe(4_167_000);
    expect(p.antiguedad).toEqual({ al_dia: 9_167_000, d1_30: 0, d31_60: 4_167_000, d61_90: 0, mas_90: 0 });
  });

  it('detalle: no mezcla monedas del mismo proveedor y ordena por deuda', async () => {
    const s = crear([
      cuenta({ id: 'a', proveedor_id: 'p-chico', proveedores: persona('CHICO'), fecha_vencimiento: enDias(-1), monto_original: 100, saldo_pendiente: 100 }),
      cuenta({ id: 'b', proveedor_id: 'p-grande', proveedores: persona('GRANDE'), fecha_vencimiento: enDias(-1), monto_original: 900, saldo_pendiente: 900 }),
      cuenta({ id: 'c', proveedor_id: 'p-grande', proveedores: persona('GRANDE'), moneda: { codigo: 'USD' }, fecha_vencimiento: enDias(-1), monto_original: 50, saldo_pendiente: 50 }),
    ]);
    const d = await s.detalle('emp', undefined);

    expect(d.proveedores.map((p) => [p.razon_social, p.moneda, p.saldo])).toEqual([
      ['GRANDE', 'PYG', 900],
      ['CHICO', 'PYG', 100],
      ['GRANDE', 'USD', 50],
    ]);
    expect(d.totales).toEqual(
      expect.arrayContaining([
        expect.objectContaining({ moneda: 'PYG', saldo: 1000 }),
        expect.objectContaining({ moneda: 'USD', saldo: 50 }),
      ]),
    );
  });

  it('plan de pagos: lo vencido va a «Vencido», lo demás al mes en que vence o a «Después»', async () => {
    const n = new Date(hoyUtc());
    const finDeMes = new Date(Date.UTC(n.getUTCFullYear(), n.getUTCMonth() + 1, 0));
    const s = crear([
      cuenta({ id: 'v', fecha_vencimiento: enDias(-5), monto_original: 10, saldo_pendiente: 10 }),
      cuenta({ id: 'm', fecha_vencimiento: finDeMes, monto_original: 20, saldo_pendiente: 20 }),
      cuenta({ id: 'lejos', fecha_vencimiento: enDias(400), monto_original: 30, saldo_pendiente: 30 }),
    ]);
    const plan = await s.planPagos('emp', undefined, { meses: 2 });

    expect(plan.columnas).toHaveLength(4); // Vencido, mes actual, mes siguiente, Después
    const [vencido, mesActual, , despues] = plan.columnas.map((c) => c.clave);
    expect(plan.totales[0].por_columna).toEqual(expect.objectContaining({ [vencido]: 10, [mesActual]: 20, [despues]: 30 }));
  });

  it('el Excel del detalle trae la hoja de antigüedad y los montos con separador de miles', async () => {
    const s = crear([cuenta({ id: 'cp-1', fecha_vencimiento: enDias(-40), monto_original: 9_167_000, saldo_pendiente: 9_167_000 })]);
    const wb = XLSX.read(await s.detalleXlsx('emp', undefined));

    expect(wb.SheetNames).toEqual(['Detalle', 'Antigüedad']);
    const filas = XLSX.utils.sheet_to_json<unknown[]>(wb.Sheets.Detalle, { header: 1, defval: '' });
    const cuota = filas.find((r) => r[1] === '001-001-0000356');
    expect(cuota[3]).toBe('HONORARIOS PROFESIONALES');
    expect(cuota[9]).toBe(9_167_000);
  });

  describe('saldo acumulado', () => {
    const compra = (o: Record<string, unknown>) =>
      cuenta({
        origen_tipo: 'compra',
        origen_id: null,
        compra_id: 'c-1',
        compra_cab: { establecimiento: '002', punto_expedicion: '001', numero_factura: '0001620', fecha_emision: enDias(-90), observaciones: null, sucursal_id: null },
        ...o,
      });
    const nc = { compra_id: 'c-1', gasto_id: null, establecimiento: '002', punto_expedicion: '001', numero: '0000867', fecha_emision: enDias(-40), motivo: null, total: 3_559_725 };

    it('detalle: separa la nota de crédito de lo pagado', async () => {
      const s = crear(
        [compra({ id: 'cp-c', fecha_vencimiento: enDias(-60), monto_original: 19_305_900, saldo_pendiente: 14_746_175 })],
        [{ cuenta_pagar_id: 'cp-c', fecha_pago: enDias(-10), numero_recibo: 'R-1', monto: 1_000_000, medio_pago: null }],
        [nc],
      );
      const doc = (await s.detalle('emp', undefined)).proveedores[0].documentos[0];
      expect(doc.cuotas[0].pagado).toBe(4_559_725);
      expect(doc.cuotas[0].nota_credito).toBe(3_559_725);
      expect(doc.notas_credito).toEqual([expect.objectContaining({ numero: '002-001-0000867', monto: 3_559_725 })]);
    });

    it('Excel: saldo corrido, la NC en su columna y el mismo RUC como proveedor y como acreedor', async () => {
      const s = crear(
        [
          compra({ id: 'cp-c', fecha_vencimiento: enDias(-60), monto_original: 19_305_900, saldo_pendiente: 15_746_175 }),
          cuenta({ id: 'cp-g', fecha_vencimiento: enDias(-40), monto_original: 9_167_000, saldo_pendiente: 9_167_000 }),
        ],
        [],
        [nc],
      );
      const wb = XLSX.read(await s.saldoAcumuladoXlsx('emp', undefined));
      const filas = XLSX.utils.sheet_to_json<unknown[]>(wb.Sheets['Saldo acumulado'], { header: 1, defval: '' });

      expect(filas.filter((r) => /^BALBINO · RUC 800-1 · como (proveedor|acreedor)/.test(String(r[0]))).map((r) => r[0])).toEqual([
        'BALBINO · RUC 800-1 · como proveedor (compras)',
        'BALBINO · RUC 800-1 · como acreedor (gastos)',
      ]);
      const factura = filas.find((r) => r[1] === '002-001-0001620');
      expect([factura[7], factura[8], factura[9], factura[10]]).toEqual([19_305_900, '', 0, 19_305_900]);
      const notaCredito = filas.find((r) => r[1] === '002-001-0000867');
      expect([notaCredito[2], notaCredito[8], notaCredito[10]]).toEqual(['Nota de crédito', 3_559_725, 15_746_175]);
      const totales = filas.filter((r) => r[9] === 'Saldo').map((r) => r[10]);
      expect(totales).toEqual([15_746_175, 9_167_000]);
      expect(filas.find((r) => r[9] === 'Total Gs.')[10]).toBe(24_913_175);
    });
  });
});

describe('CuentasPagarReportesService: el «hoy» es el de Asunción', () => {
  afterEach(() => jest.useRealTimers());

  it('a las 22:00 de Asunción (01:00 UTC del día siguiente) una cuota que vence hoy tiene dias = 0', async () => {
    jest.useFakeTimers({ now: new Date('2026-11-03T01:00:00.000Z') }); // 02/11 22:00 en Asunción (UTC-3)
    const s = crear([cuenta({ id: 'hoy', fecha_vencimiento: new Date('2026-11-02T00:00:00.000Z'), monto_original: 10, saldo_pendiente: 10 })]);
    const d = await s.detalle('emp', undefined);
    const q = d.proveedores[0].documentos[0].cuotas[0];
    expect(q.dias).toBe(0);
    expect(q.estado).toBe('Por vencer');
  });
});
