import { Logger } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { monedasDeRecibos } from './moneda-recibo';
import { aMonedaBase, whereMonedaTablero } from 'src/utils/montos-moneda';

const PYG = 'm-pyg';
const USD = 'm-usd';
const BRL = 'm-brl';
const CODIGOS: Record<string, string> = { [PYG]: 'PYG', [USD]: 'USD', [BRL]: 'BRL' };

type Recibo = { id: string; empresa_id: string; moneda_id: string | null; cotizacion: Prisma.Decimal | null };

function dbMock(recibos: Recibo[], bases: Record<string, string | null> = { emp: PYG }) {
  return {
    recibos_cobro: {
      findMany: jest.fn((a: any) =>
        Promise.resolve(
          recibos.filter((r) => {
            const emp = a.where.empresa_id;
            const enEmpresa = typeof emp === 'string' ? r.empresa_id === emp : emp.in.includes(r.empresa_id);
            return enEmpresa && a.where.id.in.includes(r.id);
          }),
        ),
      ),
    },
    empresa_monedas: {
      findFirst: jest.fn((a: any) => {
        const id = bases[a.where.empresa_id];
        return Promise.resolve(id ? { moneda_id: id } : null);
      }),
    },
    moneda: {
      // Sin moneda principal, `monedaBaseId` cae en la PYG del sistema; acá «sin base» es que tampoco hay PYG.
      findFirst: jest.fn(() => Promise.resolve(null)),
      findUnique: jest.fn((a: any) => Promise.resolve(CODIGOS[a.where.id] ? { id: a.where.id, codigo: CODIGOS[a.where.id] } : null)),
      findMany: jest.fn((a: any) =>
        Promise.resolve((a.where.id.in as string[]).filter((id) => CODIGOS[id]).map((id) => ({ id, codigo: CODIGOS[id] }))),
      ),
    },
    recibo_cobro_detalle: { findMany: jest.fn() },
    recibo_cobro_facturas: { findMany: jest.fn() },
  } as any;
}

const logger = () => ({ warn: jest.fn() }) as unknown as Logger & { warn: jest.Mock };
const rec = (id: string, moneda_id: string | null, cotizacion: string | null, empresa_id = 'emp'): Recibo => ({
  id,
  empresa_id,
  moneda_id,
  cotizacion: cotizacion === null ? null : new Prisma.Decimal(cotizacion),
});

