import { BadRequestException } from '@nestjs/common';
import { MOTIVO_TRASLADO_ENTRE_LOCALES, NotaRemisionService } from './nota-remision.service';

/**
 * Stock de la remisión sin factura:
 * - LT7: con lotes sale por FEFO sin vencidos, un movimiento por lote + uno sin lote (SALIDA_REMISION).
 * - S3: motivo 7 «Traslado entre locales» exige depósito destino válido y transfiere origen → destino.
 */
describe('NotaRemisionService — stock de la remisión', () => {
  const crear = ({
    usaLotes = false,
    stock = 10,
    politica = 'advertencia',
    deposito = { id: 'dep-origen', descripcion: 'Central' } as any,
    destinos = { 'dep-destino': { id: 'dep-destino', active: true, descripcion: 'Sucursal 2' } } as Record<string, any>,
    motivoCodigo = MOTIVO_TRASLADO_ENTRE_LOCALES,
  } = {}) => {
    const tx: any = {
      depositos: { findFirst: jest.fn().mockResolvedValue(deposito) },
      empresas_sucursales: { findUnique: jest.fn().mockResolvedValue({ config: { politica_stock: politica } }) },
      tipo_movimiento_inventario: {
        findUnique: jest.fn(({ where }) => Promise.resolve({ id: `tipo-${where.codigo}` })),
        upsert: jest.fn(),
      },
      productos: {
        findUnique: jest.fn().mockResolvedValue({ maneja_inventario: true, precio_costo: 50, descripcion: 'Yerba' }),
      },
      stock_deposito: {
        findUnique: jest.fn().mockResolvedValue({ cantidad_disponible: stock, cantidad_reservada: 0 }),
        upsert: jest.fn().mockResolvedValue({}),
      },
      movimientos_inventario: { create: jest.fn().mockResolvedValue({}) },
    };
    const prisma: any = {
      motivo_emision_remision: { findUnique: jest.fn().mockResolvedValue({ codigo: motivoCodigo }) },
      depositos: { findFirst: jest.fn(({ where }) => Promise.resolve(destinos[where.id] ?? null)) },
    };
    const lotes: any = {
      bloquearStockDe: jest.fn().mockResolvedValue(undefined),
      usaLotesEnDeposito: jest.fn().mockResolvedValue(usaLotes),
      transferirFefo: jest.fn().mockResolvedValue({
        lotes: [
          { lote_id: 'lote-a', numero_lote: 'A', cantidad: 3 },
          { lote_id: 'lote-b', numero_lote: 'B', cantidad: 1 },
        ],
        sin_lote: 1,
      }),
    };
    const fifo: any = {
      deductFifo: jest.fn().mockResolvedValue({
        lotes_consumidos: [
          { lote_id: 'lote-a', cantidad: 3, costo_unitario: 40 },
          { lote_id: 'lote-b', cantidad: 1, costo_unitario: 45 },
        ],
        cantidad_sin_lote: 1,
      }),
    };
    const service = new NotaRemisionService(prisma, {} as any, {} as any, {} as any, {} as any, {} as any, lotes, fifo);
    return { service: service as any, tx, prisma, lotes, fifo };
  };

  const params = (extra: Record<string, unknown> = {}) => ({
    remisionId: 'rem-1',
    items: [{ producto_id: 'prod-1', cantidad: 5 }],
    empresaId: 'emp-1',
    sucursalId: 'suc-1',
    depositoIdPreferido: 'dep-origen',
    depositoDestinoId: null,
    numeroRemision: '001-001-0000007',
    ...extra,
  });

  const movimientos = (tx: any) => tx.movimientos_inventario.create.mock.calls.map(([a]: any[]) => a.data);

  it('sin lotes: un movimiento SALIDA_REMISION sin lote y descuenta el depósito', async () => {
    const { service, tx, fifo } = crear();
    await service.descontarStockRemision(tx, params());

    expect(fifo.deductFifo).not.toHaveBeenCalled();
    const movs = movimientos(tx);
    expect(movs).toHaveLength(1);
    expect(movs[0]).toMatchObject({ tipo_movimiento_id: 'tipo-SALIDA_REMISION', cantidad: 5, lote_id: null, documento_origen: 'nota_remision' });
    expect(tx.stock_deposito.upsert).toHaveBeenCalledWith(
      expect.objectContaining({ update: expect.objectContaining({ cantidad_disponible: { decrement: 5 } }) }),
    );
  });

  it('LT7: con lotes consume FEFO sin vencidos, un movimiento por lote y otro por lo sin lote', async () => {
    const { service, tx, fifo } = crear({ usaLotes: true });
    await service.descontarStockRemision(tx, params());

    expect(fifo.deductFifo).toHaveBeenCalledWith(tx, 'emp-1', 'prod-1', 'dep-origen', 5, { vencidos: 'excluir' });
    const movs = movimientos(tx);
    expect(movs.map((m: any) => [m.lote_id, m.cantidad, m.precio_unitario])).toEqual([
      ['lote-a', 3, 40],
      ['lote-b', 1, 45],
      [null, 1, 50],
    ]);
    expect(movs.every((m: any) => m.tipo_movimiento_id === 'tipo-SALIDA_REMISION')).toBe(true);
  });

  it('I1: bloquea lotes y stock de todos los renglones antes de leer o escribir, con origen y destino', async () => {
    const { service, tx, lotes, fifo } = crear({ usaLotes: true });
    await service.descontarStockRemision(
      tx,
      params({ depositoDestinoId: 'dep-destino', items: [{ producto_id: 'p2', cantidad: 1 }, { producto_id: 'p1', cantidad: 2 }, { producto_id: 'p3', cantidad: 0 }] }),
    );
    expect(lotes.bloquearStockDe).toHaveBeenCalledTimes(1);
    expect(lotes.bloquearStockDe).toHaveBeenCalledWith(tx, 'emp-1', [
      { productoId: 'p2', depositoId: 'dep-origen' },
      { productoId: 'p1', depositoId: 'dep-origen' },
      { productoId: 'p2', depositoId: 'dep-destino' },
      { productoId: 'p1', depositoId: 'dep-destino' },
    ]);
    const bloqueo = lotes.bloquearStockDe.mock.invocationCallOrder[0];
    expect(bloqueo).toBeLessThan(tx.stock_deposito.findUnique.mock.invocationCallOrder[0]);
    expect(bloqueo).toBeLessThan(lotes.transferirFefo.mock.invocationCallOrder[0]);
    expect(bloqueo).toBeLessThan(tx.stock_deposito.upsert.mock.invocationCallOrder[0]);
    expect(fifo.deductFifo).not.toHaveBeenCalled();
  });

  it('I1: en una salida con lotes el bloqueo va antes del FEFO', async () => {
    const { service, tx, lotes, fifo } = crear({ usaLotes: true });
    await service.descontarStockRemision(tx, params());
    expect(lotes.bloquearStockDe).toHaveBeenCalledWith(tx, 'emp-1', [{ productoId: 'prod-1', depositoId: 'dep-origen' }]);
    expect(lotes.bloquearStockDe.mock.invocationCallOrder[0]).toBeLessThan(fifo.deductFifo.mock.invocationCallOrder[0]);
  });

  it('política estricta: sin disponible no deja emitir', async () => {
    const { service, tx } = crear({ politica: 'estricto', stock: 2 });
    await expect(service.descontarStockRemision(tx, params())).rejects.toThrow(/Stock insuficiente/);
    expect(tx.movimientos_inventario.create).not.toHaveBeenCalled();
  });

  it('S3: traslado con lotes transfiere FEFO al destino (TRANSFERENCIA) y suma en el destino', async () => {
    const { service, tx, lotes, fifo } = crear({ usaLotes: true });
    await service.descontarStockRemision(tx, params({ depositoDestinoId: 'dep-destino' }));

    expect(fifo.deductFifo).not.toHaveBeenCalled();
    expect(lotes.transferirFefo).toHaveBeenCalledWith(tx, {
      empresaId: 'emp-1',
      productoId: 'prod-1',
      origenId: 'dep-origen',
      destinoId: 'dep-destino',
      cantidad: 5,
    });
    const movs = movimientos(tx);
    expect(movs.map((m: any) => [m.lote_id, m.cantidad])).toEqual([
      ['lote-a', 3],
      ['lote-b', 1],
      [null, 1],
    ]);
    expect(movs.every((m: any) => m.tipo_movimiento_id === 'tipo-TRANSFERENCIA' && m.deposito_destino_id === 'dep-destino')).toBe(true);
    const destino = tx.stock_deposito.upsert.mock.calls.find(
      ([a]: any[]) => a.where.deposito_id_producto_id.deposito_id === 'dep-destino',
    );
    expect(destino[0].update.cantidad_disponible).toEqual({ increment: 5 });
  });

  it.each([
    ['dep-destino', ['dep-destino', 'dep-origen']],
    ['dep-z', ['dep-origen', 'dep-z']],
  ])('el traslado a %s escribe stock_deposito en orden de id, y después de los lotes', async (destino, orden) => {
    const { service, tx, lotes } = crear({ usaLotes: true, destinos: { [destino]: { id: destino, active: true, descripcion: 'Otro' } } });
    await service.descontarStockRemision(tx, params({ depositoDestinoId: destino }));
    const escrituras = tx.stock_deposito.upsert.mock.calls.map(([a]: any[]) => [a.where.deposito_id_producto_id.deposito_id, a.update.cantidad_disponible, a.create.cantidad_disponible]);
    expect(escrituras.map((e: any[]) => e[0])).toEqual(orden);
    expect(escrituras).toEqual(expect.arrayContaining([['dep-origen', { decrement: 5 }, -5], [destino, { increment: 5 }, 5]]));
    expect(lotes.transferirFefo.mock.invocationCallOrder[0]).toBeLessThan(tx.stock_deposito.upsert.mock.invocationCallOrder[0]);
  });

  describe('I1: el mismo producto en dos renglones', () => {
    const dosRenglones = (extra: Record<string, unknown> = {}) =>
      params({
        items: [
          { producto_id: 'prod-1', cantidad: 5 },
          { producto_id: 'prod-1', cantidad: 2 },
        ],
        ...extra,
      });
    const ultima = (fn: jest.Mock) => Math.max(...fn.mock.invocationCallOrder);

    it('salida: los lotes de todos los renglones antes del primer stock_deposito; stock y movimientos no cambian', async () => {
      const { service, tx, fifo } = crear({ usaLotes: true });
      await service.descontarStockRemision(tx, dosRenglones());
      expect(fifo.deductFifo).toHaveBeenCalledTimes(2);
      expect(fifo.deductFifo.mock.calls.map((c: any[]) => c[4])).toEqual([5, 2]);
      expect(ultima(fifo.deductFifo)).toBeLessThan(tx.stock_deposito.upsert.mock.invocationCallOrder[0]);
      expect(tx.stock_deposito.upsert.mock.calls.map(([a]: any[]) => a.update.cantidad_disponible)).toEqual([{ decrement: 5 }, { decrement: 2 }]);
      expect(movimientos(tx).map((m: any) => [m.lote_id, m.cantidad, m.precio_unitario])).toEqual([
        ['lote-a', 3, 40],
        ['lote-b', 1, 45],
        [null, 1, 50],
        ['lote-a', 3, 40],
        ['lote-b', 1, 45],
        [null, 1, 50],
      ]);
    });

    it('traslado: los lotes de todos los renglones antes del primer stock_deposito', async () => {
      const { service, tx, lotes } = crear({ usaLotes: true });
      await service.descontarStockRemision(tx, dosRenglones({ depositoDestinoId: 'dep-destino' }));
      expect(lotes.transferirFefo).toHaveBeenCalledTimes(2);
      expect(ultima(lotes.transferirFefo)).toBeLessThan(tx.stock_deposito.upsert.mock.invocationCallOrder[0]);
      expect(tx.stock_deposito.upsert).toHaveBeenCalledTimes(4);
    });

    it('política estricta: el segundo renglón ve lo que ya pidió el primero, con el mismo mensaje', async () => {
      const { service, tx } = crear({ politica: 'estricto', stock: 6 });
      await expect(service.descontarStockRemision(tx, dosRenglones())).rejects.toThrow('Stock insuficiente para "Yerba". Disponible: 1, requerido: 2');
      expect(tx.stock_deposito.upsert).not.toHaveBeenCalled();
    });

    it('política estricta: lo justo alcanza, también con decimales', async () => {
      const { service, tx } = crear({ politica: 'estricto', stock: 0.3 });
      await service.descontarStockRemision(tx, params({ items: [{ producto_id: 'prod-1', cantidad: 0.1 }, { producto_id: 'prod-1', cantidad: 0.2 }] }));
      expect(tx.stock_deposito.upsert).toHaveBeenCalledTimes(2);
    });

    it('política estricta: productos distintos no se suman entre sí', async () => {
      const { service, tx } = crear({ politica: 'estricto', stock: 5 });
      await service.descontarStockRemision(tx, params({ items: [{ producto_id: 'prod-1', cantidad: 5 }, { producto_id: 'prod-2', cantidad: 5 }] }));
      expect(tx.stock_deposito.upsert).toHaveBeenCalledTimes(2);
    });
  });

  it('S3: el destino no puede ser el mismo depósito de origen', async () => {
    const { service, tx } = crear();
    await expect(service.descontarStockRemision(tx, params({ depositoDestinoId: 'dep-origen' }))).rejects.toThrow(
      BadRequestException,
    );
  });

  describe('depositoDestinoTraslado (validación al crear)', () => {
    it('motivo traslado sin destino: pide elegir el depósito destino', async () => {
      const { service } = crear();
      const errores: string[] = [];
      const id = await service.depositoDestinoTraslado({ motivo_emision_id: 'm7' }, 'emp-1', errores);
      expect(id).toBeNull();
      expect(errores[0]).toMatch(/elegí el depósito destino/);
    });

    it('destino de otra empresa o inactivo: error claro', async () => {
      const { service } = crear({ destinos: { 'dep-x': { id: 'dep-x', active: false, descripcion: 'Viejo' } } });
      const errores: string[] = [];
      await service.depositoDestinoTraslado({ motivo_emision_id: 'm7', deposito_destino_id: 'dep-otra' }, 'emp-1', errores);
      await service.depositoDestinoTraslado({ motivo_emision_id: 'm7', deposito_destino_id: 'dep-x' }, 'emp-1', errores);
      expect(errores[0]).toMatch(/no existe en esta empresa/);
      expect(errores[1]).toMatch(/«Viejo» está inactivo/);
    });

    it('destino válido: devuelve su id', async () => {
      const { service } = crear();
      const errores: string[] = [];
      const id = await service.depositoDestinoTraslado({ motivo_emision_id: 'm7', deposito_destino_id: 'dep-destino' }, 'emp-1', errores);
      expect(id).toBe('dep-destino');
      expect(errores).toEqual([]);
    });

    it('otro motivo: ignora el destino (la remisión descuenta como siempre)', async () => {
      const { service } = crear({ motivoCodigo: 1 });
      const errores: string[] = [];
      const id = await service.depositoDestinoTraslado({ motivo_emision_id: 'm1', deposito_destino_id: 'dep-destino' }, 'emp-1', errores);
      expect(id).toBeNull();
      expect(errores).toEqual([]);
    });
  });
});
