import { HttpException } from '@nestjs/common';
import { validarDto } from 'src/common/utils/validar-dto.testutil';
import { GuardarConfigMonedaLoteDto } from './dto/config-compras-moneda.dto';
import { ComprasService } from './compras.service';

const EMPRESA = 'emp-1';
const USUARIO = 'usr-1';
const PYG = '11111111-1111-4111-8111-111111111111';
const USD = '22222222-2222-4222-8222-222222222222';
const EUR = '33333333-3333-4333-8333-333333333333';

function montar(opts: { activas?: string[]; previas?: Array<Record<string, unknown>> } = {}) {
  const activas = opts.activas ?? [PYG, USD];
  const tx = {
    empresa_monedas: { findMany: jest.fn(async () => activas.map((moneda_id) => ({ moneda_id }))) },
    config_compras_moneda: {
      findMany: jest.fn(async () => opts.previas ?? []),
      upsert: jest.fn(async (_a: any) => ({})),
      deleteMany: jest.fn(async (_a: any) => ({ count: 1 })),
    },
  };
  const prisma = { $transaction: jest.fn(async (fn: any) => fn(tx)) };
  const audit = { logEnTransaccion: jest.fn() };
  const service = new ComprasService(prisma as any, {} as any, {} as any, {} as any, {} as any, {} as any, audit as any) as any;
  const lista = [{ moneda_id: PYG }];
  service.listConfigMoneda = jest.fn().mockResolvedValue(lista);
  return { service: service as ComprasService, tx, audit, lista };
}

const rechazo = async (p: Promise<unknown>) => {
  try {
    await p;
  } catch (e) {
    return (e as HttpException).getResponse() as Record<string, unknown>;
  }
  throw new Error('no lanzó');
};
const fila = (moneda_id: string, extra: Record<string, unknown> = {}) => ({ moneda_id, decimales_monto: 2, decimales_porcentaje: 4, modo_redondeo: 'HALF_UP', ...extra });

