import { FifoService } from './fifo.service';

/**
 * LT1: FEFO (vence antes, sale antes; sin vencimiento al final).
 * LT2: los vencidos no se venden sin autorización; el stock sin lote va antes
 * que los vencidos; lo que falta se vende sin lote como antes.
 */
describe('FifoService - salida FEFO y vencidos', () => {
  const HOY = new Date('2026-10-25T00:00:00.000Z');
  const d = (s: string | null) => (s ? new Date(`${s}T00:00:00.000Z`) : null);

  type Lote = { id: string; venc: string | null; fab?: string | null; cant: number; costo: number };

  /** Simula stock_lote aplicando el where (vencimiento) y el orden FEFO como lo haría la base. */
  const crearTx = (lotes: Lote[]) => {
    const estado = new Map(lotes.map((l) => [l.id, { ...l }]));
    const cumple = (l: Lote, where: any) => {
      const lp = where?.lotes_producto ?? {};
      if (lp.fecha_vencimiento?.lt) return !!l.venc && d(l.venc)! < lp.fecha_vencimiento.lt;
      if (lp.OR) return !l.venc || d(l.venc)! >= lp.OR[1].fecha_vencimiento.gte;
      return true;
    };
    const ordenar = (a: Lote, b: Lote) => {
      const va = a.venc ? d(a.venc)!.getTime() : Infinity;
      const vb = b.venc ? d(b.venc)!.getTime() : Infinity;
      if (va !== vb) return va - vb;
      const fa = a.fab ? d(a.fab)!.getTime() : Infinity;
      const fb = b.fab ? d(b.fab)!.getTime() : Infinity;
      return fa - fb;
    };
    const filas = (where: any) =>
      [...estado.values()]
        .filter((l) => l.cant > 0 && cumple(l, where))
        .sort(ordenar)
        .map((l) => ({
          id: `sl-${l.id}`,
          lote_id: l.id,
          cantidad_disponible: l.cant,
          lotes_producto: {
            id: l.id,
            numero_lote: l.id.toUpperCase(),
            costo_unitario: l.costo,
            cantidad_disponible: l.cant,
            fecha_vencimiento: d(l.venc),
          },
        }));
    const tx: any = {
      stock_lote: {
        findMany: jest.fn(async ({ where }: any) => filas(where)),
        update: jest.fn(async ({ where, data }: any) => {
          estado.get(where.id.replace('sl-', ''))!.cant = data.cantidad_disponible;
        }),
      },
      lotes_producto: { update: jest.fn() },
    };
    return { tx, estado };
  };

  const svc = new FifoService();

  it('LT1: sale primero el que vence antes, aunque se haya fabricado después; sin vencimiento al final', async () => {
    const { tx } = crearTx([
      { id: 'sinvenc', venc: null, fab: '2025-01-01', cant: 5, costo: 10 },
      { id: 'tarde', venc: '2027-06-01', fab: '2025-01-01', cant: 5, costo: 10 },
      { id: 'pronto', venc: '2026-11-15', fab: '2026-05-01', cant: 5, costo: 10 },
    ]);
    const r = await svc.deductFifo(tx, 'emp', 'prod', 'dep', 12, { hoy: HOY });
    expect(r.lotes_consumidos.map((c) => [c.lote_id, c.cantidad])).toEqual([
      ['pronto', 5],
      ['tarde', 5],
      ['sinvenc', 2],
    ]);
  });

  it('LT2: la venta saltea los vencidos y usa el stock sin lote antes de pedir autorización', async () => {
    const { tx } = crearTx([
      { id: 'vencido', venc: '2026-09-30', cant: 5, costo: 10 },
      { id: 'vigente', venc: '2026-12-10', cant: 2, costo: 20 },
    ]);
    const r = await svc.consumirParaVenta(tx, {
      empresaId: 'emp', productoId: 'prod', depositoId: 'dep', cantidad: 4, sinLoteLibre: 2, permitirVencidos: false, hoy: HOY,
    });
    expect(r.lotes_consumidos.map((c) => c.lote_id)).toEqual(['vigente']);
    expect(r.sin_lote_usado).toBe(2);
    expect(r.vencidos_requeridos).toBeNull();
  });

  it('LT2: si solo queda vencido, lo informa y no lo consume', async () => {
    const { tx, estado } = crearTx([{ id: 'vencido', venc: '2026-09-30', cant: 5, costo: 10 }]);
    const r = await svc.consumirParaVenta(tx, {
      empresaId: 'emp', productoId: 'prod', depositoId: 'dep', cantidad: 3, sinLoteLibre: 0, permitirVencidos: false, hoy: HOY,
    });
    expect(r.vencidos_requeridos).toEqual({ cantidad: 3, lotes: ['VENCIDO'] });
    expect(r.lotes_consumidos).toHaveLength(0);
    expect(estado.get('vencido')!.cant).toBe(5);
  });

  it('LT2: con autorización consume el vencido', async () => {
    const { tx } = crearTx([{ id: 'vencido', venc: '2026-09-30', cant: 5, costo: 10 }]);
    const r = await svc.consumirParaVenta(tx, {
      empresaId: 'emp', productoId: 'prod', depositoId: 'dep', cantidad: 3, sinLoteLibre: 0, permitirVencidos: true, hoy: HOY,
    });
    expect(r.usa_vencidos).toBe(true);
    expect(r.cantidad_con_lote).toBe(3);
    expect(r.costo_total_lotes).toBe(30);
  });

  it('un lote que vence hoy todavía se vende', async () => {
    const { tx } = crearTx([{ id: 'hoy', venc: '2026-10-25', cant: 1, costo: 10 }]);
    const r = await svc.consumirParaVenta(tx, {
      empresaId: 'emp', productoId: 'prod', depositoId: 'dep', cantidad: 1, sinLoteLibre: 0, permitirVencidos: false, hoy: HOY,
    });
    expect(r.lotes_consumidos.map((c) => c.lote_id)).toEqual(['hoy']);
  });

  it('sin lotes ni vencidos, lo que falta se vende sin lote (no bloquea)', async () => {
    const { tx } = crearTx([]);
    const r = await svc.consumirParaVenta(tx, {
      empresaId: 'emp', productoId: 'prod', depositoId: 'dep', cantidad: 3, sinLoteLibre: 0, permitirVencidos: false, hoy: HOY,
    });
    expect(r.vencidos_requeridos).toBeNull();
    expect(r.cantidad_con_lote).toBe(0);
  });
});
