import { OfertasService } from './ofertas.service';

/**
 * Red de resolución (Stock P3): cómo entra una oferta en el precio. Estas aserciones en PYG
 * son las del motor viejo y no se cambian nunca: una aserción que cambia es un precio que cambió.
 */
const PRODUCTO = { id: 'p1', categoria_id: 'c1', marca_id: 'm1' };
const TODOS = [{ aplica_a: 'todos', referencia_id: null, excluir: false }];

const oferta = (d: Record<string, unknown> = {}) => ({
  id: 'o1',
  nombre: 'Promo',
  tipo: 'descuento_porcentaje',
  valor: 10,
  prioridad: 1,
  acumulable_lista_precios: true,
  moneda: null,
  oferta_aplicacion: TODOS,
  oferta_sucursales: [],
  ...d,
});

const crear = (ofertas: any[] = [], principal = 'PYG') => {
  const prisma: any = {
    productos: { findMany: jest.fn().mockResolvedValue([PRODUCTO]) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda: { codigo: principal } }) },
  };
  const service = new OfertasService(prisma, {} as any, { set: jest.fn() } as any);
  jest.spyOn(service, 'getOfertasActivas').mockResolvedValue(ofertas as any);
  return { service, prisma };
};

const evaluar = async (ofertas: any[], item: Record<string, unknown> = {}, extra: Record<string, unknown> = {}, principal = 'PYG') => {
  const { service } = crear(ofertas, principal);
  const r = await service.evaluarOfertas({ items: [{ producto_id: 'p1', cantidad: 1, precio_unitario: 65000, ...item }], ...extra } as any, 'e1');
  return { ...r.items[0], total_descuento: r.total_descuento } as any;
};

