import { SupervisoresService } from '../supervisores/supervisores.service';
import { AsignacionFacturasService } from './asignacion-facturas.service';
import { LiquidacionesService } from './liquidaciones.service';
import { agruparPorMoneda, monedaPdf, sumarCampos } from './pdf-moneda';

// Payload de los cinco PDF de comisiones y liquidaciones (spec 2026-10-17-comercial-finanzas, 5b):
// cada fila o bloque lleva `moneda: {codigo, simbolo}` y los totales van por moneda, nunca mezclados.

const PYG = { id: 'm-pyg', codigo: 'PYG', simbolo: '₲' };
const USD = { id: 'm-usd', codigo: 'USD', simbolo: '$' };
const EMPRESA = { razon_social: 'Empresa SA', nombre_fantasia: null, ruc: '800-1', logo_url: null };

/** Espía `callMsvKude` y devuelve el payload que se mandaría al generador. */
const capturar = (service: any) => {
  const llamadas: Array<{ endpoint: string; payload: any }> = [];
  service.callMsvKude = jest.fn().mockImplementation(async (endpoint: string, payload: any) => {
    llamadas.push({ endpoint, payload });
    return Buffer.from('%PDF');
  });
  service.getEmpresaHeader = jest.fn().mockResolvedValue(EMPRESA);
  return llamadas;
};

describe('pdf-moneda', () => {
  it('monedaPdf deja solo codigo y simbolo', () => {
    expect(monedaPdf(USD)).toEqual({ codigo: 'USD', simbolo: '$' });
    expect(monedaPdf(null)).toBeNull();
  });

  it('agruparPorMoneda agrupa por código en el orden de aparición', () => {
    const g = agruparPorMoneda([{ m: PYG, v: 1 }, { m: USD, v: 2 }, { m: PYG, v: 3 }], (x) => x.m);
    expect(g.map((x) => x.moneda?.codigo)).toEqual(['PYG', 'USD']);
    expect(g[0].items.map((x) => x.v)).toEqual([1, 3]);
  });

  it('sumarCampos convierte los textos de Prisma', () => {
    expect(sumarCampos([{ a: '1.5', b: 2 }, { a: 2, b: null }], ['a', 'b'] as const)).toEqual({ a: 3.5, b: 2 });
  });
});

describe('PDF de comisiones de vendedores y cobradores', () => {
  const crear = () => {
    const service: any = new AsignacionFacturasService({} as any, {} as any);
    const llamadas = capturar(service);
    service.prepararFiltros = jest.fn().mockResolvedValue({ desde: '2026-10-01', hasta: '2026-10-31', moneda: USD });
    service.getResumenComisiones = jest.fn().mockResolvedValue([
      { id: 'vc-1', nombre: 'Ana', apellido: 'Gómez', tipo: 'vendedor', comision_porcentaje: 5, ventas: 1000.5, cobranzas: 0, comision_generada: 50.03, estado: 'pendiente', moneda: USD },
      { id: 'vc-2', nombre: 'Luis', apellido: null, tipo: 'cobrador', comision_porcentaje: 2, ventas: 0, cobranzas: 200, comision_generada: 4, estado: 'liquidada', moneda: USD },
    ]);
    service.getComisionesDetalle = jest.fn().mockImplementation(async (_e: string, vcId: string) => [
      {
        tipo: 'venta',
        monto_base: '1000.50',
        monto_comision: '50.03',
        fecha_documento: '2026-10-10T09:00:00.000Z',
        factura_cab: { dest: '001', dpunexp: '001', dnumdoc: '0000123', clientes: { personas: { razon_social: 'Cliente' } } },
        moneda: USD,
        vc: vcId,
      },
    ]);
    return { service, llamadas };
  };

  it('resumen: moneda del filtro, moneda por fila y un bloque con su total', async () => {
    const { service, llamadas } = crear();
    await service.comisionesResumenPdf('emp-1', { moneda_id: USD.id });
    const { endpoint, payload } = llamadas[0];
    expect(endpoint).toBe('comisiones-resumen');
    expect(payload.moneda).toEqual({ codigo: 'USD', simbolo: '$' });
    expect(payload.bloques).toHaveLength(1);
    expect(payload.bloques[0].moneda).toEqual({ codigo: 'USD', simbolo: '$' });
    expect(payload.bloques[0].filas.every((f: any) => f.moneda.codigo === 'USD')).toBe(true);
    expect(payload.bloques[0].totales).toEqual({ ventas: 1000.5, cobranzas: 200, comisiones: 54.03 });
    expect(payload.filas).toBeUndefined();
  });

  it('detalle: cada grupo e item con su moneda y el total del bloque', async () => {
    const { service, llamadas } = crear();
    await service.comisionesDetallePdf('emp-1', { moneda_id: USD.id });
    const { endpoint, payload } = llamadas[0];
    expect(endpoint).toBe('comisiones-detalle');
    expect(payload.bloques).toHaveLength(1);
    const [b] = payload.bloques;
    expect(b.moneda.codigo).toBe('USD');
    expect(b.grupos).toHaveLength(2);
    expect(b.grupos[0]).toMatchObject({ moneda: { codigo: 'USD' }, total_base: 1000.5, total_comision: 50.03 });
    expect(b.grupos[0].items[0].moneda).toEqual({ codigo: 'USD', simbolo: '$' });
    expect(b.totales).toEqual({ base: 2001, comision: 100.06 });
  });
});

