import { ComprasService } from './compras.service';

/**
 * S7: al anular o editar una compra, el costo del producto vuelve al de la última
 * compra activa; si no queda ninguna, al costo que tenía antes de las compras
 * deshechas. Nunca queda en null.
 */
describe('ComprasService - costo del producto al deshacer compras (S7)', () => {
  type Linea = { costo_unitario_neto: number | null; costo_anterior: number | null };

  const crear = (opts: { ultimaActiva: number | null; lineas?: Linea[] }) => {
    const tx: any = {
      $queryRaw: jest.fn(async (strings: TemplateStringsArray) => {
        const sql = strings.join('?');
        if (sql.includes('cd.costo_anterior')) return opts.lineas ?? [];
        return opts.ultimaActiva == null ? [] : [{ costo_unitario_neto: opts.ultimaActiva }];
      }),
      productos: { update: jest.fn().mockResolvedValue(undefined) },
    };
    const service = new ComprasService({} as any, {} as any, {} as any, {} as any, {} as any, {} as any, { logEnTransaccion: jest.fn() } as any);
    const recalcular = (ids: string[], previos?: Map<string, number | null>) =>
      (service as any).recalculateProductCosts(tx, 'emp-1', ids, previos);
    return { tx, recalcular };
  };

  it('usa el costo de la última compra activa si queda alguna', async () => {
    const { tx, recalcular } = crear({ ultimaActiva: 120 });
    await recalcular(['p1']);
    expect(tx.productos.update).toHaveBeenCalledWith({
      where: { id: 'p1' },
      data: expect.objectContaining({ precio_costo: 120 }),
    });
  });

  it('sin compras activas vuelve al costo previo guardado en la línea anulada', async () => {
    const { tx, recalcular } = crear({
      ultimaActiva: null,
      lineas: [{ costo_unitario_neto: 150, costo_anterior: 80 }],
    });
    await recalcular(['p1']);
    expect(tx.productos.update).toHaveBeenCalledWith({
      where: { id: 'p1' },
      data: expect.objectContaining({ precio_costo: 80 }),
    });
  });

  it('anular dos compras seguidas vuelve al costo de antes de la primera', async () => {
    // Compra A: costo 80 (manual) → 100. Compra B: 100 → 120. Ambas anuladas.
    const { tx, recalcular } = crear({
      ultimaActiva: null,
      lineas: [
        { costo_unitario_neto: 120, costo_anterior: 100 },
        { costo_unitario_neto: 100, costo_anterior: 80 },
      ],
    });
    await recalcular(['p1']);
    expect(tx.productos.update).toHaveBeenCalledWith({
      where: { id: 'p1' },
      data: expect.objectContaining({ precio_costo: 80 }),
    });
  });

  it('no retrocede más allá de un costo cargado a mano entre compras', async () => {
    // X (60, antes 50) anulada hace tiempo; después alguien cargó 90 a mano;
    // compra C (130, antes 90) anulada ahora → vuelve a 90, no a 50.
    const { tx, recalcular } = crear({
      ultimaActiva: null,
      lineas: [
        { costo_unitario_neto: 130, costo_anterior: 90 },
        { costo_unitario_neto: 60, costo_anterior: 50 },
      ],
    });
    await recalcular(['p1']);
    expect(tx.productos.update).toHaveBeenCalledWith({
      where: { id: 'p1' },
      data: expect.objectContaining({ precio_costo: 90 }),
    });
  });

  it('en una edición que saca el producto usa el costo previo de la versión vieja', async () => {
    const { tx, recalcular } = crear({ ultimaActiva: null, lineas: [] });
    await recalcular(['p1'], new Map([['p1', 75]]));
    expect(tx.productos.update).toHaveBeenCalledWith({
      where: { id: 'p1' },
      data: expect.objectContaining({ precio_costo: 75 }),
    });
  });

  it('nunca deja el costo en null: si no hay a qué volver, no lo toca', async () => {
    const { tx, recalcular } = crear({
      ultimaActiva: null,
      lineas: [{ costo_unitario_neto: 150, costo_anterior: null }],
    });
    await recalcular(['p1']);
    expect(tx.productos.update).not.toHaveBeenCalled();
  });
});
