import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { REQUIRE_PERMISSION_KEY } from 'src/auth/decorators/require-permission.decorator';
import { REQUIRE_SUBMODULO_KEY } from 'src/auth/decorators/require-submodulo.decorator';
import { SubmoduloGuard } from 'src/auth/guards/submodulo.guard';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { rubrosFiltroUsuario } from 'src/utils/alcance-rubro';
import { CerrarSesionInventarioDto } from './dto/cerrar-sesion.dto';
import { CerrarZonaInventarioDto } from './dto/cerrar-zona.dto';
import { DeshacerConteoQueryDto, NoContadosQueryDto, ProductosZonaQueryDto, ResumenZonaQueryDto } from './dto/consultas.dto';
import { RegistrarConteoDto } from './dto/registrar-conteo.dto';
import { InventarioFisicoController } from './inventario-fisico.controller';
import { efectoDeDeposito, 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 uuid = '9a05c7ed-e639-4e2e-9f19-e8e122c5a7f9';
const alcanceA = { sucursalIds: ['s'], puntosEstablecimiento: [], depositoIds: ['dep-a'] };

type FilaStock = { producto_id: string; cantidad: number; reservado?: number };
type Escenario = {
  nombre?: string;
  estado?: string;
  depositos?: { id: string; descripcion: string; sucursal_id: string | null }[];
  stock?: Record<string, FilaStock[]>;
  lotes?: { deposito_id: string; lote_id: string; producto_id: string; numero_lote: string; cantidad: number }[];
  conteos?: { deposito_id: string; producto_id: string; lote_id?: string | null; cantidad: number; numero_lote?: string }[];
  conLote?: string[];
  lotesHabilitados?: boolean;
  productosZona?: string[];
  nombres?: { id: string; cod_producto: string; descripcion: string }[];
};

/** Texto completo de una llamada a $queryRaw: las plantillas y los fragmentos Prisma.sql anidados. */
const textoSql = (llamada: unknown[]) => `${(llamada[0] as string[]).join('?')} ${JSON.stringify(llamada.slice(1))}`;

function armar(e: Escenario = {}) {
  const depositos = e.depositos ?? [{ id: 'dep-a', descripcion: 'A', sucursal_id: 's' }];
  const esSesion = { id: 'ses', nombre: e.nombre ?? 'Octubre', estado: e.estado ?? 'abierto' };
  const queryRaw = jest.fn().mockImplementation((strings: TemplateStringsArray, ...valores: unknown[]) => {
    const sql = strings.join('?');
    if (sql.includes('FROM inventario_sesiones')) return Promise.resolve([esSesion]);
    if (sql.includes('FOR UPDATE')) return Promise.resolve([]);
    if (sql.includes('FROM stock_lote')) {
      const dep = valores[0] as string;
      return Promise.resolve((e.lotes ?? []).filter((l) => l.deposito_id === dep).map((l) => ({ lote_id: l.lote_id, producto_id: l.producto_id, numero_lote: l.numero_lote, cantidad_disponible: l.cantidad })));
    }
    if (sql.includes('FROM stock_deposito')) {
      const dep = valores[0] as string;
      return Promise.resolve((e.stock?.[dep] ?? []).map((s) => ({ producto_id: s.producto_id, cantidad_disponible: s.cantidad, cantidad_reservada: s.reservado ?? 0 })));
    }
    return Promise.resolve([]);
  });
  const conteosDe = ({ where }: any) => {
    const filas = (e.conteos ?? []).filter((c) => !where.deposito_id || c.deposito_id === where.deposito_id);
    if (where.producto_id?.in) return filas.filter((c) => where.producto_id.in.includes(c.producto_id));
    return filas;
  };
  const conteosFindMany = jest.fn().mockImplementation(async (args: any) => {
    const filas = conteosDe(args);
    if (args.distinct?.[0] === 'deposito_id') return [...new Set(filas.map((f) => f.deposito_id))].map((deposito_id) => ({ deposito_id }));
    return filas.map((c) => ({ producto_id: c.producto_id, lote_id: c.lote_id ?? null, cantidad_contada: c.cantidad, deposito_id: c.deposito_id, lote: c.lote_id ? { numero_lote: c.numero_lote ?? 'N' } : null }));
  });
  const productosFindMany = jest.fn().mockImplementation(async ({ where, select }: any) => {
    if (where?.maneja_lote) return (e.conLote ?? []).map((id) => ({ id }));
    if (select?.cod_producto) return (e.nombres ?? []).filter((n) => where.id.in.includes(n.id));
    return (e.productosZona ?? []).map((id) => ({ id }));
  });
  const db: any = {
    $queryRaw: queryRaw,
    $executeRaw: jest.fn().mockResolvedValue(1),
    inventario_sesiones: { update: jest.fn(), findFirst: jest.fn().mockResolvedValue(esSesion) },
    inventario_zonas_aplicadas: { create: jest.fn(), count: jest.fn().mockResolvedValue(0), findMany: jest.fn().mockResolvedValue([]) },
    inventario_conteos: { findMany: conteosFindMany, findFirst: jest.fn().mockResolvedValue(null), create: jest.fn(), update: jest.fn(), deleteMany: jest.fn() },
    productos: {
      findMany: productosFindMany,
      findFirst: jest.fn().mockResolvedValue({ descripcion: 'Coca', maneja_inventario: true, categoria_id: 'cat-producto' }),
      count: jest.fn().mockResolvedValue(0),
    },
    stock_deposito: { createMany: jest.fn(), groupBy: jest.fn().mockResolvedValue([]) },
    movimientos_inventario: { createMany: jest.fn() },
    tipo_movimiento_inventario: { findUnique: jest.fn().mockImplementation(({ where }: any) => Promise.resolve({ id: `tipo-${where.codigo}` })), upsert: jest.fn() },
    depositos: {
      findMany: jest.fn().mockImplementation(async ({ orderBy }: any) => (orderBy?.id ? [...depositos].sort((a, b) => a.id.localeCompare(b.id)) : depositos)),
      findFirst: jest.fn().mockResolvedValue(depositos[0] ?? null),
    },
    categorias: { findMany: jest.fn().mockResolvedValue([]) },
    marcas: { findMany: jest.fn().mockResolvedValue([]) },
    usuario: { findMany: jest.fn().mockResolvedValue([]) },
  };
  db.$transaction = jest.fn(async (cb: any) => cb(db));
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  const lotes: any = {
    isEnabledForEmpresa: jest.fn().mockResolvedValue(e.lotesHabilitados ?? false),
    usaLotesEnDeposito: jest.fn().mockResolvedValue(false),
    loteDelProducto: jest.fn(),
    ingresarEnLote: jest.fn(),
    descontarDeLote: jest.fn(),
  };
  return { service: new InventarioFisicoService(db, lotes, audit as any), db, audit, lotes };
}

const sqls = (db: any) => db.$queryRaw.mock.calls.map(textoSql) as string[];
const sinEscritura = (db: any) => {
  expect(db.movimientos_inventario.createMany).not.toHaveBeenCalled();
  expect(db.inventario_sesiones.update).not.toHaveBeenCalled();
  expect(db.$executeRaw).not.toHaveBeenCalled();
};

/** Depósito con un contado que baja, uno sin cambio y dos no contados (uno negativo). */
const conNoContados: Escenario = {
  stock: { 'dep-a': [{ producto_id: 'a', cantidad: 10 }, { producto_id: 'b', cantidad: 5 }, { producto_id: 'c', cantidad: 7 }, { producto_id: 'd', cantidad: -2 }] },
  conteos: [{ deposito_id: 'dep-a', producto_id: 'a', cantidad: 8 }, { deposito_id: 'dep-a', producto_id: 'b', cantidad: 5 }],
};

const conReservado = (stock: number, reservado: number, conteo?: number): Escenario => ({
  stock: { 'dep-a': [{ producto_id: 'p', cantidad: stock, reservado }] },
  conteos: conteo === undefined ? [{ deposito_id: 'dep-a', producto_id: 'otro', cantidad: 0 }] : [{ deposito_id: 'dep-a', producto_id: 'p', cantidad: conteo }],
  nombres: [{ id: 'p', cod_producto: 'P-1', descripcion: 'Coca' }],
});

beforeEach(() => {
  (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null);
  (rubrosFiltroUsuario as jest.Mock).mockResolvedValue(null);
});

describe('Rutas: submódulo y privilegio', () => {
  it('la clase exige INV_CONTEO_FISICO con SubmoduloGuard', () => {
    expect(Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, InventarioFisicoController)).toBe('INV_CONTEO_FISICO');
    expect(Reflect.getMetadata('__guards__', InventarioFisicoController)).toContain(SubmoduloGuard);
  });

  it.each([
    ['crearSesion', 'INV_CON_CONTEO_CREAR'],
    ['registrarConteo', 'INV_CON_CONTEO_CREAR'],
    ['cerrarSesion', 'INV_CON_CONTEO_CONFIRMAR'],
    ['cancelarSesion', 'INV_CON_CONTEO_CONFIRMAR'],
    ['resumenCierre', 'INV_CON_CONTEO_CONFIRMAR'],
    ['resumenZona', 'INV_CON_CONTEO_CONFIRMAR'],
    ['eliminarConteo', 'INV_CON_CONTEO_CONFIRMAR'],
    ['cerrarZona', 'INV_CON_CONTEO_CONFIRMAR'],
    ['opciones', 'INV_CON_CONTEO_VER'],
    ['listarSesiones', 'INV_CON_CONTEO_VER'],
    ['progreso', 'INV_CON_CONTEO_VER'],
    ['listarConteos', 'INV_CON_CONTEO_VER'],
    ['zonasAplicadas', 'INV_CON_CONTEO_VER'],
    ['productosZona', 'INV_CON_CONTEO_VER'],
    ['productosNoContados', 'INV_CON_CONTEO_VER'],
  ])('%s pide %s', (metodo, privilegio) => {
    const meta = Reflect.getMetadata(REQUIRE_PERMISSION_KEY, (InventarioFisicoController.prototype as any)[metodo]);
    expect(meta).toEqual({ modulo: 'INVENTARIO', privilegio });
  });
});

