import { ListaPreciosService } from './lista-precios.service';

/**
 * Precio de venta y piso del tope (L3, L1, L2, L13, L14): un solo cálculo en el
 * servidor, con recargo/mínimo/redondeo, listas por zona del cliente y el piso
 * pasado a la moneda de la factura con su cotización.
 */
describe('ListaPreciosService · precios y pisos de venta', () => {
  const listaGeneral = (extra: any = {}) => ({
    id: 'l-gen',
    codigo: 'GEN',
    nombre: 'General',
    moneda: 'PYG',
    prioridad: 1,
    tipo_aplicacion: 'general',
    aplica_descuento_general: false,
    descuento_porcentaje: 0,
    aplica_recargo_general: false,
    recargo_porcentaje: 0,
    redondeo_activo: false,
    ...extra,
  });

  const crear = (opts: {
    listas?: any[];
    listasCliente?: any[];
    filas?: any[];
    producto?: any;
    cliente?: any;
    asignacionesZona?: any[];
    principal?: string;
    cotizacion?: number;
  }) => {
    const producto = opts.producto ?? { id: 'p1', precio: 10000, precio_costo: 6000 };
    const listaFindMany = jest.fn().mockImplementation(({ where }) => {
      if (where.id) return Promise.resolve(opts.listasCliente ?? []);
      return Promise.resolve((opts.listas ?? []).filter((l) => !where.moneda || l.moneda === where.moneda));
    });
    const asignacionesFindMany = jest.fn().mockImplementation(({ where }) =>
      Promise.resolve(where.tipo_entidad === 'zona' ? (opts.asignacionesZona ?? []) : []),
    );
    const prisma: any = {
      clientes: { findFirst: jest.fn().mockResolvedValue(opts.cliente ?? null) },
      lista_precios_asignaciones: { findMany: asignacionesFindMany },
      lista_precios: { findMany: listaFindMany },
      productos: { findMany: jest.fn().mockResolvedValue([producto]) },
      lista_precios_productos: { findMany: jest.fn().mockResolvedValue(opts.filas ?? []) },
      empresa_monedas: {
        findFirst: jest.fn().mockResolvedValue({ moneda: { codigo: opts.principal ?? 'PYG' } }),
      },
      cotizacion_moneda: {
        findFirst: jest.fn().mockResolvedValue(opts.cotizacion ? { cotizacion_venta: opts.cotizacion } : null),
      },
    };
    const service = Object.create(ListaPreciosService.prototype) as ListaPreciosService;
    (service as any).prisma = prisma;
    return { service, prisma, listaFindMany, asignacionesFindMany };
  };

  it('la lista propia del cliente aplica su recargo general y su redondeo a un producto que no tiene (L3)', async () => {
    const lista = listaGeneral({ aplica_recargo_general: true, recargo_porcentaje: 10, redondeo_activo: true, redondeo_tipo: 'superior', redondeo_decimales: -2 });
    const { service } = crear({
      listas: [lista],
      listasCliente: [lista],
      cliente: { id: 'c1', lista_precios_id: 'l-gen', zona_id: null },
      producto: { id: 'p1', precio: 10050, precio_costo: 0 },
    });
    const r = await service.obtenerPrecioProducto({ productoId: 'p1', empresaId: 'e1', clienteId: 'c1' });
    // 10050 × 1.10 = 11055 → redondeo superior a la centena = 11100
    expect(r.precioFinal).toBe(11100);
  });

  it('una lista general que no tiene el producto no le aplica su recargo al cliente sin lista (incidente DOBA)', async () => {
    const { service } = crear({
      listas: [listaGeneral({ aplica_recargo_general: true, recargo_porcentaje: 20 })],
      producto: { id: 'p1', precio: 4400, precio_costo: 0 },
    });
    const r = await service.obtenerPrecioProducto({ productoId: 'p1', empresaId: 'e1' });
    expect(r.precioFinal).toBe(4400);
    expect(r.listaAplicada).toBeNull();
  });

  it('aplica el precio mínimo del producto en la lista (L3)', async () => {
    const { service } = crear({
      listas: [listaGeneral()],
      filas: [{ lista_precios_id: 'l-gen', producto_id: 'p1', precio_base: 10000, descuento_porcentaje: 50, precio_minimo: 8000 }],
    });
    const r = await service.obtenerPrecioProducto({ productoId: 'p1', empresaId: 'e1' });
    expect(r.precioFinal).toBe(8000);
  });

  it('usa la lista asignada a la zona del cliente, por id del catálogo (L1)', async () => {
    const listaZona = listaGeneral({ id: 'l-zona', codigo: 'ZN', tipo_aplicacion: 'zona', prioridad: 3 });
    const { service, asignacionesFindMany } = crear({
      cliente: { lista_precios_id: null, zona_id: 'z-central' },
      asignacionesZona: [{ lista_precios_id: 'l-zona' }],
      listasCliente: [listaZona],
      listas: [listaGeneral()],
      filas: [
        { lista_precios_id: 'l-zona', producto_id: 'p1', precio_base: 9000 },
        { lista_precios_id: 'l-gen', producto_id: 'p1', precio_base: 9500 },
      ],
    });
    const r = await service.obtenerPrecioProducto({ productoId: 'p1', empresaId: 'e1', clienteId: 'c1' });
    expect(r.listaAplicada.id).toBe('l-zona');
    expect(r.precioFinal).toBe(9000);
    const llamadaZona = asignacionesFindMany.mock.calls.find(([a]) => a.where.tipo_entidad === 'zona');
    expect(llamadaZona[0].where.zona_id).toBe('z-central');
  });

  it('ordena por prioridad ascendente y, a igual prioridad, la más antigua (L2, incidente DOBA)', async () => {
    const { service, listaFindMany } = crear({ listas: [listaGeneral()] });
    await service.obtenerPrecioProducto({ productoId: 'p1', empresaId: 'e1' });
    expect(listaFindMany.mock.calls[0][0].orderBy).toEqual([{ prioridad: 'asc' }, { fecha_creacion: 'asc' }]);
  });

  describe('pisosDeVenta', () => {
    it('sin precio mínimo, el piso es el costo', async () => {
      const { service } = crear({ listas: [listaGeneral()], filas: [{ lista_precios_id: 'l-gen', producto_id: 'p1', precio_base: 10000 }] });
      const r = await service.pisosDeVenta({ productoIds: ['p1'], empresaId: 'e1', monedaFactura: 'PYG' });
      expect(r.p1).toMatchObject({ piso: 6000, origen: 'costo', precioLista: 10000 });
    });

    it('con precio mínimo en la lista, el piso es el mínimo', async () => {
      const { service } = crear({
        listas: [listaGeneral()],
        filas: [{ lista_precios_id: 'l-gen', producto_id: 'p1', precio_base: 10000, precio_minimo: 7500 }],
      });
      const r = await service.pisosDeVenta({ productoIds: ['p1'], empresaId: 'e1', monedaFactura: 'PYG' });
      expect(r.p1).toMatchObject({ piso: 7500, origen: 'precio_minimo' });
    });

    it('sin costo ni mínimo ni tope manual, el piso es el precio de lista (todo descuento pide autorización)', async () => {
      const { service } = crear({ listas: [], producto: { id: 'p1', precio: 10000, precio_costo: 0 } });
      const r = await service.pisosDeVenta({ productoIds: ['p1'], empresaId: 'e1', monedaFactura: 'PYG' });
      expect(r.p1).toMatchObject({ piso: 10000, origen: 'precio_lista' });
    });

    it('un costo por encima del precio de lista se baja al precio de lista', async () => {
      const { service } = crear({ listas: [], producto: { id: 'p1', precio: 5000, precio_costo: 6000 } });
      const r = await service.pisosDeVenta({ productoIds: ['p1'], empresaId: 'e1', monedaFactura: 'PYG' });
      expect(r.p1.piso).toBe(5000);
    });

    it('factura en USD: el costo en guaraníes se pasa a dólares con la cotización (L14)', async () => {
      const listaUsd = listaGeneral({ id: 'l-usd', moneda: 'USD' });
      const { service } = crear({
        listas: [listaUsd],
        filas: [{ lista_precios_id: 'l-usd', producto_id: 'p1', precio_base: 2 }],
        producto: { id: 'p1', precio: 15000, precio_costo: 7500 },
      });
      const r = await service.pisosDeVenta({ productoIds: ['p1'], empresaId: 'e1', monedaFactura: 'USD', cotizacion: 7500 });
      expect(r.p1).toMatchObject({ piso: 1, origen: 'costo', precioLista: 2, moneda: 'USD' });
    });

    it('factura en USD sin cotización: el costo no se usa y el piso es el precio de lista', async () => {
      const listaUsd = listaGeneral({ id: 'l-usd', moneda: 'USD' });
      const { service } = crear({
        listas: [listaUsd],
        filas: [{ lista_precios_id: 'l-usd', producto_id: 'p1', precio_base: 2 }],
      });
      const r = await service.pisosDeVenta({ productoIds: ['p1'], empresaId: 'e1', monedaFactura: 'USD', cotizacion: 0 });
      expect(r.p1).toMatchObject({ piso: 2, origen: 'precio_lista' });
    });
  });

  it('batch en USD: el costo se pasa con la última cotización y el tope sale de ahí (E2E 2026-10-25)', async () => {
    const { service } = crear({
      listasCliente: [listaGeneral({ id: 'l-usd', moneda: 'USD', tipo_aplicacion: 'cliente' })],
      cliente: { id: 'c1', lista_precios_id: 'l-usd', zona_id: null },
      filas: [{ lista_precios_id: 'l-usd', producto_id: 'p1', precio_base: 2, precio_minimo: 0 }],
      cotizacion: 7500,
    });
    const r = await service.obtenerPreciosProductosBatch({ productoIds: ['p1'], empresaId: 'e', clienteId: 'c1', moneda: 'USD' });
    expect(r.p1.precioFinal).toBe(2);
    expect(r.p1.precioCosto).toBeCloseTo(0.8);
    expect(r.p1.topeDescuentoPct).toBeCloseTo(60);
  });

  it('batch en USD sin cotización cargada: costo 0 (sin control desde el costo)', async () => {
    const { service } = crear({
      listasCliente: [listaGeneral({ id: 'l-usd', moneda: 'USD', tipo_aplicacion: 'cliente' })],
      cliente: { id: 'c1', lista_precios_id: 'l-usd', zona_id: null },
      filas: [{ lista_precios_id: 'l-usd', producto_id: 'p1', precio_base: 2, precio_minimo: 0 }],
    });
    const r = await service.obtenerPreciosProductosBatch({ productoIds: ['p1'], empresaId: 'e', clienteId: 'c1', moneda: 'USD' });
    expect(r.p1.precioCosto).toBe(0);
  });

  it('el redondeo «superior» no sube por el error de coma flotante (10.000 + 7,78% = 10.778)', async () => {
    const lista = listaGeneral({ aplica_recargo_general: true, recargo_porcentaje: 7.78, redondeo_activo: true, redondeo_tipo: 'superior', redondeo_decimales: 0 });
    const { service } = crear({
      listas: [lista],
      listasCliente: [lista],
      cliente: { id: 'c1', lista_precios_id: 'l-gen', zona_id: null },
      producto: { id: 'p1', precio: 10000, precio_costo: 0 },
    });
    const r = await service.obtenerPreciosProductosBatch({ productoIds: ['p1'], empresaId: 'e', clienteId: 'c1', moneda: 'PYG' });
    expect(r.p1.precioFinal).toBe(10778);
  });
});
