import { MovimientosInventarioService } from './movimientos-inventario.service';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { resolverPermisos } from 'src/productos/permisos-columnas';

jest.mock('src/productos/permisos-columnas', () => ({ resolverPermisos: jest.fn().mockResolvedValue(new Set()) }));
jest.mock('src/utils/alcance-sucursal', () => ({
  exigirSucursalEnAlcance: jest.requireActual('src/utils/alcance-sucursal').exigirSucursalEnAlcance,
  alcanceSucursalUsuario: jest.fn().mockResolvedValue(null),
  filtroSucursalDeposito: jest.fn((_a: unknown, pedida?: string) => pedida),
}));

/** S15: el filtro de sucursal mira el depósito de origen O el de destino. */
describe('MovimientosInventarioService.findAll - sucursal', () => {
  const transferencia = {
    id: 'm1',
    deposito_origen_id: 'dep-a',
    deposito_destino_id: 'dep-b',
    deposito_origen: { sucursal_id: 'suc-a' },
    deposito_destino: { sucursal_id: 'suc-b' },
    tipo_movimiento: { afecta_stock: 0 },
    created_at: new Date('2026-10-25T12:00:00Z'),
  };
  const crear = () => {
    const prisma: any = {
      movimientos_inventario: {
        findMany: jest.fn().mockResolvedValue([transferencia]),
        count: jest.fn().mockResolvedValue(1),
        groupBy: jest.fn().mockResolvedValue([{ tipo_movimiento_id: 't', _sum: { cantidad: 5 } }]),
        aggregate: jest.fn().mockResolvedValue({ _sum: { cantidad: 5 } }),
      },
      tipo_movimiento_inventario: { findMany: jest.fn().mockResolvedValue([{ id: 't', afecta_stock: 0 }]) },
      empresas_sucursales: { findFirst: jest.fn().mockResolvedValue({ id: 'suc' }) },
      $transaction: jest.fn(async (ops: any[]) => Promise.all(ops)),
    };
    return { service: new MovimientosInventarioService(prisma), prisma };
  };

  it('una transferencia que llega desde otra sucursal aparece y suma como entrada', async () => {
    const { service, prisma } = crear();
    prisma.movimientos_inventario.aggregate
      .mockResolvedValueOnce({ _sum: { cantidad: 0 } }) // salen de suc-b
      .mockResolvedValueOnce({ _sum: { cantidad: 5 } }); // llegan a suc-b
    const r: any = await service.findAll('emp', { sucursal_id: 'suc-b', usuarioId: 'usr' });
    const where = prisma.movimientos_inventario.findMany.mock.calls[0][0].where;
    expect(where.AND).toEqual(
      expect.arrayContaining([
        { OR: [{ deposito_origen: { sucursal_id: 'suc-b' } }, { deposito_destino: { sucursal_id: 'suc-b' } }] },
      ]),
    );
    expect(r.data[0].efecto).toBe(1);
    expect(r.totales.entradas).toBe(5);
  });

  it('vista desde la sucursal de origen es una salida', async () => {
    const { service } = crear();
    const r: any = await service.findAll('emp', { sucursal_id: 'suc-a', usuarioId: 'usr' });
    expect(r.data[0].efecto).toBe(-1);
  });

  it('una sucursal pedida fuera del alcance es 403 SUCURSAL_FUERA_DE_ALCANCE, no lista vacía', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValueOnce({ sucursalIds: ['suc-a'], puntosEstablecimiento: [], depositoIds: ['dep-a'] });
    const { service, prisma } = crear();
    await expect(service.findAll('emp', { sucursal_id: 'suc-b', usuarioId: 'usr' })).rejects.toMatchObject({
      status: 403,
      response: { codigo: 'SUCURSAL_FUERA_DE_ALCANCE', campo: 'sucursal_id' },
    });
    expect(prisma.movimientos_inventario.findMany).not.toHaveBeenCalled();
  });

  it('sin alcance (admin), una sucursal de otra empresa también es 403', async () => {
    const { service, prisma } = crear();
    prisma.empresas_sucursales.findFirst.mockResolvedValue(null);
    await expect(service.findAll('emp', { sucursal_id: 'suc-ajena', usuarioId: 'usr' })).rejects.toMatchObject({ status: 403 });
    expect(prisma.empresas_sucursales.findFirst).toHaveBeenCalledWith(expect.objectContaining({ where: expect.objectContaining({ id: 'suc-ajena', empresa_id: 'emp' }) }));
  });
});