describe('DTOs', () => {
  const valido = async (clase: any, datos: object) => (await validate(plainToInstance(clase, datos) as object)).length === 0;

  it('CerrarSesion: la opción es obligatoria y sin defecto', async () => {
    expect(await valido(CerrarSesionInventarioDto, {})).toBe(false);
    expect(await valido(CerrarSesionInventarioDto, { no_contados: 'otra' })).toBe(false);
    expect(await valido(CerrarSesionInventarioDto, { no_contados: 'mantener' })).toBe(true);
    expect(await valido(CerrarSesionInventarioDto, { no_contados: 'poner_en_cero', confirmacion_nombre: 'x'.repeat(256) })).toBe(false);
  });

  it('CerrarZona: sin no_contados, con el booleano viejo o con ids malos, inválido', async () => {
    expect(await valido(CerrarZonaInventarioDto, { deposito_id: uuid })).toBe(false);
    expect(await valido(CerrarZonaInventarioDto, { deposito_id: uuid, mantener_stock_no_contados: true })).toBe(false);
    expect(await valido(CerrarZonaInventarioDto, { deposito_id: 'x', no_contados: 'mantener' })).toBe(false);
    expect(await valido(CerrarZonaInventarioDto, { deposito_id: uuid, categoria_ids: ['x'], no_contados: 'mantener' })).toBe(false);
    expect(await valido(CerrarZonaInventarioDto, { deposito_id: uuid, categoria_ids: [uuid], marca_ids: [uuid], no_contados: 'mantener' })).toBe(true);
  });

  it.each([[-1, false], [0, true], [75223.5, true], [1.23456, false], [100_000_000_000, false]])('RegistrarConteo: cantidad %p válida=%p', async (cantidad_contada, esperado) => {
    expect(await valido(RegistrarConteoDto, { deposito_id: uuid, producto_id: uuid, cantidad_contada })).toBe(esperado);
  });

  it('RegistrarConteo: lote_id null vale; un lote que no es uuid, no', async () => {
    expect(await valido(RegistrarConteoDto, { deposito_id: uuid, producto_id: uuid, cantidad_contada: 1, lote_id: null })).toBe(true);
    expect(await valido(RegistrarConteoDto, { deposito_id: uuid, producto_id: uuid, cantidad_contada: 1, lote_id: 'x' })).toBe(false);
  });

  it('Resumen de zona: ids separados por coma; uno malo, inválido', async () => {
    expect(await valido(ResumenZonaQueryDto, { depositoId: uuid, categoriaIds: `${uuid},${uuid}`, marcaIds: uuid })).toBe(true);
    expect(await valido(ResumenZonaQueryDto, { depositoId: uuid, categoriaIds: `${uuid},x` })).toBe(false);
    expect(plainToInstance(ResumenZonaQueryDto, { depositoId: uuid, categoriaIds: `${uuid},` }).categoriaIds).toEqual([uuid]);
  });

  it('Productos de zona: sesionId obligatorio; números y filtro', async () => {
    expect(await valido(ProductosZonaQueryDto, {})).toBe(false);
    expect(await valido(ProductosZonaQueryDto, { sesionId: uuid, skip: '0', take: '50', filtro: 'contados', marcaId: uuid })).toBe(true);
    expect(await valido(ProductosZonaQueryDto, { sesionId: uuid, filtro: 'otro' })).toBe(false);
    expect(await valido(ProductosZonaQueryDto, { sesionId: uuid, categoriaId: 'x' })).toBe(false);
    expect(plainToInstance(ProductosZonaQueryDto, { sesionId: uuid, skip: '10' }).skip).toBe(10);
  });

  it('No contados: acepta con_stock=1 y números como texto', async () => {
    expect(await valido(NoContadosQueryDto, { skip: '0', take: '50', con_stock: '1' })).toBe(true);
    expect(await valido(NoContadosQueryDto, { con_stock: '2' })).toBe(false);
    expect(await valido(NoContadosQueryDto, { depositoId: 'x' })).toBe(false);
  });

  it('Deshacer: loteId es «sin-lote» o un uuid', async () => {
    const base = { productoId: uuid, depositoId: uuid };
    expect(await valido(DeshacerConteoQueryDto, base)).toBe(true);
    expect(await valido(DeshacerConteoQueryDto, { ...base, loteId: 'sin-lote' })).toBe(true);
    expect(await valido(DeshacerConteoQueryDto, { ...base, loteId: uuid })).toBe(true);
    expect(await valido(DeshacerConteoQueryDto, { ...base, loteId: 'x' })).toBe(false);
    expect(await valido(DeshacerConteoQueryDto, { productoId: 'x', depositoId: uuid })).toBe(false);
  });
});