describe('Red de resolución de ofertas', () => {
  it('M1 sin ofertas ni lista: base', async () => {
    expect(await evaluar([])).toMatchObject({ precio_final: 65000, origen_precio: 'base', descuento: 0, oferta_id: null });
  });

  it('M2 sin ofertas con lista 60000: lista', async () => {
    expect(await evaluar([], { precio_lista: 60000 })).toMatchObject({ precio_final: 60000, origen_precio: 'lista_precios', oferta_id: null });
  });

  it('M3 10 % sin lista', async () => {
    expect(await evaluar([oferta()])).toMatchObject({ precio_final: 58500, descuento: 6500, origen_precio: 'oferta', oferta_id: 'o1' });
  });

  it('M4 10 % acumulable con lista 60000', async () => {
    expect(await evaluar([oferta()], { precio_lista: 60000 })).toMatchObject({ precio_final: 54000, descuento: 6000, origen_precio: 'lista_precios+oferta' });
  });

  it('M5 10 % no acumulable con lista 60000: sobre la base y gana a la lista', async () => {
    expect(await evaluar([oferta({ acumulable_lista_precios: false })], { precio_lista: 60000 })).toMatchObject({ precio_final: 58500, origen_precio: 'oferta' });
  });

  it('M6 5 % no acumulable con lista 60000: la lista da mejor precio', async () => {
    expect(await evaluar([oferta({ acumulable_lista_precios: false, valor: 5 })], { precio_lista: 60000 })).toMatchObject({ precio_final: 60000, origen_precio: 'lista_precios', oferta_id: null });
  });

  it('M7 monto 5000', async () => {
    expect(await evaluar([oferta({ tipo: 'descuento_monto', valor: 5000, moneda: 'PYG' })])).toMatchObject({ precio_final: 60000, descuento: 5000 });
  });

  it('M7 monto 70000 no pasa de cero', async () => {
    expect(await evaluar([oferta({ tipo: 'descuento_monto', valor: 70000, moneda: 'PYG' })])).toMatchObject({ precio_final: 0, descuento: 65000 });
  });

  it('M8 precio especial 50000', async () => {
    expect(await evaluar([oferta({ tipo: 'precio_especial', valor: 50000, moneda: 'PYG' })])).toMatchObject({ precio_final: 50000, descuento: 15000, origen_precio: 'oferta' });
  });

  it('M8 precio especial 70000, más caro que la base: no aplica', async () => {
    expect(await evaluar([oferta({ tipo: 'precio_especial', valor: 70000, moneda: 'PYG' })])).toMatchObject({ precio_final: 65000, origen_precio: 'base', oferta_id: null });
  });

  it('M9 precio especial 50000 acumulable con lista 60000', async () => {
    expect(await evaluar([oferta({ tipo: 'precio_especial', valor: 50000, moneda: 'PYG' })], { precio_lista: 60000 })).toMatchObject({
      precio_final: 50000,
      descuento: 10000,
      origen_precio: 'lista_precios+oferta',
    });
  });

  it.each([
    ['producto', 'p1'],
    ['categoria', 'c1'],
    ['marca', 'm1'],
    ['todos', null],
  ])('M10 aplica por %s', async (aplica_a, referencia_id) => {
    const r = await evaluar([oferta({ oferta_aplicacion: [{ aplica_a, referencia_id, excluir: false }] })]);
    expect(r).toMatchObject({ precio_final: 58500, oferta_id: 'o1' });
  });

  it.each([
    ['producto', 'otro'],
    ['categoria', 'otra'],
    ['marca', 'otra'],
  ])('M10 no aplica por %s de otro', async (aplica_a, referencia_id) => {
    const r = await evaluar([oferta({ oferta_aplicacion: [{ aplica_a, referencia_id, excluir: false }] })]);
    expect(r).toMatchObject({ precio_final: 65000, oferta_id: null });
  });

  it.each([
    ['producto', 'p1'],
    ['categoria', 'c1'],
    ['marca', 'm1'],
  ])('M10 excluida por %s no aplica', async (aplica_a, referencia_id) => {
    const r = await evaluar([oferta({ oferta_aplicacion: [...TODOS, { aplica_a, referencia_id, excluir: true }] })]);
    expect(r).toMatchObject({ precio_final: 65000, oferta_id: null });
  });

  it('M10 sin aplicaciones no aplica', async () => {
    expect(await evaluar([oferta({ oferta_aplicacion: [] })])).toMatchObject({ precio_final: 65000, oferta_id: null });
  });

  it('M11 lista igual a la base no cuenta como lista', async () => {
    expect(await evaluar([oferta()], { precio_lista: 65000 })).toMatchObject({ precio_final: 58500, origen_precio: 'oferta' });
  });

  it('M12 cantidad 3', async () => {
    expect(await evaluar([oferta()], { cantidad: 3 })).toMatchObject({ descuento_total: 19500, total_descuento: 19500 });
  });

  it('M13 forma de la respuesta, con y sin ofertas vigentes', async () => {
    const { service } = crear([oferta()]);
    const con = await service.evaluarOfertas({ items: [{ producto_id: 'p1', cantidad: 1, precio_unitario: 65000 }] } as any, 'e1');
    expect(Object.keys(con.items[0]).sort()).toEqual(['cantidad', 'descuento', 'descuento_total', 'nombre_oferta', 'oferta_id', 'origen_precio', 'precio_final', 'precio_lista', 'precio_original', 'producto_id', 'tipo_oferta']);
    const { service: sin } = crear([]);
    const vacio = await sin.evaluarOfertas({ items: [{ producto_id: 'p1', cantidad: 1, precio_unitario: 65000 }] } as any, 'e1');
    expect(Object.keys(vacio.items[0]).sort()).toEqual(['cantidad', 'descuento', 'nombre_oferta', 'oferta_id', 'origen_precio', 'precio_final', 'precio_lista', 'precio_original', 'producto_id']);
  });

  describe('getOfertasActivas', () => {
    const conFilas = (filas: any[]) => {
      const prisma: any = { ofertas: { findMany: jest.fn().mockResolvedValue(filas) } };
      return { service: new OfertasService(prisma, {} as any, { set: jest.fn() } as any), prisma };
    };
    const FILAS = [
      { id: 'a', oferta_sucursales: [] },
      { id: 'b', oferta_sucursales: [{ sucursal_id: 's1' }] },
      { id: 'c', oferta_sucursales: [{ sucursal_id: 's2' }] },
    ];

    it('pide las de la empresa, activas y vigentes', async () => {
      const { service, prisma } = conFilas([]);
      await service.getOfertasActivas('e1');
      const { where } = prisma.ofertas.findMany.mock.calls[0][0];
      expect(where).toMatchObject({ empresa_id: 'e1', active: true, fecha_inicio: { lte: expect.any(Date) }, fecha_fin: { gte: expect.any(Date) } });
    });

    it('con sucursal filtra, y la que no tiene sucursales pasa', async () => {
      const { service } = conFilas(FILAS);
      expect((await service.getOfertasActivas('e1', 's1')).map((o) => o.id)).toEqual(['a', 'b']);
    });

    it('sin sucursal no filtra', async () => {
      const { service } = conFilas(FILAS);
      expect((await service.getOfertasActivas('e1')).map((o) => o.id)).toEqual(['a', 'b', 'c']);
    });
  });

  // Eran it.failing contra el motor viejo (T1).
  it('productos.findMany lleva empresa_id', async () => {
    const { service, prisma } = crear([oferta()]);
    await service.evaluarOfertas({ items: [{ producto_id: 'p1', cantidad: 1, precio_unitario: 65000 }] } as any, 'e1');
    expect(prisma.productos.findMany.mock.calls[0][0].where).toMatchObject({ empresa_id: 'e1' });
  });

  it('10 % en USD sobre 12.5 da 11.25', async () => {
    expect(await evaluar([oferta()], { precio_unitario: 12.5 }, { moneda: 'USD' })).toMatchObject({ precio_final: 11.25 });
  });

  it('monto en PYG en documento USD no aplica', async () => {
    expect(await evaluar([oferta({ tipo: 'descuento_monto', valor: 5, moneda: 'PYG' })], { precio_unitario: 20 }, { moneda: 'USD' })).toMatchObject({ precio_final: 20, oferta_id: null });
  });

  it('monto en USD sin moneda, principal PYG, no aplica', async () => {
    expect(await evaluar([oferta({ tipo: 'descuento_monto', valor: 5, moneda: 'USD' })], { precio_unitario: 20 })).toMatchObject({ precio_final: 20, oferta_id: null });
  });

  it('oferta en USD en documento USD aplica: 20 − 5 = 15', async () => {
    expect(await evaluar([oferta({ tipo: 'descuento_monto', valor: 5, moneda: 'USD' })], { precio_unitario: 20 }, { moneda: 'USD' })).toMatchObject({ precio_final: 15, oferta_id: 'o1' });
  });

  it('monto sin moneda (dato viejo) en documento USD no aplica: no deja el producto gratis', async () => {
    expect(await evaluar([oferta({ tipo: 'descuento_monto', valor: 5000, moneda: null })], { precio_unitario: 15 }, { moneda: 'USD' })).toMatchObject({ precio_final: 15, oferta_id: null });
  });

  it('precio especial sin moneda en documento USD no aplica', async () => {
    expect(await evaluar([oferta({ tipo: 'precio_especial', valor: 10, moneda: null })], { precio_unitario: 15 }, { moneda: 'USD' })).toMatchObject({ precio_final: 15, oferta_id: null });
  });

  it('monto sin moneda en documento PYG (la principal) aplica', async () => {
    expect(await evaluar([oferta({ tipo: 'descuento_monto', valor: 5000, moneda: null })], { precio_unitario: 65000 }, { moneda: 'PYG' })).toMatchObject({ precio_final: 60000, oferta_id: 'o1' });
  });

  it('monto sin moneda y sin moneda en el documento: vale la principal', async () => {
    expect(await evaluar([oferta({ tipo: 'descuento_monto', valor: 5000, moneda: null })], { precio_unitario: 65000 })).toMatchObject({ precio_final: 60000 });
  });

  it('empresa con principal USD: monto sin moneda aplica en USD y no en PYG', async () => {
    const { service } = crear([oferta({ tipo: 'descuento_monto', valor: 5, moneda: null })], 'USD');
    const evalua = async (moneda: string) => (await service.evaluarOfertas({ items: [{ producto_id: 'p1', cantidad: 1, precio_unitario: 20 }], moneda } as any, 'e1')).items[0];
    expect(await evalua('USD')).toMatchObject({ precio_final: 15 });
    expect(await evalua('PYG')).toMatchObject({ precio_final: 20, oferta_id: null });
  });

  it('principal consultada una sola vez por pedido', async () => {
    const { service, prisma } = crear([oferta({ tipo: 'descuento_monto', valor: 5000, moneda: 'PYG' })]);
    const items = [1, 2, 3].map(() => ({ producto_id: 'p1', cantidad: 1, precio_unitario: 65000 }));
    const r = await service.evaluarOfertas({ items } as any, 'e1');
    expect(r.items.map((i: any) => i.precio_final)).toEqual([60000, 60000, 60000]);
    expect(prisma.empresa_monedas.findFirst).toHaveBeenCalledTimes(1);
  });

  it('documento con moneda explícita no consulta la principal', async () => {
    const { service, prisma } = crear([oferta()]);
    await service.evaluarOfertas({ items: [{ producto_id: 'p1', cantidad: 1, precio_unitario: 65000 }], moneda: 'PYG' } as any, 'e1');
    expect(prisma.empresa_monedas.findFirst).not.toHaveBeenCalled();
  });

  it('% en PYG sigue entero: 65001 × 10 % → descuento 6500', async () => {
    expect(await evaluar([oferta()], { precio_unitario: 65001 })).toMatchObject({ descuento: 6500, precio_final: 58501 });
  });

  it('fuera de PYG sin ruido de coma flotante: 15,30 con 10 % → 13,77', async () => {
    expect(await evaluar([oferta()], { precio_unitario: 15.3 }, { moneda: 'USD' })).toMatchObject({ descuento: 1.53, precio_final: 13.77 });
  });

  it('% en USD aplica aunque la principal sea PYG', async () => {
    expect(await evaluar([oferta()], { precio_unitario: 12.5 }, { moneda: 'USD' })).toMatchObject({ oferta_id: 'o1' });
  });

  it('sin ofertas vigentes de la moneda la respuesta es la de «sin ofertas»', async () => {
    const { service } = crear([oferta({ tipo: 'descuento_monto', valor: 5, moneda: 'PYG' })]);
    const r = await service.evaluarOfertas({ items: [{ producto_id: 'p1', cantidad: 1, precio_unitario: 20 }], moneda: 'USD' } as any, 'e1');
    expect(Object.keys(r.items[0])).not.toContain('tipo_oferta');
  });
});