describe('ComprasService.guardarConfigMonedaLote', () => {
  it('guarda y restablece en una transacción y devuelve la lista', async () => {
    const m = montar();
    const r = await m.service.guardarConfigMonedaLote(EMPRESA, { guardar: [fila(USD, { decimales_monto: 1 })] as any, restablecer: [PYG] }, USUARIO);
    expect(r).toBe(m.lista);
    expect(m.tx.config_compras_moneda.upsert).toHaveBeenCalledTimes(1);
    expect(m.tx.config_compras_moneda.upsert.mock.calls[0]?.[0]).toMatchObject({
      where: { empresa_id_moneda_id: { empresa_id: EMPRESA, moneda_id: USD } },
      create: { decimales_monto: 1, decimales_porcentaje: 4, modo_redondeo: 'HALF_UP' },
    });
    expect(m.tx.config_compras_moneda.deleteMany).toHaveBeenCalledWith({ where: { empresa_id: EMPRESA, moneda_id: { in: [PYG] } } });
    expect((m.service as any).prisma.$transaction).toHaveBeenCalledTimes(1);
  });

  it('decimales_monto sin informar guarda null (estándar de la moneda)', async () => {
    const m = montar();
    await m.service.guardarConfigMonedaLote(EMPRESA, { guardar: [{ moneda_id: USD }] as any, restablecer: [] }, USUARIO);
    expect(m.tx.config_compras_moneda.upsert.mock.calls[0]?.[0].create).toMatchObject({ decimales_monto: null });
  });

  it('moneda no activa en la empresa: MONEDA_NO_HABILITADA con campo y linea, sin escribir ni auditar', async () => {
    const m = montar();
    const r = await rechazo(m.service.guardarConfigMonedaLote(EMPRESA, { guardar: [fila(USD), fila(EUR)] as any, restablecer: [] }, USUARIO));
    expect(r).toMatchObject({ codigo: 'MONEDA_NO_HABILITADA', campo: 'moneda_id', linea: 2 });
    expect(m.tx.config_compras_moneda.upsert).not.toHaveBeenCalled();
    expect(m.audit.logEnTransaccion).not.toHaveBeenCalled();
  });

  it('Review Focus: PYG repetida en guardar y en restablecer: MONEDA_REPETIDA, sin upsert ni delete', async () => {
    const m = montar();
    const r = await rechazo(m.service.guardarConfigMonedaLote(EMPRESA, { guardar: [fila(PYG)] as any, restablecer: [PYG] }, USUARIO));
    expect(r).toMatchObject({ codigo: 'MONEDA_REPETIDA', campo: 'moneda_id' });
    expect(m.tx.config_compras_moneda.upsert).not.toHaveBeenCalled();
    expect(m.tx.config_compras_moneda.deleteMany).not.toHaveBeenCalled();
    expect((m.service as any).prisma.$transaction).not.toHaveBeenCalled();
  });

  it('Review Focus: PYG dos veces dentro de guardar, o dos veces en restablecer: MONEDA_REPETIDA', async () => {
    const a = montar();
    expect(await rechazo(a.service.guardarConfigMonedaLote(EMPRESA, { guardar: [fila(PYG), fila(PYG)] as any, restablecer: [] }, USUARIO))).toMatchObject({
      codigo: 'MONEDA_REPETIDA',
      linea: 2,
    });
    const b = montar();
    expect(await rechazo(b.service.guardarConfigMonedaLote(EMPRESA, { guardar: [], restablecer: [PYG, PYG] }, USUARIO))).toMatchObject({
      codigo: 'MONEDA_REPETIDA',
    });
    expect(a.tx.config_compras_moneda.upsert).not.toHaveBeenCalled();
    expect(b.tx.config_compras_moneda.deleteMany).not.toHaveBeenCalled();
  });

  it('DOBA: restablecer PYG borra su override y audita CONFIG_MONEDA_GUARDADA con el antes y el después', async () => {
    const m = montar({ previas: [{ moneda_id: PYG, decimales_monto: 0, decimales_porcentaje: 2, modo_redondeo: 'DOWN' }] });
    await m.service.guardarConfigMonedaLote(EMPRESA, { guardar: [], restablecer: [PYG] }, USUARIO);
    expect(m.tx.config_compras_moneda.deleteMany).toHaveBeenCalledWith({ where: { empresa_id: EMPRESA, moneda_id: { in: [PYG] } } });
    expect(m.audit.logEnTransaccion).toHaveBeenCalledTimes(1);
    expect(m.audit.logEnTransaccion.mock.calls[0][1]).toMatchObject({
      empresa_id: EMPRESA,
      user_id: USUARIO,
      action: 'CONFIG_MONEDA_GUARDADA',
      entity_type: 'config_compras_moneda',
      old_value: { [PYG]: { decimales_monto: 0, decimales_porcentaje: 2, modo_redondeo: 'DOWN' } },
      new_value: { [PYG]: null },
    });
  });

  it('restablecer una moneda que la empresa ya no tiene activa pasa: borra el override huérfano (solo guardar exige moneda activa)', async () => {
    const m = montar({ activas: [PYG], previas: [{ moneda_id: EUR, decimales_monto: 1, decimales_porcentaje: 4, modo_redondeo: 'HALF_UP' }] });
    await expect(m.service.guardarConfigMonedaLote(EMPRESA, { guardar: [], restablecer: [EUR] }, USUARIO)).resolves.toBe(m.lista);
    expect(m.tx.config_compras_moneda.deleteMany).toHaveBeenCalledWith({ where: { empresa_id: EMPRESA, moneda_id: { in: [EUR] } } });
    expect(m.audit.logEnTransaccion.mock.calls[0][1]).toMatchObject({ old_value: { [EUR]: { decimales_monto: 1 } }, new_value: { [EUR]: null } });
  });

  it('una sola fila de auditoría por lote, con todas las monedas', async () => {
    const m = montar({ previas: [{ moneda_id: USD, decimales_monto: null, decimales_porcentaje: 4, modo_redondeo: 'HALF_UP' }] });
    await m.service.guardarConfigMonedaLote(EMPRESA, { guardar: [fila(USD, { decimales_monto: 1 })] as any, restablecer: [PYG] }, USUARIO);
    expect(m.audit.logEnTransaccion).toHaveBeenCalledTimes(1);
    const { old_value, new_value } = m.audit.logEnTransaccion.mock.calls[0][1];
    expect(Object.keys(new_value).sort()).toEqual([PYG, USD].sort());
    expect(old_value[USD]).toMatchObject({ decimales_monto: null });
    expect(new_value[USD]).toMatchObject({ decimales_monto: 1 });
  });

  it('lote vacío: devuelve la lista sin escribir ni auditar', async () => {
    const m = montar();
    await expect(m.service.guardarConfigMonedaLote(EMPRESA, { guardar: [], restablecer: [] }, USUARIO)).resolves.toBe(m.lista);
    expect((m.service as any).prisma.$transaction).not.toHaveBeenCalled();
    expect(m.audit.logEnTransaccion).not.toHaveBeenCalled();
  });

  describe('DTO (ValidationPipe real)', () => {
    it('acepta un lote válido', async () => {
      await expect(validarDto(GuardarConfigMonedaLoteDto, { guardar: [{ moneda_id: USD, decimales_monto: null }], restablecer: [PYG] })).resolves.toBeDefined();
    });

    it('rechaza ids que no son uuid, decimales fuera de rango y campos de más', async () => {
      for (const mal of [
        { guardar: [], restablecer: ['PYG'] },
        { guardar: [{ moneda_id: 'x' }], restablecer: [] },
        { guardar: [{ moneda_id: USD, decimales_monto: 3 }], restablecer: [] },
        { guardar: [{ moneda_id: USD, modo_redondeo: 'TECHO' }], restablecer: [] },
        { guardar: [], restablecer: [], otro: 1 },
        { restablecer: [] },
      ]) {
        await expect(validarDto(GuardarConfigMonedaLoteDto, mal)).rejects.toMatchObject({ status: 400 });
      }
    });
  });
});