describe('PDF de comisiones de supervisores', () => {
  const fila = (over: Record<string, any>) => ({
    id: 'cs-1',
    supervisor: { nombre: 'Sara', apellido: 'Ruiz', codigo: 'S1' },
    periodo_desde: new Date('2026-10-01T00:00:00.000Z'),
    periodo_hasta: new Date('2026-10-31T00:00:00.000Z'),
    total_ventas: '1000',
    total_cobros: '500',
    comision_ventas: '30',
    comision_cobros: '10',
    total_comision: '40',
    estado: 'pendiente',
    porcentaje_ventas_aplicado: '3.00',
    porcentaje_cobros_aplicado: '2.00',
    moneda: PYG,
    ...over,
  });

  const crear = () => {
    const prisma: any = {
      empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda: PYG }) },
      moneda: { findFirst: jest.fn().mockResolvedValue(PYG) },
    };
    const service: any = new SupervisoresService(prisma, {} as any, {} as any);
    const llamadas = capturar(service);
    service.getReporteComisiones = jest.fn().mockResolvedValue([
      fila({ id: 'cs-1', total_ventas: '1000000', total_comision: '40000' }),
      fila({ id: 'cs-2', moneda: USD, total_ventas: '1000.5', total_comision: '40.25', porcentaje_ventas_aplicado: null, porcentaje_cobros_aplicado: null }),
      fila({ id: 'cs-3', total_ventas: '500000', total_comision: '20000' }),
    ]);
    service.getDetalleComision = jest.fn().mockResolvedValue({
      equipo: [{ vendedor_cobrador: { nombre: 'Ana', apellido: 'Gómez', codigo: 'V1', tipo: 'vendedor' }, ventas: 10, cobros: 5 }],
    });
    return { service, llamadas };
  };

  it('resumen: un bloque por moneda con su total, sin mezclar', async () => {
    const { service, llamadas } = crear();
    await service.reporteComisionesResumenPdf('emp-1', { periodo_desde: '2026-10-01', periodo_hasta: '2026-10-31' });
    const { endpoint, payload } = llamadas[0];
    expect(endpoint).toBe('comisiones-supervisores-resumen');
    expect(payload.periodo).toBe('01/10/2026 — 31/10/2026');
    expect(payload.bloques.map((b: any) => b.moneda.codigo)).toEqual(['PYG', 'USD']);
    const [pyg, usd] = payload.bloques;
    expect(pyg.filas).toHaveLength(2);
    expect(pyg.totales).toMatchObject({ ventas: 1500000, total_comision: 60000 });
    expect(usd.totales).toMatchObject({ ventas: 1000.5, total_comision: 40.25 });
    expect(pyg.filas[0]).toMatchObject({ periodo: '01/10/2026 — 31/10/2026', moneda: { codigo: 'PYG', simbolo: '₲' } });
  });

  it('detalle: bloques por moneda y los % aplicados (null si no se guardaron)', async () => {
    const { service, llamadas } = crear();
    await service.reporteComisionesDetallePdf('emp-1', {});
    const { endpoint, payload } = llamadas[0];
    expect(endpoint).toBe('comisiones-supervisores-detalle');
    const [pyg, usd] = payload.bloques;
    expect(pyg.moneda.codigo).toBe('PYG');
    expect(pyg.grupos.map((g: any) => [g.pct_ventas, g.pct_cobros])).toEqual([[3, 2], [3, 2]]);
    expect(pyg.totales).toEqual({ ventas: 1500000, cobros: 1000, comision: 60000 });
    expect(usd.grupos[0]).toMatchObject({ pct_ventas: null, pct_cobros: null, moneda: { codigo: 'USD' } });
    expect(usd.totales).toEqual({ ventas: 1000.5, cobros: 500, comision: 40.25 });
  });
});

