import { BadRequestException } from '@nestjs/common';
import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { CancelarSesionInventarioDto } from './dto/cancelar-sesion.dto';
import { InventarioFisicoService } from './inventario-fisico.service';

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


/**
 * Una sesión de inventario abierta no se podía cancelar ni borrar y quedaba
 * colgada. «Cancelar sesión»: sin tocar el stock, con motivo y auditoría.
 */
function crear(estado = 'abierto', zonas = 0) {
  const tx: any = {
    $queryRaw: jest.fn().mockResolvedValue([{ id: 'ses', nombre: 'Inventario Octubre', estado }]),
    inventario_zonas_aplicadas: { count: jest.fn().mockResolvedValue(zonas) },
    inventario_conteos: { count: jest.fn().mockResolvedValue(12) },
    inventario_sesiones: { update: jest.fn() },
    // Si algo de esto se llamara, se estaría tocando el stock.
    stock_deposito: { createMany: jest.fn(), update: jest.fn(), updateMany: jest.fn() },
    movimientos_inventario: { create: jest.fn(), createMany: jest.fn() },
  };
  const prisma: any = { $transaction: jest.fn((cb: (t: any) => unknown) => cb(tx)), inventario_conteos: { findMany: jest.fn().mockResolvedValue([]) } };
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  const lotes: any = { descontarDeLote: jest.fn(), ingresarEnLote: jest.fn() };
  return { service: new InventarioFisicoService(prisma, lotes, audit as any), tx, audit, lotes };
}

describe('Inventario físico — cancelar sesión', () => {
  it('pasa a «cancelado» con motivo y quién, sin tocar stock ni lotes, y audita', async () => {
    const { service, tx, audit, lotes } = crear();
    const r = await service.cancelarSesion('ses', 'emp', '  Se creó por error  ', 'usr');
    expect(tx.$queryRaw).toHaveBeenCalled(); // FOR UPDATE: no se cruza con un cierre
    expect(tx.inventario_sesiones.update).toHaveBeenCalledWith({
      where: { id: 'ses' },
      data: expect.objectContaining({ estado: 'cancelado', cancelado_por: 'usr', motivo_cancelacion: 'Se creó por error' }),
    });
    expect(tx.stock_deposito.createMany).not.toHaveBeenCalled();
    expect(tx.movimientos_inventario.createMany).not.toHaveBeenCalled();
    expect(lotes.descontarDeLote).not.toHaveBeenCalled();
    expect(audit.log).toHaveBeenCalledWith(
      expect.objectContaining({ action: 'CANCELAR', entity_type: 'inventario_sesion', entity_id: 'ses', user_id: 'usr' }),
    );
    expect(r.message).toContain('el stock no cambió');
  });

  it('avisa que los ajustes de zona ya aplicados no se revierten', async () => {
    const { service } = crear('abierto', 2);
    const r = await service.cancelarSesion('ses', 'emp', 'x', 'usr');
    expect(r.message).toMatch(/2 ajuste\(s\) de zona/);
    expect(r.data.zonas_aplicadas).toBe(2);
  });

  it('una sesión cerrada o ya cancelada no se cancela', async () => {
    await expect(crear('cerrado').service.cancelarSesion('ses', 'emp', 'x', 'usr')).rejects.toThrow(/ya está cerrada/);
    await expect(crear('cancelado').service.cancelarSesion('ses', 'emp', 'x', 'usr')).rejects.toThrow(/fue cancelada/);
  });

  it('una sesión cancelada tampoco se puede cerrar después', async () => {
    const { service } = crear('cancelado');
    await expect(service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' })).rejects.toThrow(BadRequestException);
  });

  it('el motivo es obligatorio (y no vale solo espacios)', async () => {
    await expect(crear().service.cancelarSesion('ses', 'emp', '   ', 'usr')).rejects.toThrow(/motivo/);
    const errores = await validate(plainToInstance(CancelarSesionInventarioDto, { motivo: '  ' }));
    expect(errores.map((e) => e.property)).toContain('motivo');
  });
});