describe('monedasDeRecibos', () => {
  it('cabecera USD con cotización válida → la del recibo', async () => {
    const { monedas: m } = await monedasDeRecibos(dbMock([rec('r1', USD, '7300.5')]), 'emp', ['r1'], logger());
    const r = m.get('r1');
    expect(r).toMatchObject({ codigo: 'USD', moneda_id: USD, origen: 'recibo' });
    expect(r.cotizacion).toBeInstanceOf(Prisma.Decimal);
    expect(r.cotizacion.toString()).toBe('7300.5');
  });

  it('cabecera nula → la moneda base (como el Tablero), sin mirar los documentos aplicados', async () => {
    const db = dbMock([rec('r1', null, null)]);
    const { monedas: m } = await monedasDeRecibos(db, 'emp', ['r1'], logger());
    expect(m.get('r1')).toEqual({ codigo: 'PYG', moneda_id: PYG, cotizacion: null, origen: 'base' });
    expect(db.recibo_cobro_detalle.findMany).not.toHaveBeenCalled();
    expect(db.recibo_cobro_facturas.findMany).not.toHaveBeenCalled();
  });

  it('cabecera nula con base USD → USD: es la base de esa empresa, no PYG fijo', async () => {
    const { monedas: m } = await monedasDeRecibos(dbMock([rec('r1', null, null)], { emp: USD }), 'emp', ['r1'], logger());
    expect(m.get('r1')).toMatchObject({ codigo: 'USD', moneda_id: USD, origen: 'base' });
  });

  it('el recibo nulo cae en la base, igual que el filtro `whereMonedaTablero` de la base', async () => {
    const { monedas: m } = await monedasDeRecibos(dbMock([rec('r1', null, null)]), 'emp', ['r1'], logger());
    const base = { id: PYG, codigo: 'PYG' };
    expect(whereMonedaTablero({ convertir: false, base, moneda: base })).toEqual({ OR: [{ moneda_id: PYG }, { moneda_id: null }] });
    expect(m.get('r1').moneda_id).toBe(base.id);
  });

  it('cotización 1, 0 o nula en USD → null (no es una cotización), y aMonedaBase lo deja sin cotizar', async () => {
    const db = dbMock([rec('r1', USD, '1'), rec('r2', USD, '0'), rec('r3', USD, null)]);
    const { monedas: m } = await monedasDeRecibos(db, 'emp', ['r1', 'r2', 'r3'], logger());
    for (const id of ['r1', 'r2', 'r3']) {
      expect(m.get(id)).toEqual({ codigo: 'USD', moneda_id: USD, cotizacion: null, origen: 'recibo' });
      expect(aMonedaBase(100, m.get(id), 'PYG')).toBeNull();
    }
    expect(db.recibo_cobro_detalle.findMany).not.toHaveBeenCalled();
  });

  it('cotización con decimales se conserva exacta (Decimal, sin pasar por float)', async () => {
    const { monedas: m } = await monedasDeRecibos(dbMock([rec('r1', USD, '7312.3456')]), 'emp', ['r1'], logger());
    expect(m.get('r1').cotizacion.toFixed(4)).toBe('7312.3456');
    expect(aMonedaBase(1234.56, m.get('r1'), 'PYG')).toBe(Math.round(1234.56 * 7312.3456));
  });

  it('una sola consulta de recibos por lote, ids repetidos una vez', async () => {
    const db = dbMock([rec('r1', USD, '7300'), rec('r2', null, null)]);
    const { monedas: m } = await monedasDeRecibos(db, 'emp', ['r1', 'r2', 'r1'], logger());
    expect(db.recibos_cobro.findMany).toHaveBeenCalledTimes(1);
    expect(db.recibos_cobro.findMany.mock.calls[0][0]).toEqual({
      where: { empresa_id: 'emp', id: { in: ['r1', 'r2'] } },
      select: { id: true, empresa_id: true, moneda_id: true, cotizacion: true },
    });
    expect([...m.keys()].sort()).toEqual(['r1', 'r2']);
  });

  it('agrupación lineal: 60.000 recibos de una empresa en menos de 1 s', async () => {
    const muchos = Array.from({ length: 60_000 }, (_, i) => rec(`r${i}`, i % 2 ? USD : null, i % 2 ? '7300' : null));
    const db = dbMock(muchos);
    db.recibos_cobro.findMany = jest.fn((a: any) => {
      const pedidos = new Set(a.where.id.in as string[]);
      return Promise.resolve(muchos.filter((r) => pedidos.has(r.id)));
    });
    const t0 = Date.now();
    const { monedas, sin_moneda, no_encontrados } = await monedasDeRecibos(db, 'emp', muchos.map((r) => r.id), logger());
    expect(Date.now() - t0).toBeLessThan(1000);
    expect(monedas.size).toBe(60_000);
    expect([sin_moneda, no_encontrados]).toEqual([[], []]);
    expect(db.recibos_cobro.findMany).toHaveBeenCalledTimes(6);
  });

  it('sin ids → mapa vacío, sin consultar', async () => {
    const db = dbMock([]);
    expect(await monedasDeRecibos(db, 'emp', [], logger())).toEqual({ monedas: new Map(), sin_moneda: [], no_encontrados: [] });
    expect(db.recibos_cobro.findMany).not.toHaveBeenCalled();
  });

  it('un recibo de otra empresa (o inexistente) no se resuelve: va a `no_encontrados`, en el orden pedido', async () => {
    const r = await monedasDeRecibos(dbMock([rec('r1', USD, '7300', 'otra'), rec('r2', USD, '7300')]), 'emp', ['r1', 'r2', 'r9'], logger());
    expect(r.monedas.has('r1')).toBe(false);
    expect(r.monedas.has('r2')).toBe(true);
    expect(r.no_encontrados).toEqual(['r1', 'r9']);
    expect(r.sin_moneda).toEqual([]);
  });

  it('varias empresas (holding): cada recibo nulo toma la base de SU empresa', async () => {
    const db = dbMock([rec('r1', null, null, 'emp'), rec('r2', null, null, 'sub'), rec('r3', BRL, '1400', 'sub')], { emp: PYG, sub: USD });
    const { monedas: m } = await monedasDeRecibos(db, ['emp', 'sub'], ['r1', 'r2', 'r3'], logger());
    expect(db.recibos_cobro.findMany.mock.calls[0][0].where.empresa_id).toEqual({ in: ['emp', 'sub'] });
    expect(m.get('r1')).toMatchObject({ codigo: 'PYG', moneda_id: PYG, origen: 'base' });
    expect(m.get('r2')).toMatchObject({ codigo: 'USD', moneda_id: USD, origen: 'base' });
    expect(m.get('r3')).toMatchObject({ codigo: 'BRL', moneda_id: BRL, origen: 'recibo' });
  });

  it('empresa sin moneda base → 422 EMPRESA_SIN_MONEDA_BASE, como el Tablero (no descarta en silencio)', async () => {
    await expect(
      monedasDeRecibos(dbMock([rec('r1', null, null), rec('r2', USD, '7300')], { emp: null }), 'emp', ['r1', 'r2'], logger()),
    ).rejects.toMatchObject({ status: 422, response: { codigo: 'EMPRESA_SIN_MONEDA_BASE' } });
  });

  it('holding con una sub-empresa sin base → 422 (aunque la principal tenga)', async () => {
    const db = dbMock([rec('r1', USD, '7300', 'emp'), rec('r2', USD, '7300', 'sub')], { emp: PYG, sub: null });
    await expect(monedasDeRecibos(db, ['emp', 'sub'], ['r1', 'r2'], logger())).rejects.toMatchObject({ status: 422 });
  });

  it('moneda sin código (inexistente) → `sin_moneda` para que el llamador la cuente; nunca se suma a otra', async () => {
    const r = await monedasDeRecibos(dbMock([rec('r1', 'm-borrada', '7300'), rec('r2', USD, '7300')]), 'emp', ['r1', 'r2'], logger());
    expect(r.monedas.has('r1')).toBe(false);
    expect(r.monedas.get('r2')).toMatchObject({ codigo: 'USD' });
    expect(r.sin_moneda).toEqual(['r1']);
    expect(r.no_encontrados).toEqual([]);
  });
});
