import { BadRequestException, Logger } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import {
  aMonedaBase,
  codigoMonedaBase,
  codigosDeMonedas,
  desdeMonedaBase,
  porMoneda,
  resolverMonedaTablero,
  whereMonedaTablero,
} from './montos-moneda';

describe('aMonedaBase', () => {
  it.each([
    [100, { codigo: 'USD', cotizacion: 7300 }, 'PYG', 730000],
    [100, { codigo: 'USD', cotizacion: null }, 'PYG', null],
    [100, { codigo: 'USD', cotizacion: 0 }, 'PYG', null],
    [5000, { codigo: 'PYG', cotizacion: 1 }, 'PYG', 5000],
    [730000, { codigo: 'PYG', cotizacion: 7300 }, 'USD', 100],
    // F2: documento sin moneda = la base, vale su monto.
    [5000, { codigo: null, cotizacion: null }, 'PYG', 5000],
    // F18: el default 1 de compra_cab/NC en un documento que no es de la base no es una cotización.
    [100, { codigo: 'USD', cotizacion: 1 }, 'PYG', null],
    [100, { codigo: 'USD', cotizacion: new Prisma.Decimal('7300.5') }, 'PYG', 730050],
    [100.4, { codigo: 'USD', cotizacion: '7300' }, 'PYG', 732920],
    // Ni la base ni el documento son PYG: no hay cómo convertir.
    [100, { codigo: 'EUR', cotizacion: 8000 }, 'USD', null],
  ])('%p %j → %s: %p', (monto, doc, base, esperado) => {
    expect(aMonedaBase(monto as number, doc as any, base as string)).toBe(esperado);
  });
});

describe('desdeMonedaBase (el costo de rentabilidad, guardado en la base, a la moneda del documento)', () => {
  it.each([
    [730000, { codigo: 'USD', cotizacion: 7300 }, 'PYG', 100],
    [800, { codigo: 'USD', cotizacion: 7300 }, 'PYG', 0.11],
    [5000, { codigo: 'PYG', cotizacion: null }, 'PYG', 5000],
    [100, { codigo: 'PYG', cotizacion: 7300 }, 'USD', 730000],
    [100, { codigo: 'USD', cotizacion: null }, 'PYG', null],
  ])('%p %j → %s: %p', (monto, doc, base, esperado) => {
    expect(desdeMonedaBase(monto as number, doc as any, base as string)).toBe(esperado);
  });
});

describe('porMoneda', () => {
  it('suma por código, nunca entre códigos; texto con 2 decimales; null a la base; ordenado', () => {
    expect(porMoneda([{ codigo: 'USD', v: 1 }, { codigo: 'PYG', v: 2 }, { codigo: null, v: 3 }], ['v'], 'PYG')).toEqual([
      { codigo: 'PYG', v: '5.00' },
      { codigo: 'USD', v: '1.00' },
    ]);
  });

  it('varios campos, sin error de coma flotante', () => {
    expect(
      porMoneda(
        [
          { codigo: 'USD', a: 0.1, b: 1 },
          { codigo: 'USD', a: 0.2, b: 2 },
        ],
        ['a', 'b'],
        'PYG',
      ),
    ).toEqual([{ codigo: 'USD', a: '0.30', b: '3.00' }]);
  });

  it('sin filas: []', () => {
    expect(porMoneda([], ['v'], 'PYG')).toEqual([]);
  });
});

describe('codigoMonedaBase', () => {
  it('la principal de la empresa', async () => {
    const db: any = {
      empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: 'm-usd' }) },
      moneda: {
        findFirst: jest.fn(),
        findUnique: jest.fn().mockResolvedValue({ id: 'm-usd', codigo: 'USD' }),
      },
    };
    await expect(codigoMonedaBase(db, 'emp')).resolves.toEqual({ id: 'm-usd', codigo: 'USD' });
  });

  it('sin moneda base: error con código, no un código inventado', async () => {
    const db: any = {
      empresa_monedas: { findFirst: jest.fn().mockResolvedValue(null) },
      moneda: { findFirst: jest.fn().mockResolvedValue(null), findUnique: jest.fn() },
    };
    await expect(codigoMonedaBase(db, 'emp')).rejects.toMatchObject({
      response: expect.objectContaining({ codigo: 'EMPRESA_SIN_MONEDA_BASE' }),
    });
  });
});