describe('Efecto por escenario', () => {
  const partes = (stock: FilaStock[], conteos: { producto_id: string; lote_id?: string | null; cantidad: number }[], lotes: { producto_id: string; lote_id: string; cantidad: number }[] = []) => ({
    stock: [...stock.map((s) => ({ producto_id: s.producto_id, lote_id: null, cantidad: s.cantidad })), ...lotes],
    conteos: conteos.map((c) => ({ producto_id: c.producto_id, lote_id: c.lote_id ?? null, cantidad: c.cantidad })),
    stockDeposito: new Map(stock.map((s) => [s.producto_id, s.cantidad])),
    reservadoDeposito: new Map(stock.map((s) => [s.producto_id, s.reservado ?? 0])),
    numerosLote: new Map<string, string>(),
  });
  const dep = { id: 'dep-a', descripcion: 'A' };

  it('cuenta por escenario: contados, no contados, sin cambio, bajan y a cero', () => {
    const r = efectoDeDeposito(dep, partes([{ producto_id: 'a', cantidad: 10 }, { producto_id: 'b', cantidad: 5 }, { producto_id: 'c', cantidad: 7 }, { producto_id: 'd', cantidad: -2 }], [{ producto_id: 'a', cantidad: 8 }, { producto_id: 'b', cantidad: 5 }]));
    expect(r).toMatchObject({ contados: 2, partes_no_contadas: 2 });
    expect(r.poner_en_cero).toMatchObject({ bajan: 1, unidades_bajan: -2, sin_cambio: 1, a_cero: 2, unidades_a_cero: -5 });
    expect(r.mantener).toMatchObject({ bajan: 1, sin_cambio: 1, a_cero: 0, unidades_a_cero: 0 });
  });

  it('lote no contado de un producto contado cuenta como parte no contada y con mantener no se mueve', () => {
    const r = efectoDeDeposito(dep, partes([{ producto_id: 'p', cantidad: 0 }], [{ producto_id: 'p', lote_id: 'L1', cantidad: 4 }], [{ producto_id: 'p', lote_id: 'L1', cantidad: 4 }, { producto_id: 'p', lote_id: 'L2', cantidad: 3 }]));
    expect(r.partes_no_contadas).toBe(1);
    expect(r.poner_en_cero.a_cero).toBe(0);
    expect(r.ajustes.mantener).toHaveLength(0);
    expect(r.ajustes.poner_en_cero).toEqual([expect.objectContaining({ lote_id: 'L2', final: 0 })]);
  });

  it('reservado: el conteo deja por debajo, en las dos opciones', () => {
    const r = efectoDeDeposito(dep, partes([{ producto_id: 'p', cantidad: 10, reservado: 9 }], [{ producto_id: 'p', cantidad: 8 }]));
    for (const e of [r.poner_en_cero, r.mantener]) {
      expect(e.reservado_total).toBe(1);
      expect(e.reservado[0]).toMatchObject({ producto_id: 'p', quedaria: 8, reservado: 9 });
    }
  });

  it('no contado con reservado: bloquea con poner en cero, no con mantener', () => {
    const r = efectoDeDeposito(dep, partes([{ producto_id: 'p', cantidad: 10, reservado: 3 }], []));
    expect(r.poner_en_cero.reservado_total).toBe(1);
    expect(r.mantener.reservado_total).toBe(0);
  });

  it('subir no bloquea aunque siga por debajo de lo reservado', () => {
    const r = efectoDeDeposito(dep, partes([{ producto_id: 'p', cantidad: 2, reservado: 5 }], [{ producto_id: 'p', cantidad: 3 }]));
    expect(r.poner_en_cero.reservado_total).toBe(0);
  });

  it('más de 20: el total es real y la lista se corta', () => {
    const filas = Array.from({ length: 25 }, (_, i) => ({ producto_id: `p${i}`, cantidad: 10, reservado: 9 }));
    const r = efectoDeDeposito(dep, partes(filas, filas.map((f) => ({ producto_id: f.producto_id, cantidad: 8 }))));
    expect(r.poner_en_cero.reservado_total).toBe(25);
    expect(r.poner_en_cero.reservado).toHaveLength(20);
  });
});

