import { calcularAjustesCierre, InventarioFisicoService } from './inventario-fisico.service';

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


/**
 * Cerrar la sesión deja cada depósito contado igual al conteo: lo contado con
 * la cantidad contada (aunque se haya movido después) y lo no contado en cero.
 */
describe('calcularAjustesCierre', () => {
  const ajustes = calcularAjustesCierre(
    [
      { producto_id: 'baja', cantidad: 10 },
      { producto_id: 'igual', cantidad: 5 },
      { producto_id: 'no-contado', cantidad: 7 },
      { producto_id: 'no-contado-negativo', cantidad: -2 },
      { producto_id: 'ya-en-cero', cantidad: 0 },
    ],
    [
      { producto_id: 'baja', cantidad: 7 },
      { producto_id: 'igual', cantidad: 5 },
      { producto_id: 'sin-fila', cantidad: 3 },
    ],
  );
  const de = (id: string) => ajustes.find((a) => a.producto_id === id);

  it('lo contado queda con la cantidad contada', () => {
    expect(de('baja')).toMatchObject({ actual: 10, final: 7, contado: true, lote_id: null });
  });

  it('lo no contado con stock queda en cero, también un stock negativo', () => {
    expect(de('no-contado')).toMatchObject({ actual: 7, final: 0, contado: false });
    expect(de('no-contado-negativo')).toMatchObject({ actual: -2, final: 0, contado: false });
  });

  it('un contado sin fila de stock sube desde cero', () => {
    expect(de('sin-fila')).toMatchObject({ actual: 0, final: 3 });
  });

  it('lo que no cambia no genera ajuste', () => {
    expect(de('igual')).toBeUndefined();
    expect(de('ya-en-cero')).toBeUndefined();
    expect(ajustes).toHaveLength(4);
  });

  it('ajuste de zona con «mantener no contados»: lo no contado queda como está', () => {
    const zona = calcularAjustesCierre(
      [
        { producto_id: 'a', cantidad: 10 },
        { producto_id: 'b', cantidad: 4 },
      ],
      [{ producto_id: 'a', cantidad: 8 }],
      { mantenerNoContados: true },
    );
    expect(zona).toEqual([expect.objectContaining({ producto_id: 'a', actual: 10, final: 8 })]);
  });

  it('LT8: por lote, cada lote queda con lo contado y el lote no contado en cero', () => {
    const lotes = calcularAjustesCierre(
      [
        { producto_id: 'p', lote_id: 'L1', cantidad: 6 },
        { producto_id: 'p', lote_id: 'L2', cantidad: 4 },
        { producto_id: 'p', lote_id: null, cantidad: 2 },
      ],
      [
        { producto_id: 'p', lote_id: 'L1', cantidad: 6 },
        { producto_id: 'p', lote_id: null, cantidad: 5 },
      ],
    );
    expect(lotes).toHaveLength(2);
    expect(lotes).toEqual(
      expect.arrayContaining([
        expect.objectContaining({ lote_id: 'L2', actual: 4, final: 0, contado: false, producto_contado: true }),
        expect.objectContaining({ lote_id: null, actual: 2, final: 5, contado: true }),
      ]),
    );
  });
});

/**
 * S12: «Aplicar ajuste de zona» ya no pisa el stock: graba un movimiento de
 * ajuste por diferencia atado a la sesión, solo de productos que manejan
 * inventario, y con lotes ajusta cada lote (LT8).
 */