describe('resolverMonedaTablero / whereMonedaTablero', () => {
  const UUID_USD = '11111111-1111-4111-8111-111111111111';
  const UUID_PYG = '22222222-2222-4222-8222-222222222222';
  const db: any = {
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: UUID_PYG }) },
    moneda: {
      findFirst: jest.fn(),
      findUnique: jest.fn(({ where }) =>
        Promise.resolve(
          where.id === UUID_PYG ? { id: UUID_PYG, codigo: 'PYG' } : where.id === UUID_USD ? { id: UUID_USD, codigo: 'USD' } : null,
        ),
      ),
    },
  };

  it('sin moneda: convierte a la base y no filtra', async () => {
    const m = await resolverMonedaTablero(db, 'emp');
    expect(m).toEqual({ convertir: true, base: { id: UUID_PYG, codigo: 'PYG' }, moneda: { id: UUID_PYG, codigo: 'PYG' } });
    expect(whereMonedaTablero(m)).toBeUndefined();
  });

  it('con USD: filtra USD', async () => {
    const m = await resolverMonedaTablero(db, 'emp', UUID_USD);
    expect(m.convertir).toBe(false);
    expect(m.moneda).toEqual({ id: UUID_USD, codigo: 'USD' });
    expect(whereMonedaTablero(m)).toEqual({ moneda_id: UUID_USD });
  });

  it('con la base: incluye los documentos sin moneda (F2)', async () => {
    const m = await resolverMonedaTablero(db, 'emp', UUID_PYG);
    expect(whereMonedaTablero(m)).toEqual({ OR: [{ moneda_id: UUID_PYG }, { moneda_id: null }] });
  });

  it.each(['xx', '33333333-3333-4333-8333-333333333333'])('moneda %s inválida o inexistente: 400 con código', async (id) => {
    const e = await resolverMonedaTablero(db, 'emp', id).catch((x) => x);
    expect(e).toBeInstanceOf(BadRequestException);
    expect(e.getResponse()).toEqual(expect.objectContaining({ codigo: 'MONEDA_INVALIDA', campo: 'moneda_id' }));
  });
});

describe('codigosDeMonedas (movido de pagos-proveedor)', () => {
  const logger = { warn: jest.fn() } as unknown as Logger;
  const db: any = {
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: 'm-pyg' }) },
    moneda: {
      findFirst: jest.fn(),
      findMany: jest.fn().mockResolvedValue([
        { id: 'm-pyg', codigo: 'PYG' },
        { id: 'm-usd', codigo: 'USD' },
      ]),
    },
  };

  it('null es la base; una moneda sin código queda afuera con un WARN', async () => {
    const out = await codigosDeMonedas(db, 'emp', ['m-usd', null, 'm-x'], 'la prueba', logger);
    expect([...out]).toEqual([
      ['m-usd', 'USD'],
      [null, 'PYG'],
    ]);
    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('moneda_id=m-x'));
  });

  it('con la base ya leída no la vuelve a consultar', async () => {
    db.empresa_monedas.findFirst.mockClear();
    const out = await codigosDeMonedas(db, 'emp', [null], 'la prueba', logger, 'm-pyg');
    expect(out.get(null)).toBe('PYG');
    expect(db.empresa_monedas.findFirst).not.toHaveBeenCalled();
  });
});

describe('convertirMontos / redondearBloque', () => {
  const { convertirMontos, redondearBloque } = jest.requireActual('src/utils/montos-moneda');

  it('convierte cada monto; si uno no se puede, null (el documento queda fuera entero)', () => {
    expect(convertirMontos({ iva10: 10, total: 110 }, (m: number) => m * 7500)).toEqual({ iva10: 75000, total: 825000 });
    expect(convertirMontos({ iva10: 10, total: 110 }, (m: number) => (m === 110 ? null : m))).toBeNull();
  });

  it('redondea a 2 decimales cada número del bloque, también anidado', () => {
    expect(redondearBloque({ a: 0.1 + 0.2, b: { c: 1.005 * 1000, n: 3 }, s: 'x' })).toEqual({ a: 0.3, b: { c: 1005, n: 3 }, s: 'x' });
  });
});
