import { HttpException } from '@nestjs/common';
import { formatoArqueo, monedaDeArqueo, rotularMezcla } from './moneda-arqueo';

const ceros = { apertura: 0, entradas: 0, salidas: 0 };
const LINEA = 'Sesión con documentos en PYG y USD: el resumen y el arqueo muestran los acumulados de la caja, sin convertir.';

describe('monedaDeArqueo', () => {
  it('sin documentos ni montos: PYG', () => {
    expect(monedaDeArqueo([], ceros)).toEqual({ codigo: 'PYG', mezcla: [] });
  });
  it('PYG con apertura: PYG sin mezcla', () => {
    expect(monedaDeArqueo(['PYG'], { ...ceros, apertura: 100 })).toEqual({ codigo: 'PYG', mezcla: [] });
  });
  it('solo USD sin montos de caja: USD', () => {
    expect(monedaDeArqueo(['USD'], ceros)).toEqual({ codigo: 'USD', mezcla: [] });
  });
  it.each([
    ['apertura', { ...ceros, apertura: 100000 }],
    ['entradas', { ...ceros, entradas: 1 }],
    ['salidas', { ...ceros, salidas: 1 }],
  ])('USD con %s: la base entra y hay mezcla', (_n, montos) => {
    expect(monedaDeArqueo(['USD'], montos)).toEqual({ codigo: 'PYG', mezcla: ['PYG', 'USD'] });
  });
  it('USD y PYG: PYG con la base primero', () => {
    expect(monedaDeArqueo(['USD', 'PYG'], ceros)).toEqual({ codigo: 'PYG', mezcla: ['PYG', 'USD'] });
  });
  it('USD y BRL sin PYG: codigo PYG y las dos ordenadas', () => {
    expect(monedaDeArqueo(['USD', 'BRL'], ceros)).toEqual({ codigo: 'PYG', mezcla: ['BRL', 'USD'] });
  });
  it('repetidos no crean mezcla', () => {
    expect(monedaDeArqueo(['USD', 'USD'], ceros)).toEqual({ codigo: 'USD', mezcla: [] });
  });
});

describe('formatoArqueo', () => {
  it('undefined → a4', () => {
    expect(formatoArqueo(undefined)).toBe('a4');
  });
  it.each(['a4', 'a4-detallado', 'ticket', 'ticket-detallado'])('%s pasa', (f) => {
    expect(formatoArqueo(f)).toBe(f);
  });
  it('"pdf" → 400 FORMATO_INVALIDO', () => {
    let error: unknown;
    try {
      formatoArqueo('pdf');
    } catch (e) {
      error = e;
    }
    expect(error).toBeInstanceOf(HttpException);
    expect((error as HttpException).getStatus()).toBe(400);
    expect((error as HttpException).getResponse()).toMatchObject({ codigo: 'FORMATO_INVALIDO', campo: 'formato' });
  });
});