/** Alcance por depósito y costo por permiso en las lecturas por producto y por depósito. */
describe('MovimientosInventarioService: alcance y costo', () => {
  const alcanceA = { sucursalIds: ['s'], puntosEstablecimiento: [], depositoIds: ['dep-a'] };
  const mov = { id: 'm', costo_unitario: 1100, precio_unitario: 1500, producto: { id: 'p', descripcion: 'P', precio_costo: 900 } };
  const crear = () => {
    const prisma: any = { movimientos_inventario: { findMany: jest.fn().mockResolvedValue([mov]) } };
    return { service: new MovimientosInventarioService(prisma), prisma };
  };
  const UUID = '9e79de7a-4ed4-4d9f-a787-e745aa359a82';

  afterEach(() => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null);
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set());
  });

  it('findByProducto y findByDeposito filtran por origen o destino en el alcance', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
    const { service, prisma } = crear();
    await service.findByProducto(UUID, 'emp', 'usr');
    expect(prisma.movimientos_inventario.findMany.mock.calls[0][0].where.OR).toEqual([{ deposito_origen_id: { in: ['dep-a'] } }, { deposito_destino_id: { in: ['dep-a'] } }]);
    await service.findByDeposito('dep-a', 'emp', 'usr');
    expect(JSON.stringify(prisma.movimientos_inventario.findMany.mock.calls[1][0].where)).toContain('"in":["dep-a"]');
  });

  it('findByDeposito con un depósito ajeno: vacío', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
    const { service, prisma } = crear();
    expect(await service.findByDeposito('dep-b', 'emp', 'usr')).toEqual([]);
    expect(prisma.movimientos_inventario.findMany).not.toHaveBeenCalled();
  });

  it('F3: sin INV_STK_COSTO_VER el movimiento no trae producto.precio_costo; con el permiso sí', async () => {
    const { service } = crear();
    const sin: any = await service.findByProducto(UUID, 'emp', 'usr');
    expect(sin[0].producto).not.toHaveProperty('precio_costo');
    expect(sin[0].costo_unitario).toBeNull();
    expect(JSON.stringify(sin)).not.toContain('900');
    expect(JSON.stringify(sin)).not.toContain('1100');
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set(['INV_STK_COSTO_VER']));
    const con: any = await service.findByDeposito('dep-a', 'emp', 'usr');
    expect(con[0].producto.precio_costo).toBe(900);
    expect(con[0].costo_unitario).toBe(1100);
  });

  it('F3: el listado general tampoco manda el costo sin permiso', async () => {
    const prisma: any = {
      movimientos_inventario: {
        findMany: jest.fn().mockResolvedValue([{ ...mov, deposito_origen_id: 'a', deposito_destino_id: null, deposito_origen: null, deposito_destino: null, tipo_movimiento: { afecta_stock: 1 }, created_at: new Date() }]),
        count: jest.fn().mockResolvedValue(1),
        groupBy: jest.fn().mockResolvedValue([]),
        aggregate: jest.fn().mockResolvedValue({ _sum: { cantidad: 0 } }),
      },
      tipo_movimiento_inventario: { findMany: jest.fn().mockResolvedValue([]) },
      $transaction: jest.fn(async (ops: any[]) => Promise.all(ops)),
    };
    const r: any = await new MovimientosInventarioService(prisma).findAll('emp', { usuarioId: 'usr' });
    expect(r.data[0].producto).not.toHaveProperty('precio_costo');
    expect(r.data[0].costo_unitario).toBeNull();
  });
});
