import { ForbiddenException } from '@nestjs/common';
import { FacturasService } from './facturas.service';

/**
 * L13/L14: el tope se mide sobre el precio NETO unitario contra el piso del
 * servidor. Antes se medía el % de descuento contra total_bruto, así que bajar
 * el precio unitario a mano (total_bruto baja con él) esquivaba el tope y el PIN.
 */
describe('FacturasService.validarTopeDescuentoFactura', () => {
  const crear = (piso: any, principal = 'PYG', autorizacion: any = null, modoCaja: string | null = null) => {
    const service = Object.create(FacturasService.prototype) as any;
    const pisosDeVenta = jest.fn().mockResolvedValue({ p1: piso });
    service.listaPreciosService = {
      monedaPrincipal: jest.fn().mockResolvedValue(principal),
      pisosDeVenta,
    };
    service.prisma = {
      autorizaciones_caja: { findUnique: jest.fn().mockResolvedValue(autorizacion) },
      pos_config: { findUnique: jest.fn().mockResolvedValue(modoCaja ? { precio_bajo_minimo: modoCaja } : null) },
    };
    return { service, pisosDeVenta };
  };
  const item = (precio: number, totalOperacion: number, cantidad = 1) => ({
    producto_id: 'p1',
    descripcion: 'Producto 1',
    cantidad,
    precio_unitario: precio,
    total_bruto: precio * cantidad,
    total_operacion: totalOperacion,
  });
  const piso = { piso: 6000, origen: 'costo', precioLista: 10000, moneda: 'PYG' };
  const validar = (service: any, items: any[], extra: any = {}) =>
    service.validarTopeDescuentoFactura({ items, empresaId: 'e1', clienteId: 'c1', monedaCodigo: 'PYG', ...extra });

  it('reproduce la evasión: precio unitario bajado a mano sin descuento → ahora pide autorización', async () => {
    const { service } = crear(piso);
    // Antes: total_bruto = total_operacion = 4000 → 0 % de descuento → pasaba.
    await expect(validar(service, [item(4000, 4000)])).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('descuento dentro del piso no pide autorización', async () => {
    const { service } = crear(piso);
    await expect(validar(service, [item(10000, 13000, 2)])).resolves.toEqual({ requiereConsumoAutorizacion: false });
  });

  it('precio bajado más descuento que cruza el piso pide autorización con el detalle', async () => {
    const { service } = crear(piso);
    const err = await validar(service, [item(7000, 11000, 2)]).catch((e: any) => e);
    expect(err).toBeInstanceOf(ForbiddenException);
    expect(err.getResponse().codigo).toBe('PRECIO_BAJO_MINIMO_REQUIERE_AUTORIZACION');
    const detalle = err.getResponse().items[0];
    expect(detalle).toMatchObject({ producto_id: 'p1', precioNeto: 5500, piso: 6000, moneda: 'PYG' });
    expect(detalle.topeDescuentoPct).toBeCloseTo(40);
    expect(detalle.descuentoAplicadoPct).toBeCloseTo(45);
  });

  it('el anticipo aplicado no cuenta como descuento', async () => {
    const { service } = crear(piso);
    const conAnticipo = { ...item(10000, 3000), anticipo_precio_unitario: 7000 };
    await expect(validar(service, [conAnticipo])).resolves.toEqual({ requiereConsumoAutorizacion: false });
  });

  it('factura en USD: pasa la cotización de la factura para convertir el piso (L14)', async () => {
    const { service, pisosDeVenta } = crear({ piso: 1, origen: 'costo', precioLista: 2, moneda: 'USD' });
    await expect(validar(service, [item(0.9, 0.9)], { monedaCodigo: 'USD', tipoCambio: 7500 })).rejects.toBeInstanceOf(
      ForbiddenException,
    );
    expect(pisosDeVenta).toHaveBeenCalledWith(expect.objectContaining({ monedaFactura: 'USD', cotizacion: 7500 }));
  });

  it('con autorización aprobada y vigente pasa y pide consumirla', async () => {
    const { service } = crear(piso, 'PYG', {
      empresa_id: 'e1',
      tipo: 'descuento',
      estado: 'aprobada',
      expires_at: new Date(Date.now() + 60000),
    });
    await expect(validar(service, [item(4000, 4000)], { autorizacionId: 'a1' })).resolves.toEqual({
      requiereConsumoAutorizacion: true,
      autorizacionId: 'a1',
    });
  });

  it('una autorización de otra empresa no sirve', async () => {
    const { service } = crear(piso, 'PYG', {
      empresa_id: 'otra',
      tipo: 'descuento',
      estado: 'aprobada',
      expires_at: new Date(Date.now() + 60000),
    });
    await expect(validar(service, [item(4000, 4000)], { autorizacionId: 'a1' })).rejects.toBeInstanceOf(
      ForbiddenException,
    );
  });

  it('sin piso medible no controla', async () => {
    const { service } = crear({ piso: null, origen: 'sin_control', precioLista: null, moneda: 'PYG' });
    await expect(validar(service, [item(1, 1)])).resolves.toEqual({ requiereConsumoAutorizacion: false });
  });

  describe('caja con «Precio bajo el mínimo» = aviso', () => {
    const confirmacion = (extra: any = {}) => ({
      empresa_id: 'e1',
      tipo: 'precio_minimo_aviso',
      estado: 'aprobada',
      solicitante_id: 'vendedor',
      expires_at: new Date(Date.now() + 60000),
      ...extra,
    });

    it('sin confirmación pide confirmar (no PIN), con el detalle', async () => {
      const { service } = crear(piso, 'PYG', null, 'aviso');
      const err = await validar(service, [item(4000, 4000)], { cajaId: 'caja-1', usuarioId: 'vendedor' }).catch((e: any) => e);
      expect(err).toBeInstanceOf(ForbiddenException);
      expect(err.getResponse()).toMatchObject({ codigo: 'PRECIO_BAJO_MINIMO_REQUIERE_CONFIRMACION', modo: 'aviso' });
      expect(err.getResponse().items[0]).toMatchObject({ precioNeto: 4000, piso: 6000 });
    });

    it('la confirmación del propio vendedor pasa y se consume', async () => {
      const { service } = crear(piso, 'PYG', confirmacion(), 'aviso');
      await expect(
        validar(service, [item(4000, 4000)], { autorizacionId: 'a1', cajaId: 'caja-1', usuarioId: 'vendedor' }),
      ).resolves.toEqual({ requiereConsumoAutorizacion: true, autorizacionId: 'a1' });
    });

    it('la confirmación de otro usuario no sirve', async () => {
      const { service } = crear(piso, 'PYG', confirmacion(), 'aviso');
      await expect(
        validar(service, [item(4000, 4000)], { autorizacionId: 'a1', cajaId: 'caja-1', usuarioId: 'otro' }),
      ).rejects.toBeInstanceOf(ForbiddenException);
    });

    it('la autorización de un supervisor también sirve en una caja con aviso', async () => {
      const { service } = crear(piso, 'PYG', confirmacion({ tipo: 'descuento', solicitante_id: 'otro' }), 'aviso');
      await expect(
        validar(service, [item(4000, 4000)], { autorizacionId: 'a1', cajaId: 'caja-1', usuarioId: 'vendedor' }),
      ).resolves.toMatchObject({ requiereConsumoAutorizacion: true });
    });

    it('una confirmación del vendedor en una caja con autorización (o sin caja) no sirve: pide supervisor', async () => {
      const { service } = crear(piso, 'PYG', confirmacion(), 'autorizacion');
      const err = await validar(service, [item(4000, 4000)], { autorizacionId: 'a1', cajaId: 'caja-2', usuarioId: 'vendedor' }).catch(
        (e: any) => e,
      );
      expect(err).toBeInstanceOf(ForbiddenException);
      expect(err.getResponse().codigo).toBe('PRECIO_BAJO_MINIMO_REQUIERE_AUTORIZACION');

      const sinCaja = crear(piso, 'PYG', confirmacion(), 'aviso').service;
      await expect(
        validar(sinCaja, [item(4000, 4000)], { autorizacionId: 'a1', cajaId: null, usuarioId: 'vendedor' }),
      ).rejects.toBeInstanceOf(ForbiddenException);
    });
  });
});