describe('rotularMezcla', () => {
  const movUsd = { concepto: 'Venta Fact. 001-001-0002521 - Transferencia', monto: 110, moneda: 'USD', referencia: 'r1', tipo: 'ENTRADA' };
  const movPyg = { concepto: 'Apertura', monto: 5000, moneda: 'PYG', referencia: null, tipo: 'ENTRADA' };
  const ventas = [
    { medio_pago: 'Efectivo', cantidad: 3, total: 558500, moneda: 'PYG' },
    { medio_pago: 'Transferencia', cantidad: 1, total: 110, moneda: 'USD' },
  ];
  const conMezcla = (over = {}) => rotularMezcla({ codigoBase: 'PYG', mezcla: ['PYG', 'USD'], ventas, movimientos: [movUsd, movPyg], observaciones: null, ...over });

  it('la fila en otra moneda lleva el monto en el texto y 0 en el número', () => {
    expect(conMezcla().ventas_por_medio).toContainEqual({ medio_pago: 'Transferencia · US$ 110,00', cantidad: 1, total: 0 });
  });
  it('la fila en la base queda igual', () => {
    expect(conMezcla().ventas_por_medio[0]).toEqual({ medio_pago: 'Efectivo', cantidad: 3, total: 558500 });
  });
  it('al final, una fila TOTAL por moneda distinta de la base', () => {
    const v = conMezcla({
      ventas: [...ventas, { medio_pago: 'Efectivo', cantidad: 1, total: 20000, moneda: 'USD' }, { medio_pago: 'Pix', cantidad: 2, total: 1250.5, moneda: 'BRL' }],
    }).ventas_por_medio;
    expect(v.slice(-2)).toEqual([
      { medio_pago: 'TOTAL BRL · R$ 1.250,50', cantidad: null, total: 0 },
      { medio_pago: 'TOTAL USD · US$ 20.110,00', cantidad: null, total: 0 },
    ]);
    expect(v.filter((f) => f.medio_pago.startsWith('TOTAL PYG'))).toEqual([]);
  });
  it('ningún número suma otra moneda: el TOTAL del generador da solo los guaraníes', () => {
    expect(conMezcla().ventas_por_medio.reduce((s, f) => s + (Number(f.total) || 0), 0)).toBe(558500);
  });
  it('el movimiento en otra moneda lleva el monto al principio del concepto y 0', () => {
    const [m] = conMezcla().movimientos;
    expect(m.concepto).toBe('US$ 110,00 · Venta Fact. 001-001-0002521 - Transferencia');
    expect(m.monto).toBe(0);
    expect(m.referencia).toBe('r1');
  });
  it('el movimiento en la base queda igual', () => {
    expect(conMezcla().movimientos[1]).toEqual({ concepto: 'Apertura', monto: 5000, referencia: null, tipo: 'ENTRADA' });
  });
  it('observaciones: la línea primero, y conserva la anterior', () => {
    const { observaciones } = conMezcla({ observaciones: 'Faltó un billete' });
    expect(observaciones?.startsWith(LINEA)).toBe(true);
    expect(observaciones).toContain('Faltó un billete');
    expect(conMezcla().observaciones).toBe(LINEA);
  });
  it('más de dos monedas se listan con comas', () => {
    expect(conMezcla({ mezcla: ['PYG', 'BRL', 'USD'] }).observaciones).toContain('en PYG, BRL y USD:');
  });
  it('un monto en guaraníes de otra base va sin decimales', () => {
    const r = rotularMezcla({
      codigoBase: 'USD',
      mezcla: ['PYG', 'USD'],
      ventas: [{ medio_pago: 'Efectivo', cantidad: 1, total: 1250000, moneda: 'PYG' }],
      movimientos: [],
      observaciones: null,
    });
    expect(r.ventas_por_medio[0].medio_pago).toBe('Efectivo · Gs. 1.250.000');
  });
  describe('el monto en el texto se escribe como fmtMoneda (M3)', () => {
    const texto = (total: number, moneda: string) =>
      rotularMezcla({ codigoBase: 'PYG', mezcla: ['PYG', moneda], ventas: [{ medio_pago: 'M', cantidad: 1, total, moneda }], movimientos: [], observaciones: null })
        .ventas_por_medio[0].medio_pago;

    it('el runtime trae los datos de es-PY: con small-icu caería en otro separador sin avisar', () => {
      expect(Intl.NumberFormat.supportedLocalesOf('es-PY')).toEqual(['es-PY']);
    });
    it.each([
      [110, 'USD', 'M · US$ 110,00'],
      [1250.5, 'USD', 'M · US$ 1.250,50'],
      [1250, 'USD', 'M · US$ 1.250,00'],
      [1234567.891, 'USD', 'M · US$ 1.234.567,89'],
      [-110, 'USD', 'M · US$ -110,00'],
      [1250.5, 'BRL', 'M · R$ 1.250,50'],
      [1250.5, 'ARS', 'M · $ 1.250,50'],
      [1250.5, 'EUR', 'M · EUR 1.250,50'],
    ])('%d %s → %s', (total, moneda, esperado) => {
      expect(texto(total, moneda)).toBe(esperado);
    });
  });
  it('sin mezcla devuelve todo tal cual, sin la moneda por fila', () => {
    const r = rotularMezcla({
      codigoBase: 'USD',
      mezcla: [],
      ventas: [{ medio_pago: 'Efectivo', cantidad: 1, total: 110, moneda: 'USD' }],
      movimientos: [{ concepto: 'Venta', monto: 110, moneda: 'USD' }],
      observaciones: 'obs',
    });
    expect(r).toEqual({ ventas_por_medio: [{ medio_pago: 'Efectivo', cantidad: 1, total: 110 }], movimientos: [{ concepto: 'Venta', monto: 110 }], observaciones: 'obs' });
  });
  it('sin mezcla, el movimiento en otra moneda (factura anulada) igual va rotulado; ventas, observaciones y TOTAL no cambian', () => {
    const r = rotularMezcla({
      codigoBase: 'PYG',
      mezcla: [],
      ventas: [{ medio_pago: 'Efectivo', cantidad: 1, total: 5000, moneda: 'PYG' }],
      movimientos: [movUsd, movPyg],
      observaciones: 'obs',
    });
    expect(r.movimientos[0]).toEqual({ concepto: 'US$ 110,00 · Venta Fact. 001-001-0002521 - Transferencia', monto: 0, referencia: 'r1', tipo: 'ENTRADA' });
    expect(r.movimientos[1]).toEqual({ concepto: 'Apertura', monto: 5000, referencia: null, tipo: 'ENTRADA' });
    expect(r.ventas_por_medio).toEqual([{ medio_pago: 'Efectivo', cantidad: 1, total: 5000 }]);
    expect(r.observaciones).toBe('obs');
  });
  it('no devuelve monedas_sesion ni moneda por fila', () => {
    const r = conMezcla();
    expect(r).not.toHaveProperty('monedas_sesion');
    expect(r.ventas_por_medio.every((f) => !('moneda' in f))).toBe(true);
    expect(r.movimientos.every((f) => !('moneda' in f))).toBe(true);
  });
});