describe('cerrarSesion', () => {
  it('con nombre equivocado, nada se bloquea ni se escribe', async () => {
    const { service, db } = armar(conNoContados);
    await expect(service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener', confirmacion_nombre: 'otra' })).rejects.toMatchObject({ status: 400, response: { codigo: 'NOMBRE_NO_COINCIDE', campo: 'confirmacion_nombre' } });
    expect(db.$queryRaw).toHaveBeenCalledTimes(1);
    sinEscritura(db);
  });

  it('poner en cero sin nombre y con no contados con stock: 400 sin escritura', async () => {
    const { service, db } = armar(conNoContados);
    await expect(service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'poner_en_cero' })).rejects.toMatchObject({ status: 400, response: { codigo: 'NOMBRE_NO_COINCIDE', campo: 'confirmacion_nombre' } });
    sinEscritura(db);
  });

  it('mantener sin nombre y con no contados con stock: pasa y lo no contado no se mueve', async () => {
    const { service, db } = armar(conNoContados);
    const r = await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' });
    expect(r.no_contados).toBe('mantener');
    const movimientos = db.movimientos_inventario.createMany.mock.calls[0][0].data;
    expect(movimientos.map((m: any) => m.producto_id)).toEqual(['a']);
    expect(db.inventario_sesiones.update).toHaveBeenCalledWith({ where: { id: 'ses' }, data: expect.objectContaining({ estado: 'cerrado' }) });
  });

  it('poner en cero sin no contados con stock no pide nombre', async () => {
    const { service, db } = armar({ stock: { 'dep-a': [{ producto_id: 'a', cantidad: 10 }] }, conteos: [{ deposito_id: 'dep-a', producto_id: 'a', cantidad: 8 }] });
    await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'poner_en_cero' });
    expect(db.inventario_sesiones.update).toHaveBeenCalled();
  });

  it('N1: un contado sin fila en el depósito se crea con ON CONFLICT que suma el delta, sin createMany', async () => {
    const { service, db } = armar({ stock: { 'dep-a': [{ producto_id: 'a', cantidad: 10 }] }, conteos: [{ deposito_id: 'dep-a', producto_id: 'nuevo', cantidad: 6 }] });
    await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' });
    expect(db.stock_deposito.createMany).not.toHaveBeenCalled();
    const insert = db.$executeRaw.mock.calls.map(textoSql).find((q: string) => q.includes('INSERT INTO stock_deposito'));
    expect(insert).toContain('ON CONFLICT (deposito_id, producto_id)');
    expect(insert).toContain('stock_deposito.cantidad_disponible + EXCLUDED.cantidad_disponible');
    expect(insert).toContain('"dep-a"');
    expect(insert).toContain('["nuevo"]');
    expect(insert).toContain('[6]');
  });

  it('sin conteos no pide nombre y no cambia stock', async () => {
    const { service, db } = armar();
    const r = await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'poner_en_cero' });
    expect(r.depositos).toEqual([]);
    expect(db.movimientos_inventario.createMany).not.toHaveBeenCalled();
    expect(db.inventario_sesiones.update).toHaveBeenCalled();
  });

  it('el nombre vale con espacios a los lados y no con otras mayúsculas', async () => {
    const bien = armar(conNoContados);
    await bien.service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'poner_en_cero', confirmacion_nombre: '  Octubre  ' });
    expect(bien.db.inventario_sesiones.update).toHaveBeenCalled();
    const mal = armar(conNoContados);
    await expect(mal.service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'poner_en_cero', confirmacion_nombre: 'octubre' })).rejects.toMatchObject({ response: { codigo: 'NOMBRE_NO_COINCIDE' } });
    sinEscritura(mal.db);
  });

  it('poner en cero graba el no contado con final 0', async () => {
    const { service, db } = armar(conNoContados);
    await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'poner_en_cero', confirmacion_nombre: 'Octubre' });
    const movimientos = db.movimientos_inventario.createMany.mock.calls[0][0].data;
    expect(movimientos.map((m: any) => m.producto_id).sort()).toEqual(['a', 'c', 'd']);
    expect(movimientos.find((m: any) => m.producto_id === 'd')).toMatchObject({ cantidad: 2, tipo_movimiento_id: 'tipo-AJUSTE_POSITIVO' });
  });

  it('reservado: 400 con total e items y nada se escribe', async () => {
    const { service, db } = armar(conReservado(10, 9, 8));
    const error = await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' }).catch((e) => e);
    expect(error).toMatchObject({ status: 400, response: { codigo: 'INVENTARIO_RESERVADO', total: 1 } });
    expect(error.response.message).toContain('Liberá o facturá primero esos pedidos (Ventas › Pedidos)');
    expect(error.response.items).toEqual([expect.objectContaining({ producto_id: 'p', cod_producto: 'P-1', descripcion: 'Coca', deposito: 'A', quedaria: 8, reservado: 9 })]);
    sinEscritura(db);
  });

  it('audita CERRAR una vez tras el commit con la opción y las partes', async () => {
    const { service, audit } = armar(conNoContados);
    await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'poner_en_cero', confirmacion_nombre: 'Octubre' });
    expect(audit.log).toHaveBeenCalledTimes(1);
    const entrada = audit.log.mock.calls[0][0];
    expect(entrada).toMatchObject({ action: 'CERRAR', entity_id: 'ses', user_id: 'usr' });
    expect(entrada.new_value).toMatchObject({ estado: 'cerrado', no_contados: 'poner_en_cero', partes_no_contadas: 2 });
    expect(entrada.descripcion).toContain('lo no contado se puso en cero');
  });

  it('si la transacción falla, no audita', async () => {
    const { service, db, audit } = armar(conNoContados);
    db.$transaction.mockRejectedValue(new Error('boom'));
    await expect(service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' })).rejects.toThrow('boom');
    expect(audit.log).not.toHaveBeenCalled();
  });

  it('códigos de estado, con el texto de hoy', async () => {
    await expect(armar({ estado: 'cerrado' }).service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' })).rejects.toMatchObject({ status: 400, message: 'La sesión ya está cerrada: creá una sesión nueva para volver a contar.', response: { codigo: 'SESION_CERRADA' } });
    await expect(armar({ estado: 'cancelado' }).service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' })).rejects.toMatchObject({ status: 400, message: 'La sesión fue cancelada: creá una sesión nueva para volver a contar.', response: { codigo: 'SESION_CANCELADA' } });
  });

  it('otra empresa: 404 SESION_NO_ENCONTRADA', async () => {
    const { service, db } = armar();
    db.$queryRaw.mockResolvedValue([]);
    await expect(service.cerrarSesion('ses', 'otra', 'usr', { no_contados: 'mantener' })).rejects.toMatchObject({ status: 404, message: 'Sesión no encontrada', response: { codigo: 'SESION_NO_ENCONTRADA' } });
  });

  it('depósito contado fuera del alcance: 403 sin transacción', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
    const { service, db } = armar({ conteos: [{ deposito_id: 'dep-b', producto_id: 'p', cantidad: 1 }] });
    await expect(service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' })).rejects.toMatchObject({ status: 403, response: { codigo: 'DEPOSITO_FUERA_DE_ALCANCE' } });
    expect(db.$transaction).not.toHaveBeenCalled();
  });

  it('el control de alcance solo mira conteos de la sesión de esa empresa', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
    const { service, db } = armar();
    await service.resumenCierre('ses', 'emp', 'usr');
    const conEmpresa = db.inventario_conteos.findMany.mock.calls.find((c: any[]) => c[0].where.sesion?.empresa_id);
    expect(conEmpresa[0].where).toMatchObject({ sesion_id: 'ses', sesion: { empresa_id: 'emp' } });
  });
});