describe('Empresa sin moneda principal (ola final, O2)', () => {
  const evaluarSinPrincipal = async (ofertas: any[], extra: Record<string, unknown> = {}) => {
    const { service, prisma } = crear(ofertas);
    prisma.empresa_monedas.findFirst.mockResolvedValue(null);
    const r = await service.evaluarOfertas({ items: [{ producto_id: 'p1', cantidad: 1, precio_unitario: 65000 }], ...extra } as any, 'e1');
    return r.items[0] as any;
  };

  it.each([
    ['descuento_monto', 5000],
    ['precio_especial', 50000],
  ])('%s sin moneda no aplica en PYG ni sin moneda pedida', async (tipo, valor) => {
    expect(await evaluarSinPrincipal([oferta({ tipo, valor })], { moneda: 'PYG' })).toMatchObject({ precio_final: 65000, oferta_id: null });
    expect(await evaluarSinPrincipal([oferta({ tipo, valor })])).toMatchObject({ precio_final: 65000, oferta_id: null });
  });

  it('el % sin moneda sí aplica, en PYG y sin moneda pedida', async () => {
    expect(await evaluarSinPrincipal([oferta()], { moneda: 'PYG' })).toMatchObject({ precio_final: 58500, oferta_id: 'o1' });
    expect(await evaluarSinPrincipal([oferta()])).toMatchObject({ precio_final: 58500, oferta_id: 'o1' });
  });

  it('sin moneda pedida ni principal, el % redondea a 2 decimales (no supone guaraníes)', async () => {
    const { service, prisma } = crear([oferta({ valor: 10 })]);
    prisma.empresa_monedas.findFirst.mockResolvedValue(null);
    const r = await service.evaluarOfertas({ items: [{ producto_id: 'p1', cantidad: 1, precio_unitario: 12.5 }] } as any, 'e1');
    expect(r.items[0]).toMatchObject({ descuento: 1.25, precio_final: 11.25 });
  });

  it('un monto con su moneda sigue valiendo en esa moneda', async () => {
    expect(await evaluarSinPrincipal([oferta({ tipo: 'descuento_monto', valor: 5000, moneda: 'PYG' })], { moneda: 'PYG' })).toMatchObject({ precio_final: 60000 });
  });
});
