import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { CrearSesionInventarioDto } from './dto/crear-sesion.dto';
import { 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) }));

const alcanceA = { sucursalIds: ['s'], puntosEstablecimiento: [], depositoIds: ['dep-a'] };

function crear(opciones: { conteos?: string[]; falla?: boolean } = {}) {
  const tx: any = {
    $queryRaw: jest.fn().mockResolvedValue([{ id: 'ses', nombre: 'Octubre', estado: 'abierto' }]),
    $executeRaw: jest.fn().mockResolvedValue(1),
    inventario_sesiones: { update: jest.fn() },
    inventario_zonas_aplicadas: { create: jest.fn(), count: jest.fn().mockResolvedValue(0) },
    inventario_conteos: { findMany: jest.fn().mockResolvedValue([]), count: jest.fn().mockResolvedValue(0) },
    productos: { findMany: jest.fn().mockResolvedValue([]) },
    stock_deposito: { createMany: jest.fn() },
    movimientos_inventario: { createMany: jest.fn() },
    depositos: { findMany: jest.fn().mockResolvedValue([]) },
  };
  const prisma: any = {
    $transaction: jest.fn(async (cb: any) => {
      if (opciones.falla) throw new Error('boom');
      return cb(tx);
    }),
    inventario_sesiones: { create: jest.fn().mockResolvedValue({ id: 'ses', nombre: 'Mayo' }), findFirst: jest.fn().mockResolvedValue({ id: 'ses', nombre: 'Octubre', estado: 'abierto' }) },
    inventario_conteos: {
      findMany: jest.fn().mockImplementation(async () => (opciones.conteos ?? []).map((deposito_id) => ({ deposito_id, producto_id: 'p', categoria_id: null }))),
      deleteMany: jest.fn(),
    },
    inventario_zonas_aplicadas: { findMany: jest.fn().mockResolvedValue([]) },
    categorias: { findMany: jest.fn().mockResolvedValue([]) },
    depositos: { findFirst: jest.fn().mockResolvedValue({ id: 'dep-b', descripcion: 'B', sucursal_id: 's2' }), findMany: jest.fn().mockResolvedValue([]) },
    productos: { findFirst: jest.fn().mockResolvedValue({ descripcion: 'P', maneja_inventario: true }), findMany: jest.fn().mockResolvedValue([]), count: jest.fn().mockResolvedValue(0) },
    stock_deposito: { findMany: jest.fn().mockResolvedValue([]), groupBy: jest.fn().mockResolvedValue([]) },
  };
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  const lotes: any = { isEnabledForEmpresa: jest.fn().mockResolvedValue(false) };
  return { service: new InventarioFisicoService(prisma, lotes, audit as any), prisma, tx, audit };
}

describe('CrearSesionInventarioDto', () => {
  it.each([['', false], ['   ', false], ['x'.repeat(256), false], ['Inventario Mayo', true]])('nombre %p válido=%p', async (nombre, valido) => {
    expect((await validate(plainToInstance(CrearSesionInventarioDto, { nombre }))).length === 0).toBe(valido);
  });
});

describe('Inventario físico E1: sesión y auditoría', () => {
  beforeEach(() => (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null));

  it('crearSesion guarda el nombre sin espacios sobrantes y audita CREATE', async () => {
    const { service, prisma, audit } = crear();
    await service.crearSesion('emp', '  Mayo  ', 'usr');
    expect(prisma.inventario_sesiones.create).toHaveBeenCalledWith({ data: { empresa_id: 'emp', nombre: 'Mayo' } });
    expect(audit.log).toHaveBeenCalledWith(expect.objectContaining({ action: 'CREATE', entity_type: 'inventario_sesion', user_id: 'usr' }));
  });

  it('cerrarSesion audita CERRAR una vez, tras el commit', async () => {
    const { service, audit, tx } = crear();
    await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' });
    expect(tx.inventario_sesiones.update).toHaveBeenCalled();
    expect(audit.log).toHaveBeenCalledTimes(1);
    expect(audit.log).toHaveBeenCalledWith(expect.objectContaining({ action: 'CERRAR', entity_id: 'ses', user_id: 'usr' }));
  });

  it('si la transacción lanza, no audita', async () => {
    const { service, audit } = crear({ falla: true });
    await expect(service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' })).rejects.toThrow('boom');
    expect(audit.log).not.toHaveBeenCalled();
  });

  it('cerrarZona audita APLICAR_ZONA con depósito, «mantener» y movimientos', async () => {
    const { service, audit, prisma } = crear();
    prisma.depositos.findFirst.mockResolvedValue({ id: 'dep-a', descripcion: 'A', sucursal_id: 's' });
    await service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep-a', no_contados: 'mantener' }, null);
    const entrada = audit.log.mock.calls[0][0];
    expect(entrada).toMatchObject({ action: 'APLICAR_ZONA', user_id: 'usr' });
    expect(entrada.new_value).toMatchObject({ deposito_id: 'dep-a', mantener_stock_no_contados: true, movimientos: 0 });
  });
});

describe('Inventario físico E1: alcance por depósito', () => {
  beforeEach(() => (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA));
  const fuera = { status: 403, response: { codigo: 'DEPOSITO_FUERA_DE_ALCANCE' } };

  it('registrar, eliminar y cerrar zona en dep-b: 403', async () => {
    const { service } = crear();
    await expect(service.registrarConteo('ses', 'emp', 'usr', { deposito_id: 'dep-b', producto_id: 'p', cantidad_contada: 1 })).rejects.toMatchObject(fuera);
    await expect(service.eliminarConteo('ses', 'emp', 'p', 'dep-b', undefined, 'usr')).rejects.toMatchObject(fuera);
    await expect(service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep-b', no_contados: 'poner_en_cero' }, null)).rejects.toMatchObject(fuera);
  });

  it.each([
    ['cerrar', (s: InventarioFisicoService) => s.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' })],
    ['cancelar', (s: InventarioFisicoService) => s.cancelarSesion('ses', 'emp', 'motivo', 'usr')],
    ['resumen del cierre', (s: InventarioFisicoService) => s.resumenCierre('ses', 'emp', 'usr')],
  ])('%s con conteos en dep-a y dep-b: 403 y el stock no se toca', async (_n, accion) => {
    const { service, prisma } = crear({ conteos: ['dep-a', 'dep-b'] });
    await expect(accion(service)).rejects.toMatchObject(fuera);
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('sin conteos, cerrar pasa', async () => {
    const { service, prisma } = crear({ conteos: [] });
    await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'poner_en_cero' });
    expect(prisma.$transaction).toHaveBeenCalled();
  });

  it('listarConteos y progresoPorZona filtran a los depósitos del alcance', async () => {
    const { service, prisma } = crear();
    prisma.inventario_conteos.findMany.mockResolvedValue([]);
    await service.listarConteos('ses', 'emp', {}, 'usr');
    await service.progresoPorZona('ses', 'emp', 'usr');
    for (const llamada of prisma.inventario_conteos.findMany.mock.calls) expect(llamada[0].where.deposito_id).toEqual({ in: ['dep-a'] });
  });

  it('productosZona y productosNoContados con dep-b: vacío con total 0', async () => {
    const { service } = crear();
    expect(await service.productosZona('emp', 'dep-b', null, 'ses', undefined, 0, 50, undefined, undefined, { usuarioId: 'usr' })).toEqual({ total: 0, data: [] });
    expect(await service.productosNoContados('ses', 'emp', 'usr', { depositoId: 'dep-b', skip: 0, take: 50, conStock: false }, null)).toEqual({ total: 0, data: [] });
  });
});