describe('Bloqueos en orden', () => {
  const dosDepositos: Escenario = {
    nombre: 'Octubre',
    depositos: [{ id: 'b', descripcion: 'A', sucursal_id: 's' }, { id: 'a', descripcion: 'B', sucursal_id: 's' }],
    stock: { a: [{ producto_id: 'p1', cantidad: 5 }], b: [{ producto_id: 'p2', cantidad: 3 }] },
    conteos: [{ deposito_id: 'a', producto_id: 'p1', cantidad: 5 }, { deposito_id: 'b', producto_id: 'p2', cantidad: 3 }],
  };

  it('todos los lotes antes que todo stock_deposito, con depósitos por id, y el resultado por descripción', async () => {
    const { service, db } = armar({ ...dosDepositos, lotesHabilitados: true });
    const r = await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' });
    expect(r.depositos.map((d) => d.deposito)).toEqual(['A', 'B']);
    const conBloqueo = sqls(db).filter((s) => s.includes('FOR UPDATE OF'));
    expect(conBloqueo).toHaveLength(2);
    expect(conBloqueo[0]).toContain('stock_lote');
    expect(conBloqueo[0]).toContain('ORDER BY sl.deposito_id, sl.lote_id');
    expect(conBloqueo[0]).toContain('FOR UPDATE OF sl');
    expect(conBloqueo[0]).toContain('["a","b"]');
    expect(conBloqueo[1]).toContain('stock_deposito');
    expect(conBloqueo[1]).toContain('ORDER BY sd.deposito_id, sd.producto_id');
    expect(conBloqueo[1]).toContain('FOR UPDATE OF sd');
    expect(conBloqueo[1]).toContain('["a","b"]');
    const orden = sqls(db);
    const ultimoBloqueo = orden.findIndex((s) => s.includes('FOR UPDATE OF sd'));
    expect(orden.slice(ultimoBloqueo + 1).some((s) => s.includes('FOR UPDATE'))).toBe(false);
  });

  it('sin lotes habilitados no bloquea stock_lote', async () => {
    const { service, db } = armar(dosDepositos);
    await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' });
    expect(sqls(db).some((s) => s.includes('FOR UPDATE OF sl'))).toBe(false);
    expect(sqls(db).some((s) => s.includes('FOR UPDATE OF sd'))).toBe(true);
  });

  it('solo bloquea los lotes de los depósitos con lotes habilitados', async () => {
    const { service, db, lotes } = armar(dosDepositos);
    lotes.isEnabledForEmpresa.mockImplementation(async (_e: string, sucursal: string) => sucursal === 's');
    db.depositos.findMany.mockResolvedValue([{ id: 'b', descripcion: 'A', sucursal_id: null }, { id: 'a', descripcion: 'B', sucursal_id: 's' }]);
    await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' });
    const lote = sqls(db).find((s) => s.includes('FOR UPDATE OF sl'))!;
    expect(lote).toContain('["a"]');
  });

  it('el lote se bloquea aunque el producto no tenga conteo: el cierre no filtra por producto', async () => {
    const { service, db } = armar({ ...conNoContados, lotesHabilitados: true });
    await service.cerrarSesion('ses', 'emp', 'usr', { no_contados: 'mantener' });
    const lote = sqls(db).find((s) => s.includes('FOR UPDATE OF sl'))!;
    expect(lote).not.toContain('lp.producto_id = ANY');
  });

  it('la zona bloquea en el mismo orden, acotada a sus productos', async () => {
    const { service, db } = armar({ ...conNoContados, lotesHabilitados: true, productosZona: ['a', 'b'] });
    await service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep-a', no_contados: 'mantener' }, null);
    const conBloqueo = sqls(db).filter((s) => s.includes('FOR UPDATE OF'));
    expect(conBloqueo[0]).toContain('FOR UPDATE OF sl');
    expect(conBloqueo[0]).toContain('lp.producto_id = ANY');
    expect(conBloqueo[1]).toContain('FOR UPDATE OF sd');
    expect(conBloqueo[1]).toContain('sd.producto_id = ANY');
  });

  it('el resumen no bloquea', async () => {
    const { service, db } = armar({ ...conNoContados, lotesHabilitados: true });
    await service.resumenCierre('ses', 'emp', 'usr');
    expect(sqls(db).some((s) => s.includes('FOR UPDATE'))).toBe(false);
  });

  it('el resumen de zona no bloquea', async () => {
    const { service, db } = armar({ ...conNoContados, productosZona: ['a'] });
    await service.resumenZona('ses', 'emp', 'dep-a', null, null, 'usr', null);
    expect(sqls(db).some((s) => s.includes('FOR UPDATE'))).toBe(false);
  });
});

