import { StockService } from './stock.service';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';

jest.mock('src/utils/alcance-sucursal', () => ({ alcanceSucursalUsuario: jest.fn().mockResolvedValue(null), filtroSucursalDeposito: jest.fn() }));

const FILA = { id: 'sd', deposito_id: 'dep-a', stock_minimo: 2, stock_maximo: 5, ubicacion: 'B-2', producto: { descripcion: 'PROD' } };

function crear(opts: { encontrada?: boolean; fila?: object } = {}) {
  const tx: any = {
    $queryRaw: jest.fn().mockResolvedValue(opts.encontrada === false ? [] : [{ id: 'sd' }]),
    stock_deposito: {
      findUnique: jest.fn().mockResolvedValue(opts.fila ?? FILA),
      update: jest.fn().mockImplementation(async ({ data }) => ({ id: 'sd', ...data })),
    },
  };
  const prisma: any = { $transaction: jest.fn(async (cb: any) => cb(tx)) };
  const audit: any = { log: jest.fn() };
  return { service: new StockService(prisma, audit, {} as any, {} as any), tx, audit };
}

describe('StockService.updateLimites', () => {
  beforeEach(() => (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null));

  it('otra empresa: 404 con código y no se escribe', async () => {
    const { service, tx } = crear({ encontrada: false });
    await expect(service.updateLimites('sd', { stock_minimo: 1 }, 'usr', 'otra')).rejects.toMatchObject({ response: { codigo: 'STOCK_NO_ENCONTRADO' }, status: 404 });
    expect(tx.stock_deposito.update).not.toHaveBeenCalled();
  });

  it('el mínimo no puede superar al máximo existente', async () => {
    const { service } = crear();
    await expect(service.updateLimites('sd', { stock_minimo: 10 }, 'usr', 'emp')).rejects.toMatchObject({ response: { codigo: 'LIMITES_INVALIDOS', campo: 'stock_minimo' } });
  });

  it('el máximo no puede quedar bajo el mínimo existente', async () => {
    const { service } = crear({ fila: { ...FILA, stock_minimo: 5, stock_maximo: null } });
    await expect(service.updateLimites('sd', { stock_maximo: 3 }, 'usr', 'emp')).rejects.toMatchObject({ response: { campo: 'stock_maximo' } });
  });

  it('máximo 0 significa sin máximo: no se valida contra el mínimo', async () => {
    const { service, tx } = crear();
    await service.updateLimites('sd', { stock_maximo: 0, stock_minimo: 9 }, 'usr', 'emp');
    expect(tx.stock_deposito.update).toHaveBeenCalled();
  });

  it('ubicación en blanco guarda null y no toca mínimo ni máximo', async () => {
    const { service, tx } = crear();
    await service.updateLimites('sd', { ubicacion: '  ' }, 'usr', 'emp');
    const data = tx.stock_deposito.update.mock.calls[0][0].data;
    expect(data.ubicacion).toBeNull();
    expect(data).not.toHaveProperty('stock_minimo');
    expect(data).not.toHaveProperty('stock_maximo');
  });

  it('la auditoría trae solo lo que cambió, sin undefined', async () => {
    const { service, audit } = crear();
    await service.updateLimites('sd', { stock_minimo: 4, ubicacion: 'B-2' }, 'usr', 'emp');
    const entrada = audit.log.mock.calls[0][0];
    expect(entrada.old_value).toEqual({ stock_minimo: 2 });
    expect(entrada.new_value).toEqual({ stock_minimo: 4 });
    expect(entrada.descripcion).not.toContain('undefined');
  });

  it('responde la fila sola, sin producto ni depósito', async () => {
    const { service } = crear();
    const r: any = await service.updateLimites('sd', { stock_minimo: 1 }, 'usr', 'emp');
    expect(r.message).toBe('Límites actualizados');
    expect(r.data).not.toHaveProperty('producto');
    expect(r.data).not.toHaveProperty('deposito');
  });

  it('depósito fuera de alcance: 403 y no se escribe', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue({ sucursalIds: [], puntosEstablecimiento: [], depositoIds: ['dep-z'] });
    const { service, tx } = crear();
    await expect(service.updateLimites('sd', { stock_minimo: 1 }, 'usr', 'emp')).rejects.toMatchObject({ response: { codigo: 'DEPOSITO_FUERA_DE_ALCANCE' }, status: 403 });
    expect(tx.stock_deposito.update).not.toHaveBeenCalled();
  });
  it('E1 T1 M1: si no llega ni mínimo ni máximo, no valida la fila que ya estaba mal y guarda la ubicación', async () => {
    const { service, tx } = crear({ fila: { ...FILA, stock_minimo: 9, stock_maximo: 3 } });
    await service.updateLimites('sd', { ubicacion: 'C-1' }, 'usr', 'emp');
    expect(tx.stock_deposito.update.mock.calls[0][0].data.ubicacion).toBe('C-1');
  });

  it('E1 T1 M2: el alcance se lee antes de abrir la transacción (no retiene otra conexión adentro)', async () => {
    const { service } = crear();
    await service.updateLimites('sd', { stock_minimo: 1 }, 'usr', 'emp');
    const prisma: any = (service as any).prisma;
    expect((alcanceSucursalUsuario as jest.Mock).mock.invocationCallOrder.at(-1)).toBeLessThan(prisma.$transaction.mock.invocationCallOrder[0]);
  });
});
