import { crearServicio, EMPRESA, filaOferta } from './ofertas-test-utils';

describe('Ofertas: listado, estado y resumen', () => {
  const condiciones = (prisma: any) => prisma.ofertas.findMany.mock.calls[0][0].where.AND;

  it('estado vencida filtra con whereEstadoOferta', async () => {
    const { service, prisma } = crearServicio();
    await service.findAll(EMPRESA, { estado: 'vencida' });
    expect(condiciones(prisma)).toEqual([{ empresa_id: EMPRESA }, { active: true, fecha_fin: { lt: expect.any(Date) } }]);
  });

  it('q se combina con estado (inactiva, que también es un OR)', async () => {
    const { service, prisma } = crearServicio();
    await service.findAll(EMPRESA, { estado: 'inactiva', q: 'promo' });
    const c = condiciones(prisma);
    expect(c).toContainEqual({ OR: [{ active: false }, { active: null }] });
    expect(c).toContainEqual({ OR: [{ nombre: { contains: 'promo', mode: 'insensitive' } }, { descripcion: { contains: 'promo', mode: 'insensitive' } }] });
    expect(prisma.ofertas.count.mock.calls[0][0].where.AND).toEqual(c);
  });

  it('estado desconocido no filtra; tipo sí', async () => {
    const { service, prisma } = crearServicio();
    await service.findAll(EMPRESA, { estado: 'x', tipo: 'precio_especial' });
    expect(condiciones(prisma)).toEqual([{ empresa_id: EMPRESA }, { tipo: 'precio_especial' }]);
  });

  it('cada fila: valor number, fecha_inicio ISO terminada en Z, estado_vigencia', async () => {
    const { service, prisma } = crearServicio();
    prisma.ofertas.findMany.mockResolvedValue([filaOferta({ valor: { toString: () => '10' } as any, active: false })]);
    const r = await service.findAll(EMPRESA, {});
    expect(r.items[0]).toMatchObject({ valor: 10, fecha_inicio: '2026-11-01T11:00:00.000Z', fecha_fin: '2026-12-01T11:00:00.000Z', estado_vigencia: 'inactiva', moneda: null });
    expect(r.items[0].fecha_inicio).toMatch(/Z$/);
  });

  it('conNombres busca los nombres solo dentro de la empresa', async () => {
    const { service, prisma } = crearServicio();
    prisma.ofertas.findMany.mockResolvedValue([
      filaOferta({ oferta_aplicacion: [{ id: 'a', aplica_a: 'producto', referencia_id: 'p1', excluir: false }] }),
      filaOferta({ oferta_aplicacion: [{ id: 'b', aplica_a: 'marca', referencia_id: 'm1', excluir: false }] }),
    ]);
    await service.findAll(EMPRESA, {});
    expect(prisma.productos.findMany.mock.calls[0][0].where).toEqual({ id: { in: ['p1'] }, empresa_id: EMPRESA });
    expect(prisma.marcas.findMany.mock.calls[0][0].where).toEqual({ id: { in: ['m1'] }, empresa_id: EMPRESA });
  });

  it('referencia_nombre: una consulta por tipo para 3 ofertas de producto y 2 de marca', async () => {
    const { service, prisma } = crearServicio();
    const ap = (aplica_a: string, referencia_id: string) => ({ oferta_aplicacion: [{ id: referencia_id, aplica_a, referencia_id, excluir: false }] });
    prisma.ofertas.findMany.mockResolvedValue([filaOferta(ap('producto', 'p1')), filaOferta(ap('producto', 'p2')), filaOferta(ap('producto', 'p3')), filaOferta(ap('marca', 'm1')), filaOferta(ap('marca', 'm2'))]);
    prisma.productos.findMany.mockResolvedValue([{ id: 'p1', descripcion: 'Uno' }, { id: 'p2', descripcion: 'Dos' }, { id: 'p3', descripcion: 'Tres' }]);
    prisma.marcas.findMany.mockResolvedValue([{ id: 'm1', descripcion: 'Marca A' }, { id: 'm2', descripcion: 'Marca B' }]);
    const r = await service.findAll(EMPRESA, {});
    expect(prisma.productos.findMany).toHaveBeenCalledTimes(1);
    expect(prisma.marcas.findMany).toHaveBeenCalledTimes(1);
    expect(prisma.categorias.findMany).not.toHaveBeenCalled();
    expect(r.items.map((i: any) => i.oferta_aplicacion[0].referencia_nombre)).toEqual(['Uno', 'Dos', 'Tres', 'Marca A', 'Marca B']);
  });

  it('producto borrado → referencia_nombre null', async () => {
    const { service, prisma } = crearServicio();
    prisma.ofertas.findMany.mockResolvedValue([filaOferta({ oferta_aplicacion: [{ id: 'a', aplica_a: 'producto', referencia_id: 'p9', excluir: false }] })]);
    const r = await service.findAll(EMPRESA, {});
    expect(r.items[0].oferta_aplicacion[0].referencia_nombre).toBeNull();
  });

  it('todos → null sin consultar', async () => {
    const { service, prisma } = crearServicio();
    prisma.ofertas.findMany.mockResolvedValue([filaOferta()]);
    const r = await service.findAll(EMPRESA, {});
    expect(r.items[0].oferta_aplicacion[0].referencia_nombre).toBeNull();
    expect(prisma.productos.findMany).not.toHaveBeenCalled();
  });

  it('resumen: una consulta por estado', async () => {
    const { service, prisma } = crearServicio();
    prisma.ofertas.count.mockImplementation(async ({ where }: any) => (Object.keys(where.AND[1]).length === 0 ? 11 : where.AND[1].OR ? 11 : 0));
    expect(await service.resumen(EMPRESA)).toEqual({ total: 11, activas: 0, programadas: 0, vencidas: 0, inactivas: 11 });
    expect(prisma.ofertas.count).toHaveBeenCalledTimes(5);
  });

  it('orden termina en id', async () => {
    const { service, prisma } = crearServicio();
    await service.findAll(EMPRESA, {});
    expect(prisma.ofertas.findMany.mock.calls[0][0].orderBy.at(-1)).toEqual({ id: 'asc' });
  });
});