describe('resumenCierre', () => {
  it('devuelve por depósito los dos escenarios, sin datos internos', async () => {
    const { service } = armar(conNoContados);
    const [fila] = await service.resumenCierre('ses', 'emp', 'usr');
    expect(Object.keys(fila).sort()).toEqual(['contados', 'deposito', 'deposito_id', 'mantener', 'partes_no_contadas', 'poner_en_cero'].sort());
    expect(fila.partes_no_contadas).toBe(2);
  });

  it('los reservados llevan código y descripción', async () => {
    const { service } = armar(conReservado(10, 9, 8));
    const [fila] = await service.resumenCierre('ses', 'emp', 'usr');
    expect(fila.mantener.reservado[0]).toMatchObject({ cod_producto: 'P-1', descripcion: 'Coca', quedaria: 8, reservado: 9 });
  });

  it('sesión ajena: 404 con código', async () => {
    const { service, db } = armar();
    db.inventario_sesiones.findFirst.mockResolvedValue(null);
    await expect(service.resumenCierre('ses', 'otra', 'usr')).rejects.toMatchObject({ status: 404, response: { codigo: 'SESION_NO_ENCONTRADA' } });
  });
});

describe('Zona', () => {
  const opciones = { deposito_id: 'dep-a', categoria_ids: ['c1'], marca_ids: ['m1'] };

  it('marca, categoría y rubro entran en los productos', async () => {
    (rubrosFiltroUsuario as jest.Mock).mockResolvedValue('rubro-1');
    const { service, db } = armar({ productosZona: [] });
    await service.cerrarZona('ses', 'emp', 'usr', { ...opciones, no_contados: 'mantener' }, 'rubro-1');
    const where = db.productos.findMany.mock.calls[0][0].where;
    expect(where).toMatchObject({ empresa_id: 'emp', deleted: false, active: true, maneja_inventario: true, marca_id: { in: ['m1'] }, categoria_id: { in: ['c1'] } });
    expect(JSON.stringify(where)).toContain('rubro-1');
  });

  it('resumenZona y cerrarZona piden los mismos productos', async () => {
    (rubrosFiltroUsuario as jest.Mock).mockResolvedValue('rubro-1');
    const { service, db } = armar({ productosZona: [] });
    await service.resumenZona('ses', 'emp', 'dep-a', ['c1'], ['m1'], 'usr', 'rubro-1');
    await service.cerrarZona('ses', 'emp', 'usr', { ...opciones, no_contados: 'mantener' }, 'rubro-1');
    const [primera, segunda] = db.productos.findMany.mock.calls;
    expect(primera[0].where).toEqual(segunda[0].where);
  });

  it('el rubro se resuelve fuera de la transacción', async () => {
    const { service, db } = armar({ productosZona: [] });
    const llamadas: string[] = [];
    (rubrosFiltroUsuario as jest.Mock).mockImplementation(async () => { llamadas.push('rubro'); return null; });
    db.$transaction.mockImplementation(async (cb: any) => { llamadas.push('tx'); return cb(db); });
    await service.cerrarZona('ses', 'emp', 'usr', { ...opciones, no_contados: 'mantener' }, null);
    expect(llamadas).toEqual(['rubro', 'tx']);
  });

  it('resumen de zona trae el total y coincide con lo aplicado', async () => {
    const { service, db } = armar({ ...conNoContados, productosZona: ['a', 'b', 'c', 'd'] });
    const r = await service.resumenZona('ses', 'emp', 'dep-a', null, null, 'usr', null);
    expect(r).toMatchObject({ total_productos: 4, contados: 2, partes_no_contadas: 2 });
    expect(r.poner_en_cero.a_cero).toBe(2);
    const a = await service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep-a', no_contados: 'poner_en_cero' }, null);
    expect(a).toMatchObject({ total_productos: 4, contados: 2, a_cero: r.poner_en_cero.a_cero, bajan: r.poner_en_cero.bajan, suben: r.poner_en_cero.suben });
    expect(db.movimientos_inventario.createMany.mock.calls[0][0].data).toHaveLength(3);
  });

  it('graba categorías, marcas y la opción', async () => {
    const { service, db } = armar({ productosZona: [] });
    await service.cerrarZona('ses', 'emp', 'usr', { ...opciones, no_contados: 'mantener' }, null);
    expect(db.inventario_zonas_aplicadas.create.mock.calls[0][0].data).toMatchObject({ categoria_id: 'c1', categoria_ids: ['c1'], marca_ids: ['m1'], mantener_stock_no_contados: true });
  });

  it('con dos categorías, categoria_id null y categoria_ids con las dos; sin elegir, vacías', async () => {
    const dos = armar({ productosZona: [] });
    await dos.service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep-a', categoria_ids: ['c1', 'c2'], no_contados: 'poner_en_cero' }, null);
    expect(dos.db.inventario_zonas_aplicadas.create.mock.calls[0][0].data).toMatchObject({ categoria_id: null, categoria_ids: ['c1', 'c2'], marca_ids: [], mantener_stock_no_contados: false });
  });

  it('devuelve a_cero real: con mantener 0, sin clave en_cero', async () => {
    const { service } = armar({ ...conNoContados, productosZona: ['a', 'b', 'c', 'd'] });
    const r = await service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep-a', no_contados: 'mantener' }, null);
    expect(r).toMatchObject({ no_contados: 'mantener', total_productos: 4, contados: 2, sin_contar: 2, a_cero: 0, bajan: 1, suben: 0, movimientos: 1 });
    expect(r).not.toHaveProperty('en_cero');
  });

  it('reservado: 400 sin escritura', async () => {
    const { service, db } = armar({ ...conReservado(10, 3), productosZona: ['p'] });
    await expect(service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep-a', no_contados: 'poner_en_cero' }, null)).rejects.toMatchObject({ status: 400, response: { codigo: 'INVENTARIO_RESERVADO', total: 1 } });
    expect(db.inventario_zonas_aplicadas.create).not.toHaveBeenCalled();
    expect(db.movimientos_inventario.createMany).not.toHaveBeenCalled();
  });

  it('audita marcas, opción, a_cero y rubro', async () => {
    const { service, audit } = armar({ ...conNoContados, productosZona: ['a', 'b', 'c', 'd'] });
    await service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep-a', marca_ids: ['m1'], no_contados: 'poner_en_cero' }, 'rubro-1');
    expect(audit.log.mock.calls[0][0].new_value).toMatchObject({ marca_ids: ['m1'], no_contados: 'poner_en_cero', a_cero: 2, rubro_id: 'rubro-1' });
  });

  it('depósito fuera: 403 sin transacción; resumen también', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
    const { service, db } = armar({ depositos: [{ id: 'dep-b', descripcion: 'B', sucursal_id: 's' }] });
    await expect(service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'dep-b', no_contados: 'mantener' }, null)).rejects.toMatchObject({ status: 403 });
    await expect(service.resumenZona('ses', 'emp', 'dep-b', null, null, 'usr', null)).rejects.toMatchObject({ status: 403 });
    expect(db.$transaction).not.toHaveBeenCalled();
  });

  it('depósito ajeno: 404 DEPOSITO_NO_ENCONTRADO', async () => {
    const { service, db } = armar();
    db.depositos.findFirst.mockResolvedValue(null);
    await expect(service.cerrarZona('ses', 'emp', 'usr', { deposito_id: 'x', no_contados: 'mantener' }, null)).rejects.toMatchObject({ status: 404, response: { codigo: 'DEPOSITO_NO_ENCONTRADO' } });
  });
});