describe('PDF de liquidaciones', () => {
  const crear = () => {
    const prisma: any = {
      empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda: PYG }) },
      moneda: { findFirst: jest.fn().mockResolvedValue(PYG), findUnique: jest.fn().mockResolvedValue(USD) },
    };
    const service: any = new LiquidacionesService(prisma, {} as any);
    const llamadas = capturar(service);
    const liq = (moneda: any, total: number, facturas: number) => ({
      vendedor_cobrador: { nombre: 'Ana', tipo: 'vendedor' },
      periodo_desde: '2026-10-01',
      periodo_hasta: '2026-10-31',
      cantidad_facturas: facturas,
      total_comisiones: total,
      estado: 'pendiente',
      fecha_pago: null,
      moneda,
    });
    service.getLiquidaciones = jest.fn().mockResolvedValue([liq(PYG, 150000, 3), liq(USD, 25.5, 1), liq(PYG, 50000, 2)]);
    service.getLiquidacionDetalle = jest.fn().mockResolvedValue({
      id: 'l-1',
      periodo_desde: '2026-10-01',
      periodo_hasta: '2026-10-31',
      total_comisiones: 25.5,
      moneda: USD,
      comisiones: [],
    });
    return { service, llamadas };
  };

  it('lista: un bloque por moneda con su total de facturas y comisiones', async () => {
    const { service, llamadas } = crear();
    await service.liquidacionesListaPdf('emp-1', {});
    const { endpoint, payload } = llamadas[0];
    expect(endpoint).toBe('liquidaciones-lista');
    expect(payload.moneda).toEqual({ codigo: 'PYG', simbolo: '₲' });
    expect(payload.bloques.map((b: any) => b.moneda.codigo)).toEqual(['PYG', 'USD']);
    expect(payload.bloques[0].totales).toEqual({ cantidad_facturas: 5, total_comisiones: 200000 });
    expect(payload.bloques[1].totales).toEqual({ cantidad_facturas: 1, total_comisiones: 25.5 });
    expect(payload.bloques[1].filas[0].moneda).toEqual({ codigo: 'USD', simbolo: '$' });
    expect(payload.totales).toBeUndefined();
  });

  it('lista con filtro: la moneda del filtro rotula el PDF', async () => {
    const { service, llamadas } = crear();
    await service.liquidacionesListaPdf('emp-1', { moneda_id: USD.id });
    expect(llamadas[0].payload.moneda).toEqual({ codigo: 'USD', simbolo: '$' });
  });

  it('comprobante: la liquidación lleva su moneda', async () => {
    const { service, llamadas } = crear();
    await service.liquidacionComprobantePdf('emp-1', 'l-1');
    const { endpoint, payload } = llamadas[0];
    expect(endpoint).toBe('liquidacion-comprobante');
    expect(payload.liquidacion.moneda).toEqual({ codigo: 'USD', simbolo: '$' });
    expect(payload.moneda).toEqual({ codigo: 'USD', simbolo: '$' });
  });
});
