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

/**
 * E2E 2026-10-25: sin conexión el retail vendía al precio de catálogo (10.000)
 * aunque rigiera una lista general (10.778 online). El catálogo offline ahora
 * trae el precio final por perfil de listas, calculado con el mismo batch que
 * usa el POS online.
 */
describe('SyncService.getPreciosOffline', () => {
  const crear = (listasPorCliente: Map<string, string[]>) => {
    const batch = jest.fn(async ({ clienteId }: any) => ({
      'prod-a': {
        precioFinal: clienteId ? 9000 : 10778,
        precioBase: 10000,
        topeDescuentoPct: 40,
        listaAplicada: { id: clienteId ? 'lista-cli' : 'lista-gral' },
        moneda: 'PYG',
        precioCosto: 6000,
      },
    }));
    const lp: any = {
      monedaPrincipal: jest.fn().mockResolvedValue('PYG'),
      listasPropiasPorCliente: jest.fn().mockResolvedValue(listasPorCliente),
      obtenerPreciosProductosBatch: batch,
    };
    const prisma: any = { productos: { findMany: jest.fn().mockResolvedValue([{ id: 'prod-a' }]) } };
    return { service: new SyncService(prisma, {} as any, {} as any, lp), batch, lp };
  };

  it('perfil general = mismo cálculo que online sin cliente, en la moneda principal', async () => {
    const { service, batch, lp } = crear(new Map());
    const r = await service.getPreciosOffline('emp-1');
    expect(lp.listasPropiasPorCliente).toHaveBeenCalledWith('emp-1', 'PYG');
    expect(batch).toHaveBeenCalledWith({ productoIds: ['prod-a'], empresaId: 'emp-1', moneda: 'PYG' });
    expect(r.perfiles.general['prod-a']).toEqual({
      precioFinal: 10778,
      precioBase: 10000,
      topeDescuentoPct: 40,
      lista_id: 'lista-gral',
    });
    expect(r.listas['lista-gral']).toEqual({ id: 'lista-gral' });
    expect(r.moneda).toBe('PYG');
    expect(r.clientes).toEqual({});
  });

  it('un lote por combinación de listas propias, no por cliente', async () => {
    const { service, batch } = crear(
      new Map([
        ['cli-1', ['lista-x']],
        ['cli-2', ['lista-x']],
        ['cli-3', ['lista-x', 'lista-y']],
      ]),
    );
    const r = await service.getPreciosOffline('emp-1');
    expect(batch).toHaveBeenCalledTimes(3); // general + 2 perfiles
    expect(r.clientes).toEqual({ 'cli-1': 'lista-x', 'cli-2': 'lista-x', 'cli-3': 'lista-x,lista-y' });
    expect(r.perfiles['lista-x']['prod-a'].precioFinal).toBe(9000);
    expect(batch.mock.calls[1][0]).toMatchObject({ clienteId: 'cli-1', moneda: 'PYG' });
  });
});

describe('ListaPreciosService.listasPropiasPorCliente', () => {
  it('junta lista del cliente, asignaciones y zona; descarta listas no vigentes', async () => {
    const prisma: any = {
      lista_precios: { findMany: jest.fn().mockResolvedValue([{ id: 'l-cli' }, { id: 'l-asig' }, { id: 'l-zona' }]) },
      clientes: {
        findMany: jest.fn().mockResolvedValue([
          { id: 'c1', lista_precios_id: 'l-cli', zona_id: 'z1' },
          { id: 'c2', lista_precios_id: 'l-vencida', zona_id: null },
        ]),
      },
      lista_precios_asignaciones: {
        findMany: jest.fn(({ where }: any) =>
          Promise.resolve(
            where.tipo_entidad === 'cliente'
              ? [{ entidad_id: 'c3', lista_precios_id: 'l-asig' }]
              : [{ zona_id: 'z1', lista_precios_id: 'l-zona' }],
          ),
        ),
      },
    };
    const service = new ListaPreciosService(prisma, {} as any, {} as any);
    const r = await service.listasPropiasPorCliente('emp-1', 'PYG');
    expect(Object.fromEntries(r)).toEqual({ c1: ['l-cli', 'l-zona'], c3: ['l-asig'] });
    expect(prisma.lista_precios.findMany.mock.calls[0][0].where).toMatchObject({ empresa_id: 'emp-1', activa: true, moneda: 'PYG' });
  });
});