describe('registrarConteo', () => {
  const dto = { deposito_id: 'dep-a', producto_id: 'p', cantidad_contada: 4 };

  it('la categoría sale del producto, aunque el cuerpo traiga otra', async () => {
    const { service, db } = armar();
    await service.registrarConteo('ses', 'emp', 'usr', { ...dto, categoria_id: 'otra' } as any);
    expect(db.inventario_conteos.create.mock.calls[0][0].data).toMatchObject({ categoria_id: 'cat-producto', usuario_id: 'usr', cantidad_contada: 4, lote_id: null });
  });

  it('sesión que no es de la empresa: 400 SESION_NO_ABIERTA', async () => {
    const { service, db } = armar();
    db.$queryRaw.mockResolvedValue([]);
    await expect(service.registrarConteo('ses', 'emp', 'usr', dto)).rejects.toMatchObject({ status: 400, message: 'Sesión no encontrada o ya cerrada', response: { codigo: 'SESION_NO_ABIERTA' } });
    await expect(service.eliminarConteo('ses', 'emp', 'p', 'dep-a', undefined, 'usr')).rejects.toMatchObject({ status: 400, response: { codigo: 'SESION_NO_ABIERTA' } });
  });

  it('E3 m2: toma la sesión FOR SHARE con empresa dentro de la transacción, antes de grabar o borrar', async () => {
    const { service, db } = armar();
    await service.registrarConteo('ses', 'emp', 'usr', dto);
    await service.eliminarConteo('ses', 'emp', 'p', 'dep-a', undefined, 'usr');
    expect(db.$transaction).toHaveBeenCalledTimes(2);
    const tomas = sqls(db).filter((q) => q.includes('FROM inventario_sesiones'));
    expect(tomas).toHaveLength(2);
    for (const q of tomas) {
      expect(q).toContain('FOR SHARE');
      expect(q).toContain('empresa_id');
      expect(q).toContain('"ses","emp"');
    }
    expect(db.$queryRaw.mock.invocationCallOrder[0]).toBeLessThan(db.inventario_conteos.create.mock.invocationCallOrder[0]);
    expect(db.$queryRaw.mock.invocationCallOrder[1]).toBeLessThan(db.inventario_conteos.deleteMany.mock.invocationCallOrder[0]);
  });

  it.each([
    ['cerrado', 'SESION_CERRADA'],
    ['cancelado', 'SESION_CANCELADA'],
  ])('E3 m2: si al tomarla la sesión quedó %s (el cierre ganó), no graba ni borra: %s', async (estado, codigo) => {
    const { service, db } = armar({ estado });
    await expect(service.registrarConteo('ses', 'emp', 'usr', dto)).rejects.toMatchObject({ status: 400, response: { codigo } });
    await expect(service.eliminarConteo('ses', 'emp', 'p', 'dep-a', undefined, 'usr')).rejects.toMatchObject({ status: 400, response: { codigo } });
    expect(db.inventario_conteos.create).not.toHaveBeenCalled();
    expect(db.inventario_conteos.update).not.toHaveBeenCalled();
    expect(db.inventario_conteos.deleteMany).not.toHaveBeenCalled();
  });

  it('otro depósito: 404 DEPOSITO_NO_ENCONTRADO', async () => {
    const { service, db } = armar();
    db.depositos.findFirst.mockResolvedValue(null);
    await expect(service.registrarConteo('ses', 'emp', 'usr', dto)).rejects.toMatchObject({ status: 404, response: { codigo: 'DEPOSITO_NO_ENCONTRADO' } });
  });

  it('producto ajeno: 404 PRODUCTO_NO_ENCONTRADO', async () => {
    const { service, db } = armar();
    db.productos.findFirst.mockResolvedValue(null);
    await expect(service.registrarConteo('ses', 'emp', 'usr', dto)).rejects.toMatchObject({ status: 404, message: 'Producto no encontrado', response: { codigo: 'PRODUCTO_NO_ENCONTRADO' } });
  });

  it('servicio: 400 PRODUCTO_SIN_INVENTARIO con el texto de hoy', async () => {
    const { service, db } = armar();
    db.productos.findFirst.mockResolvedValue({ descripcion: 'Flete', maneja_inventario: false, categoria_id: null });
    await expect(service.registrarConteo('ses', 'emp', 'usr', dto)).rejects.toMatchObject({
      status: 400,
      message: '«Flete» no maneja inventario (servicio): no se cuenta. Si es mercadería, activá «Maneja inventario» en la ficha del producto.',
      response: { codigo: 'PRODUCTO_SIN_INVENTARIO', campo: 'producto_id' },
    });
  });

  it('lote sin uso: 400 CONTEO_SIN_LOTES', async () => {
    const { service } = armar();
    await expect(service.registrarConteo('ses', 'emp', 'usr', { ...dto, lote_id: 'L1' })).rejects.toMatchObject({ status: 400, response: { codigo: 'CONTEO_SIN_LOTES', campo: 'lote_id' } });
  });
});