describe('InventarioFisicoService.cerrarZona', () => {
  const crear = (opciones: { lotes?: boolean } = {}) => {
    const conLotes = !!opciones.lotes;
    const queryRaw = jest.fn().mockImplementation((strings: TemplateStringsArray) => {
      const sql = strings.join('?');
      if (sql.includes('FROM inventario_sesiones')) return Promise.resolve([{ id: 'ses', nombre: 'Octubre', estado: 'abierto' }]);
      if (sql.includes('FOR UPDATE OF')) return Promise.resolve([]);
      if (sql.includes('FROM stock_lote')) {
        return Promise.resolve([
          { lote_id: 'L1', producto_id: 'p1', numero_lote: 'A-1', cantidad_disponible: 6 },
          { lote_id: 'L2', producto_id: 'p1', numero_lote: 'A-2', cantidad_disponible: 4 },
        ]);
      }
      if (sql.includes('FROM stock_deposito')) {
        return Promise.resolve([
          { producto_id: 'p1', cantidad_disponible: 10, cantidad_reservada: 0 },
          { producto_id: 'p2', cantidad_disponible: 3, cantidad_reservada: 0 },
        ]);
      }
      return Promise.resolve([]);
    });
    const tx: any = {
      $queryRaw: queryRaw,
      $executeRaw: jest.fn().mockResolvedValue(1),
      productos: {
        findMany: jest
          .fn()
          // productos de la zona
          .mockResolvedValueOnce([{ id: 'p1' }, { id: 'p2' }])
          // productos con lote
          .mockResolvedValue(conLotes ? [{ id: 'p1' }] : []),
      },
      inventario_conteos: {
        findMany: jest.fn().mockResolvedValue(
          conLotes
            ? [
                { producto_id: 'p1', lote_id: 'L1', cantidad_contada: 5, lote: { numero_lote: 'A-1' } },
                { producto_id: 'p1', lote_id: 'L2', cantidad_contada: 4, lote: { numero_lote: 'A-2' } },
              ]
            : [{ producto_id: 'p1', lote_id: null, cantidad_contada: 7, lote: null }],
        ),
      },
      stock_deposito: { createMany: jest.fn() },
      movimientos_inventario: { createMany: jest.fn() },
      inventario_zonas_aplicadas: { create: jest.fn() },
      tipo_movimiento_inventario: {
        findUnique: jest.fn().mockImplementation(({ where }) => Promise.resolve({ id: `tipo-${where.codigo}` })),
        upsert: jest.fn(),
      },
    };
    const prisma: any = {
      depositos: { findFirst: jest.fn().mockResolvedValue({ id: 'dep', descripcion: 'Central', sucursal_id: 'suc' }) },
      $transaction: jest.fn().mockImplementation((cb: (t: any) => unknown) => cb(tx)),
    };
    const lotes: any = {
      isEnabledForEmpresa: jest.fn().mockResolvedValue(conLotes),
      ingresarEnLote: jest.fn(),
      descontarDeLote: jest.fn(),
    };
    return { service: new InventarioFisicoService(prisma, lotes, { log: jest.fn() } as any), prisma, tx, lotes };
  };

  it('graba ajustes negativos atados a la sesión y solo pide productos con inventario', async () => {
    const { service, tx } = crear();
    const res = await service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep', categoria_ids: ['cat'], no_contados: 'poner_en_cero' }, null);

    expect(tx.productos.findMany.mock.calls[0][0].where).toMatchObject({
      empresa_id: 'emp',
      maneja_inventario: true,
      categoria_id: { in: ['cat'] },
    });
    const movimientos = tx.movimientos_inventario.createMany.mock.calls[0][0].data;
    expect(movimientos).toHaveLength(2);
    expect(movimientos).toEqual(
      expect.arrayContaining([
        expect.objectContaining({
          producto_id: 'p1',
          cantidad: 3,
          tipo_movimiento_id: 'tipo-AJUSTE_NEGATIVO',
          documento_origen: 'inventario_fisico',
          documento_id: 'ses',
          deposito_origen_id: 'dep',
          usuario_id: 'usr',
        }),
        // p2 no se contó: queda en cero.
        expect.objectContaining({ producto_id: 'p2', cantidad: 3, tipo_movimiento_id: 'tipo-AJUSTE_NEGATIVO' }),
      ]),
    );
    expect(tx.$executeRaw).toHaveBeenCalled();
    expect(res).toMatchObject({ total_productos: 2, contados: 1, movimientos: 2 });
  });

  it('con «mantener no contados» solo ajusta lo contado', async () => {
    const { service, tx } = crear();
    await service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep', no_contados: 'mantener' }, null);
    const movimientos = tx.movimientos_inventario.createMany.mock.calls[0][0].data;
    expect(movimientos).toEqual([expect.objectContaining({ producto_id: 'p1', cantidad: 3 })]);
  });

  it('lee el stock con FOR UPDATE', async () => {
    const { service, tx } = crear();
    await service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep', no_contados: 'poner_en_cero' }, null);
    const sqls = tx.$queryRaw.mock.calls.map((c: any[]) => (c[0] as string[]).join('?'));
    expect(sqls.some((s: string) => s.includes('FROM inventario_sesiones') && s.includes('FOR UPDATE'))).toBe(true);
    expect(sqls.some((s: string) => s.includes('FROM stock_deposito') && s.includes('FOR UPDATE OF sd'))).toBe(true);
  });

  it('LT8: con lotes, descuenta del lote contado de menos y graba el movimiento con lote_id', async () => {
    const { service, tx, lotes } = crear({ lotes: true });
    await service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep', no_contados: 'mantener' }, null);

    expect(lotes.descontarDeLote).toHaveBeenCalledWith(tx, { loteId: 'L1', depositoId: 'dep', cantidad: 1 });
    expect(lotes.ingresarEnLote).not.toHaveBeenCalled();
    const movimientos = tx.movimientos_inventario.createMany.mock.calls[0][0].data;
    expect(movimientos).toEqual([
      expect.objectContaining({ producto_id: 'p1', lote_id: 'L1', cantidad: 1, tipo_movimiento_id: 'tipo-AJUSTE_NEGATIVO' }),
    ]);
    expect(movimientos[0].observaciones).toContain('lote A-1');
  });

  it('el depósito tiene que ser de la empresa', async () => {
    const { service, prisma } = crear();
    prisma.depositos.findFirst.mockResolvedValue(null);
    await expect(service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'otro', no_contados: 'poner_en_cero' }, null)).rejects.toThrow('Depósito no encontrado');
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });
});