describe('opciones', () => {
  it('listas con la forma pedida, categorías con padre_id', async () => {
    const { service, db } = armar();
    db.depositos.findMany.mockResolvedValue([{ id: 'dep-a', descripcion: 'A', sucursal_id: 's', es_principal: true, sucursal: { id: 's', descripcion: 'Matriz' } }]);
    db.categorias.findMany.mockResolvedValue([{ id: 'c', descripcion: 'Hija', padre_id: 'x' }]);
    db.marcas.findMany.mockResolvedValue([{ id: 'm', descripcion: 'M' }]);
    const r = await service.opciones('emp', 'usr', null);
    expect(Object.keys(r)).toEqual(['sucursales', 'depositos', 'categorias', 'marcas']);
    expect(r.categorias).toEqual([{ id: 'c', descripcion: 'Hija', padre_id: 'x' }]);
    expect(r.sucursales).toEqual([{ id: 's', descripcion: 'Matriz' }]);
    expect(r.depositos).toEqual([{ id: 'dep-a', descripcion: 'A', sucursal_id: 's', es_principal: true }]);
  });

  it('recorta depósitos por alcance y categorías por rubro', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
    (rubrosFiltroUsuario as jest.Mock).mockResolvedValue('rubro-1');
    const { service, db } = armar();
    db.depositos.findMany.mockResolvedValue([]);
    await service.opciones('emp', 'usr', 'rubro-1');
    expect(db.depositos.findMany.mock.calls[0][0].where.id).toEqual({ in: ['dep-a'] });
    expect(JSON.stringify(db.categorias.findMany.mock.calls[0][0].where)).toContain('rubro-1');
  });

  it('no consulta stock ni productos', async () => {
    const { service, db } = armar();
    db.depositos.findMany.mockResolvedValue([]);
    await service.opciones('emp', 'usr', null);
    expect(db.stock_deposito.groupBy).not.toHaveBeenCalled();
    expect(db.productos.findMany).not.toHaveBeenCalled();
    expect(db.$queryRaw).not.toHaveBeenCalled();
  });
});

describe('productosNoContados', () => {
  const filtros = { skip: 0, take: 50, conStock: false };

  it('con_stock filtra por el depósito; sin depósito, por el alcance', async () => {
    const { service, db } = armar();
    await service.productosNoContados('ses', 'emp', 'usr', { ...filtros, depositoId: 'dep-a', conStock: true }, null);
    expect(db.productos.findMany.mock.calls[0][0].where.stock_deposito).toEqual({ some: { deposito_id: 'dep-a', cantidad_disponible: { not: 0 } } });

    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
    const conAlcance = armar();
    await conAlcance.service.productosNoContados('ses', 'emp', 'usr', { ...filtros, conStock: true }, null);
    expect(conAlcance.db.productos.findMany.mock.calls[0][0].where.stock_deposito).toEqual({ some: { deposito_id: { in: ['dep-a'] }, cantidad_disponible: { not: 0 } } });
  });

  it('sin con_stock no filtra por stock', async () => {
    const { service, db } = armar();
    await service.productosNoContados('ses', 'emp', 'usr', filtros, null);
    expect(db.productos.findMany.mock.calls[0][0].where.stock_deposito).toBeUndefined();
  });

  it('stock sin depósito es la suma del alcance', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
    const { service, db } = armar();
    db.productos.count.mockResolvedValue(1);
    db.productos.findMany.mockResolvedValue([{ id: 'p', cod_producto: 'P', descripcion: 'Coca', categoria_id: null, categoria: null }]);
    db.stock_deposito.groupBy.mockResolvedValue([{ producto_id: 'p', _sum: { cantidad_disponible: 7 } }]);
    const r = await service.productosNoContados('ses', 'emp', 'usr', filtros, null);
    expect(r.data[0].stock_sistema).toBe(7);
    expect(db.stock_deposito.groupBy.mock.calls[0][0].where.deposito_id).toEqual({ in: ['dep-a'] });
  });

  it('respeta el rubro del selector', async () => {
    (rubrosFiltroUsuario as jest.Mock).mockResolvedValue('rubro-1');
    const { service, db } = armar();
    await service.productosNoContados('ses', 'emp', 'usr', filtros, 'rubro-1');
    expect(JSON.stringify(db.productos.findMany.mock.calls[0][0].where)).toContain('rubro-1');
  });

  it('take por encima de 1.000 se recorta', async () => {
    const { service, db } = armar();
    await service.productosNoContados('ses', 'emp', 'usr', { ...filtros, take: 5000 }, null);
    expect(db.productos.findMany.mock.calls[0][0].take).toBe(1000);
    const zona = armar();
    await zona.service.productosZona('emp', undefined, null, 'ses', undefined, 0, 5000, undefined, undefined, { usuarioId: 'usr' });
    expect(zona.db.productos.findMany.mock.calls[0][0].take).toBe(1000);
  });
});

describe('productosZona', () => {
  it('sesión de otra empresa: 404', async () => {
    const { service, db } = armar();
    db.inventario_sesiones.findFirst.mockResolvedValue(null);
    await expect(service.productosZona('emp', undefined, null, 'ses', undefined, 0, 50, undefined, undefined, { usuarioId: 'usr' })).rejects.toMatchObject({ status: 404, response: { codigo: 'SESION_NO_ENCONTRADA' } });
  });

  it('la lista parte del mismo where de la zona y suma búsqueda', async () => {
    const { service, db } = armar();
    await service.productosZona('emp', undefined, ['c1'], 'ses', 'coca', 0, 50, ['m1'], undefined, { usuarioId: 'usr' });
    expect(db.productos.findMany.mock.calls[0][0].where).toMatchObject({ empresa_id: 'emp', deleted: false, active: true, maneja_inventario: true, categoria_id: { in: ['c1'] }, marca_id: { in: ['m1'] } });
    expect(db.productos.findMany.mock.calls[0][0].where.OR).toHaveLength(2);
  });
});

describe('zonasAplicadas', () => {
  it('suma ids y nombres de categorías y marcas', async () => {
    const { service, db } = armar();
    db.inventario_zonas_aplicadas.findMany.mockResolvedValue([
      { id: 'z', deposito_id: 'dep-a', categoria_id: null, aplicada_at: new Date(), aplicada_por_usuario_id: null, total_productos: 3, contados: 1, mantener_stock_no_contados: true, categoria_ids: ['c1', 'c2'], marca_ids: ['m1'], deposito: { id: 'dep-a', descripcion: 'A' }, categoria: null },
    ]);
    db.categorias.findMany.mockResolvedValue([{ id: 'c1', descripcion: 'Uno' }, { id: 'c2', descripcion: 'Dos' }]);
    db.marcas.findMany.mockResolvedValue([{ id: 'm1', descripcion: 'Marca' }]);
    const [z] = await service.zonasAplicadas('ses', 'emp', 'usr');
    expect(z).toMatchObject({ categoria_ids: ['c1', 'c2'], marca_ids: ['m1'], categorias: ['Uno', 'Dos'], marcas: ['Marca'], mantener_stock_no_contados: true });
  });
});
