import { alcanceSucursalUsuario } from '../utils/alcance-sucursal';
import { monedaBaseOpcional } from '../utils/montos-moneda';
import { tieneAlgunPrivilegio } from '../auth/guards/algun-privilegio.guard';
import { submoduloHabilitado } from '../auth/guards/submodulo.guard';
import { TesoreriaService } from './tesoreria.service';

/**
 * Carril C T2: sesiones y arqueos de caja dentro del alcance de sucursal del usuario.
 * Criterio: la sucursal de la sesión (`sesiones_caja.sucursal_id`; si es nula, la de su caja) tiene que estar en el
 * alcance; la sesión propia (la abrió o la cerró el usuario) se ve siempre. Fuera de alcance por id → 403
 * SUCURSAL_FUERA_DE_ALCANCE; de otra empresa sigue 404.
 */

jest.mock('../utils/alcance-sucursal', () => ({ ...jest.requireActual('../utils/alcance-sucursal'), alcanceSucursalUsuario: jest.fn() }));
jest.mock('../utils/montos-moneda', () => ({ ...jest.requireActual('../utils/montos-moneda'), monedaBaseOpcional: jest.fn() }));
jest.mock('../auth/guards/submodulo.guard', () => ({ ...jest.requireActual('../auth/guards/submodulo.guard'), submoduloHabilitado: jest.fn() }));
jest.mock('../auth/guards/algun-privilegio.guard', () => ({ ...jest.requireActual('../auth/guards/algun-privilegio.guard'), tieneAlgunPrivilegio: jest.fn() }));

const alcance = alcanceSucursalUsuario as jest.Mock;
const monedaBase = monedaBaseOpcional as jest.Mock;

const EMP = 'emp-1';
const OTRA_EMP = 'emp-2';
const YO = 'u-restringido';
const SUC_MIA = 'suc-mia';
const SUC_AJENA = 'suc-ajena';
const RESTRINGIDO = { sucursalIds: [SUC_MIA], puntosEstablecimiento: ['001'], depositoIds: [] };

const sesion = (id: string, over: Record<string, unknown> = {}) => ({
  id,
  empresa_id: EMP,
  caja_id: `caja-${id}`,
  sucursal_id: null as string | null,
  user_id: 'otro',
  usuario_cierre_id: null as string | null,
  cajas: { id: `caja-${id}`, sucursal_id: null as string | null },
  ...over,
});

const SESIONES = [
  sesion('s-mia', { sucursal_id: SUC_MIA, cajas: { id: 'caja-s-mia', sucursal_id: SUC_MIA } }),
  sesion('s-ajena', { sucursal_id: SUC_AJENA, cajas: { id: 'caja-s-ajena', sucursal_id: SUC_AJENA } }),
  // Sin sucursal en la sesión: manda la de la caja.
  sesion('s-caja-mia', { cajas: { id: 'caja-s-caja-mia', sucursal_id: SUC_MIA } }),
  sesion('s-caja-ajena', { cajas: { id: 'caja-s-caja-ajena', sucursal_id: SUC_AJENA } }),
  // La sucursal de la sesión manda sobre la de la caja (1 de 356 sesiones locales difiere).
  sesion('s-difiere', { sucursal_id: SUC_AJENA, cajas: { id: 'caja-s-difiere', sucursal_id: SUC_MIA } }),
  // Sin sucursal ni en la sesión ni en la caja: oculta para el restringido.
  sesion('s-sin-sucursal'),
  // Propias en una sucursal que ya no está en su alcance.
  sesion('s-abri-yo', { sucursal_id: SUC_AJENA, user_id: YO, cajas: { id: 'caja-s-abri-yo', sucursal_id: SUC_AJENA } }),
  sesion('s-cerre-yo', { sucursal_id: SUC_AJENA, usuario_cierre_id: YO, cajas: { id: 'caja-s-cerre-yo', sucursal_id: SUC_AJENA } }),
  sesion('s-otra-emp', { empresa_id: OTRA_EMP, sucursal_id: SUC_MIA, cajas: { id: 'caja-s-otra-emp', sucursal_id: SUC_MIA } }),
];
const VISIBLES = ['s-mia', 's-caja-mia', 's-abri-yo', 's-cerre-yo'];

const arqueo = (id: string, ses: (typeof SESIONES)[number] | null, cajaSucursal: string | null = null) => ({
  id,
  empresa_id: ses?.empresa_id ?? EMP,
  sesion_id: ses?.id ?? null,
  caja_id: ses?.caja_id ?? `caja-${id}`,
  sesiones_caja: ses,
  cajas: ses ? ses.cajas : { id: `caja-${id}`, sucursal_id: cajaSucursal },
});
const ARQUEOS = [
  ...SESIONES.map((s) => arqueo(`a-${s.id}`, s)),
  // Arqueos sin sesión: manda la caja.
  arqueo('a-suelto-mio', null, SUC_MIA),
  arqueo('a-suelto-ajeno', null, SUC_AJENA),
];

/** Evalúa el subconjunto de `where` de Prisma que usan estas consultas (AND, OR, igualdad, in, null, relaciones). */
function cumple(fila: any, where: any): boolean {
  if (!where) return true;
  return Object.entries(where).every(([k, v]: [string, any]) => {
    if (k === 'AND') return (v as any[]).every((w) => cumple(fila, w));
    if (k === 'OR') return (v as any[]).some((w) => cumple(fila, w));
    const valor = fila?.[k];
    if (v === null) return valor === null || valor === undefined;
    if (typeof v !== 'object') return valor === v;
    if ('in' in v) return (v.in as unknown[]).includes(valor);
    if ('is' in v) return valor ? cumple(valor, v.is) : v.is === null;
    if ('not' in v) return valor !== v.not;
    return valor ? cumple(valor, v) : false;
  });
}

function tabla(filas: any[]) {
  return {
    findFirst: jest.fn(({ where }: any) => Promise.resolve(filas.find((f) => cumple(f, where)) ?? null)),
    findMany: jest.fn(({ where, skip = 0, take }: any) => {
      const r = filas.filter((f) => cumple(f, where));
      return Promise.resolve(take === undefined ? r.slice(skip) : r.slice(skip, skip + take));
    }),
    count: jest.fn(({ where }: any) => Promise.resolve(filas.filter((f) => cumple(f, where)).length)),
  };
}

function armar() {
  const service: any = Object.create(TesoreriaService.prototype);
  service.logger = { log: jest.fn(), warn: jest.fn(), error: jest.fn() };
  service.prisma = {
    // Ventas por condición de la sesión (informativo): sin facturas ligadas.
    $queryRaw: jest.fn().mockResolvedValue([]),
    sesiones_caja: tabla(SESIONES),
    arqueo_cajas: tabla(ARQUEOS),
    sesion_caja_documentos: { findMany: jest.fn().mockResolvedValue([{ id: 'doc-1' }]) },
    empresas_sucursales: { findFirst: jest.fn().mockResolvedValue({ id: SUC_MIA }) },
  };
  return service;
}

const errorDe = async (p: Promise<unknown>) => {
  try {
    await p;
    return undefined;
  } catch (e: any) {
    return { status: e.getStatus?.() ?? 500, ...(e.getResponse?.() ?? {}) } as Record<string, any>;
  }
};
const FUERA = { status: 403, codigo: 'SUCURSAL_FUERA_DE_ALCANCE' };

beforeEach(() => {
  alcance.mockReset();
  alcance.mockImplementation((_p: unknown, usuarioId?: string) => Promise.resolve(usuarioId === YO ? RESTRINGIDO : null));
  monedaBase.mockReset();
  monedaBase.mockResolvedValue({ id: 'm-pyg', codigo: 'PYG' });
  (submoduloHabilitado as jest.Mock).mockResolvedValue({ habilitado: true, fechaFinPrueba: null });
  (tieneAlgunPrivilegio as jest.Mock).mockResolvedValue(true);
});

describe('(a) historial de sesiones', () => {
  it('restringido: solo las de su alcance (sesión, o su caja si la sesión no tiene) y las propias', async () => {
    const r = await armar().getSesionesHistorial(EMP, 1, 100, undefined, YO);
    expect(r.items.map((s: any) => s.id).sort()).toEqual([...VISIBLES].sort());
    expect(r.total).toBe(VISIBLES.length);
  });

  it('restringido con caja_id ajena → vacío', async () => {
    const r = await armar().getSesionesHistorial(EMP, 1, 100, 'caja-s-ajena', YO);
    expect(r.items).toEqual([]);
    expect(r.total).toBe(0);
  });

  it('restringido con caja_id de su sucursal → esa', async () => {
    const r = await armar().getSesionesHistorial(EMP, 1, 100, 'caja-s-mia', YO);
    expect(r.items.map((s: any) => s.id)).toEqual(['s-mia']);
  });

  it('(e) alcance total: todas las de la empresa, ninguna de otra', async () => {
    const r = await armar().getSesionesHistorial(EMP, 1, 100, undefined, 'u-admin');
    expect(r.total).toBe(SESIONES.filter((s) => s.empresa_id === EMP).length);
  });

  it('(e) llamador sin usuario: como hoy', async () => {
    const r = await armar().getSesionesHistorial(EMP, 1, 100);
    expect(r.total).toBe(SESIONES.filter((s) => s.empresa_id === EMP).length);
  });
});

describe('(b) detalle de sesión', () => {
  it.each(['s-ajena', 's-caja-ajena', 's-difiere', 's-sin-sucursal'])('restringido, %s → 403', async (id) => {
    expect(await errorDe(armar().getSesionDetalle(id, EMP, YO))).toMatchObject(FUERA);
  });

  it.each(VISIBLES)('(d) restringido, %s → se ve', async (id) => {
    await expect(armar().getSesionDetalle(id, EMP, YO)).resolves.toMatchObject({ id });
  });

  it('(e) otra empresa → 404 (para restringido y admin)', async () => {
    expect(await errorDe(armar().getSesionDetalle('s-otra-emp', EMP, YO))).toMatchObject({ status: 404 });
    expect(await errorDe(armar().getSesionDetalle('s-otra-emp', EMP, 'u-admin'))).toMatchObject({ status: 404 });
  });

  it('(e) alcance total ve la ajena', async () => {
    await expect(armar().getSesionDetalle('s-ajena', EMP, 'u-admin')).resolves.toMatchObject({ id: 's-ajena' });
  });
});

describe('(c) arqueos', () => {
  it.each(['a-s-ajena', 'a-s-caja-ajena', 'a-s-difiere', 'a-s-sin-sucursal', 'a-suelto-ajeno'])('detalle restringido, %s → 403', async (id) => {
    expect(await errorDe(armar().getArqueoDetalle(id, EMP, YO))).toMatchObject(FUERA);
  });

  it.each(['a-s-mia', 'a-s-caja-mia', 'a-s-abri-yo', 'a-s-cerre-yo', 'a-suelto-mio'])('detalle restringido, %s → se ve', async (id) => {
    await expect(armar().getArqueoDetalle(id, EMP, YO)).resolves.toMatchObject({ id });
  });

  it('detalle de otra empresa → 404', async () => {
    expect(await errorDe(armar().getArqueoDetalle('a-s-otra-emp', EMP, YO))).toMatchObject({ status: 404 });
  });

  it('listado restringido: los de sesiones visibles y los sueltos de su caja', async () => {
    const r = await armar().getArqueos(EMP, 1, 100, undefined, YO);
    expect(r.items.map((a: any) => a.id).sort()).toEqual([...VISIBLES.map((id) => `a-${id}`), 'a-suelto-mio'].sort());
    expect(r.total).toBe(VISIBLES.length + 1);
  });

  it('listado restringido con caja_id ajena → vacío', async () => {
    const r = await armar().getArqueos(EMP, 1, 100, 'caja-s-ajena', YO);
    expect(r.total).toBe(0);
  });

  it('(e) listado con alcance total o sin usuario: todos los de la empresa', async () => {
    const deEmp = ARQUEOS.filter((a) => a.empresa_id === EMP).length;
    expect((await armar().getArqueos(EMP, 1, 100, undefined, 'u-admin')).total).toBe(deEmp);
    expect((await armar().getArqueos(EMP, 1, 100)).total).toBe(deEmp);
  });
});

describe('PDF de arqueo y documentos de la sesión', () => {
  it('PDF de sesión: restringido con ARQUEAR, ajena → 403 de alcance', async () => {
    expect(await errorDe(armar().exigirPuedeVerPdfSesion('s-ajena', EMP, YO))).toMatchObject(FUERA);
  });

  it('PDF de sesión: restringido sin ARQUEAR, propia en sucursal ajena (cierre del POS) → pasa', async () => {
    (tieneAlgunPrivilegio as jest.Mock).mockResolvedValue(false);
    await expect(armar().exigirPuedeVerPdfSesion('s-cerre-yo', EMP, YO)).resolves.toBeUndefined();
  });

  it('PDF de sesión: restringido, de su sucursal → pasa', async () => {
    await expect(armar().exigirPuedeVerPdfSesion('s-mia', EMP, YO)).resolves.toBeUndefined();
  });

  it('PDF de sesión: alcance total, ajena → pasa', async () => {
    await expect(armar().exigirPuedeVerPdfSesion('s-ajena', EMP, 'u-admin')).resolves.toBeUndefined();
  });

  it('PDF de un arqueo: restringido, ajeno → 403 antes de generar', async () => {
    const service = armar();
    service.generarPdfArqueoSesion = jest.fn();
    expect(await errorDe(service.generarPdfArqueo('a4c00000-0000-4000-8000-000000000001', EMP, 'a4', YO))).toMatchObject({ status: 404 });
    service.prisma.arqueo_cajas.findFirst = jest.fn().mockResolvedValue({ sesion_id: 's-ajena', cajas: { sucursal_id: SUC_AJENA } });
    expect(await errorDe(service.generarPdfArqueo('a4c00000-0000-4000-8000-000000000001', EMP, 'a4', YO))).toMatchObject(FUERA);
    expect(service.generarPdfArqueoSesion).not.toHaveBeenCalled();
  });

  it('PDF de un arqueo: restringido, propio → genera', async () => {
    const service = armar();
    service.generarPdfArqueoSesion = jest.fn().mockResolvedValue({ pdfBuffer: Buffer.from(''), fileName: 'x.pdf' });
    service.prisma.arqueo_cajas.findFirst = jest.fn().mockResolvedValue({ sesion_id: 's-abri-yo', cajas: { sucursal_id: SUC_AJENA } });
    await service.generarPdfArqueo('a4c00000-0000-4000-8000-000000000001', EMP, 'a4', YO);
    expect(service.generarPdfArqueoSesion).toHaveBeenCalledWith('s-abri-yo', EMP, 'a4', 'a4c00000-0000-4000-8000-000000000001');
  });

  it('documentos: restringido, ajena → 403; propia → lista', async () => {
    expect(await errorDe(armar().getDocumentosSesion('s-ajena', EMP, YO))).toMatchObject(FUERA);
    await expect(armar().getDocumentosSesion('s-abri-yo', EMP, YO)).resolves.toEqual([{ id: 'doc-1' }]);
  });

  it('documentos: otra empresa → 404', async () => {
    expect(await errorDe(armar().getDocumentosSesion('s-otra-emp', EMP, YO))).toMatchObject({ status: 404 });
  });
});

describe('Ronda 1: escrituras sobre la sesión (arquear, asignar documentos)', () => {
  // Las sesiones del fixture están todas «abiertas» para estas dos escrituras.
  const abiertas = () => {
    const service = armar();
    service.prisma.sesiones_caja = tabla(SESIONES.map((s) => ({ ...s, estado: 'ABIERTA' })));
    service.prisma.sesion_caja_documentos = {
      updateMany: jest.fn().mockResolvedValue({ count: 0 }),
      createMany: jest.fn().mockResolvedValue({ count: 1 }),
    };
    return service;
  };
  const DOCS = [{ tipo_documento_id: 'td-1' }];

  it.each(['s-ajena', 's-caja-ajena', 's-difiere', 's-sin-sucursal'])('arquear, restringido, %s → 403 sin calcular nada', async (id) => {
    const service = abiertas();
    service.obtenerPosConfig = jest.fn();
    expect(await errorDe(service.crearArqueo(id, { arqueo_detalle: [] }, EMP, YO))).toMatchObject(FUERA);
    expect(service.obtenerPosConfig).not.toHaveBeenCalled();
  });

  it.each(['s-mia', 's-caja-mia', 's-abri-yo'])('arquear, restringido, %s → no corta por alcance', async (id) => {
    const service = abiertas();
    // Corta justo después del alcance: llegar a leer la config del POS es haber pasado el chequeo.
    service.obtenerPosConfig = jest.fn().mockRejectedValue(new Error('pasó el alcance'));
    expect(await errorDe(service.crearArqueo(id, { arqueo_detalle: [] }, EMP, YO))).toMatchObject({ status: 500 });
    expect(service.obtenerPosConfig).toHaveBeenCalled();
  });

  it('arquear, alcance total, ajena → no corta por alcance', async () => {
    const service = abiertas();
    service.obtenerPosConfig = jest.fn().mockRejectedValue(new Error('pasó el alcance'));
    await errorDe(service.crearArqueo('s-ajena', { arqueo_detalle: [] }, EMP, 'u-admin'));
    expect(service.obtenerPosConfig).toHaveBeenCalled();
  });

  it('arquear, otra empresa → 404', async () => {
    expect(await errorDe(abiertas().crearArqueo('s-otra-emp', { arqueo_detalle: [] }, EMP, YO))).toMatchObject({ status: 404 });
  });

  it('asignar documentos: restringido ajena → 403 sin escribir; propia y de su sucursal → asigna', async () => {
    const service = abiertas();
    expect(await errorDe(service.asignarDocumentosSesion('s-ajena', DOCS, EMP, YO))).toMatchObject(FUERA);
    expect(service.prisma.sesion_caja_documentos.updateMany).not.toHaveBeenCalled();
    await expect(service.asignarDocumentosSesion('s-cerre-yo', DOCS, EMP, YO)).resolves.toMatchObject({ count: 1 });
    await expect(service.asignarDocumentosSesion('s-mia', DOCS, EMP, YO)).resolves.toMatchObject({ count: 1 });
  });

  it('asignar documentos: alcance total ajena → asigna; otra empresa → 404', async () => {
    await expect(abiertas().asignarDocumentosSesion('s-ajena', DOCS, EMP, 'u-admin')).resolves.toMatchObject({ count: 1 });
    expect(await errorDe(abiertas().asignarDocumentosSesion('s-otra-emp', DOCS, EMP, YO))).toMatchObject({ status: 404 });
  });

  it('el controlador pasa user.id a asignar documentos', async () => {
    const { TesoreriaController } = jest.requireActual('./tesoreria.controller');
    const service = abiertas();
    const espia = jest.spyOn(service, 'asignarDocumentosSesion').mockResolvedValue({} as never);
    await new TesoreriaController(service).asignarDocumentos('s-1', DOCS, { id: YO, empresa_id: EMP });
    expect(espia).toHaveBeenCalledWith('s-1', DOCS, EMP, YO);
  });
});

describe('(f) moneda base en los detalles', () => {
  it('PYG en sesión y arqueo', async () => {
    expect((await armar().getSesionDetalle('s-mia', EMP, YO)).moneda_base).toEqual({ id: 'm-pyg', codigo: 'PYG' });
    expect((await armar().getArqueoDetalle('a-s-mia', EMP, YO)).moneda_base).toEqual({ id: 'm-pyg', codigo: 'PYG' });
  });

  it('null si la empresa no tiene base', async () => {
    monedaBase.mockResolvedValue(null);
    expect((await armar().getSesionDetalle('s-mia', EMP, YO)).moneda_base).toBeNull();
    expect((await armar().getArqueoDetalle('a-s-mia', EMP, YO)).moneda_base).toBeNull();
  });
});

describe('controlador pasa user.id', () => {
  const { TesoreriaController } = jest.requireActual('./tesoreria.controller');
  const USER = { id: YO, empresa_id: EMP };

  it('historial, detalle de sesión, arqueos, detalle de arqueo y documentos', async () => {
    const service = armar();
    const espias = ['getSesionesHistorial', 'getSesionDetalle', 'getArqueos', 'getArqueoDetalle', 'getDocumentosSesion'].map((m) =>
      jest.spyOn(service, m).mockResolvedValue({} as never),
    );
    const c = new TesoreriaController(service);
    await c.getSesionesHistorial(USER, '1', '20', 'caja-x');
    await c.getSesionDetalle('s-1', USER);
    await c.getArqueos(USER, '1', '20', 'caja-x');
    await c.getArqueoDetalle('a-1', USER);
    await c.getDocumentosSesion('s-1', USER);
    expect(espias[0]).toHaveBeenCalledWith(EMP, 1, 20, 'caja-x', YO);
    expect(espias[1]).toHaveBeenCalledWith('s-1', EMP, YO);
    expect(espias[2]).toHaveBeenCalledWith(EMP, 1, 20, 'caja-x', YO);
    expect(espias[3]).toHaveBeenCalledWith('a-1', EMP, YO);
    expect(espias[4]).toHaveBeenCalledWith('s-1', EMP, YO);
  });

  it('PDF de un arqueo', async () => {
    const service = armar();
    const espia = jest.spyOn(service, 'generarPdfArqueo').mockResolvedValue({ pdfBuffer: Buffer.from(''), fileName: 'x.pdf' } as never);
    await new TesoreriaController(service).getArqueoPdf('a-1', 'a4', USER, { writeHead: jest.fn(), end: jest.fn() });
    expect(espia).toHaveBeenCalledWith('a-1', EMP, 'a4', YO);
  });
});

describe('Prueba real C: movimientos de caja de la sesión propia', () => {
  const mov = (id: string, ses: (typeof SESIONES)[number]) => ({ id, empresa_id: ses.empresa_id, sesion_id: ses.id, sesiones_caja: ses, monto: 1 });
  const MOVS = SESIONES.map((s) => mov(`m-${s.id}`, s));

  function conMovimientos() {
    const service = armar();
    service.prisma.movimiento_cajas = tabla(MOVS);
    service.enriquecerMovimientosConMedio = jest.fn((_e: string, items: unknown[]) => Promise.resolve(items));
    service.referenciasLegibles = jest.fn().mockResolvedValue(new Map());
    service.totalesMovimientos = jest.fn().mockResolvedValue(null);
    service.totalesPorMedio = jest.fn().mockResolvedValue([]);
    return service;
  }
  const ids = (r: any) => r.items.map((i: any) => i.id);

  it('restringido con sesion_id de su sesión propia en otra sucursal (abrió o cerró) → sus movimientos', async () => {
    expect(ids(await conMovimientos().getMovimientos(EMP, { sesion_id: 's-abri-yo', usuarioId: YO }))).toEqual(['m-s-abri-yo']);
    expect(ids(await conMovimientos().getMovimientos(EMP, { sesion_id: 's-cerre-yo', usuarioId: YO }))).toEqual(['m-s-cerre-yo']);
  });

  it('restringido con sesion_id ajena de otra sucursal → nada (no se abre)', async () => {
    expect(ids(await conMovimientos().getMovimientos(EMP, { sesion_id: 's-ajena', usuarioId: YO }))).toEqual([]);
  });

  it('sesión propia de otra empresa → nada', async () => {
    const otra = sesion('s-propia-otra-emp', { empresa_id: OTRA_EMP, user_id: YO, cajas: { id: 'c', sucursal_id: SUC_AJENA } });
    const service = conMovimientos();
    service.prisma.sesiones_caja = tabla([...SESIONES, otra]);
    service.prisma.movimiento_cajas = tabla([...MOVS, mov('m-otra', otra)]);
    expect(ids(await service.getMovimientos(EMP, { sesion_id: 's-propia-otra-emp', usuarioId: YO }))).toEqual([]);
  });

  it('la sucursal es la de la sesión, no la de su caja (caso real dafd032b): restringido a la de la caja NO ve, a la de la sesión SÍ', async () => {
    // s-difiere: sesión en SUC_AJENA, caja en SUC_MIA.
    expect(ids(await conMovimientos().getMovimientos(EMP, { sesion_id: 's-difiere', usuarioId: YO }))).toEqual([]);
    expect(ids(await conMovimientos().getMovimientos(EMP, { usuarioId: YO }))).not.toContain('m-s-difiere');
    const OTRO = 'u-de-la-ajena';
    alcance.mockImplementation((_p: unknown, u?: string) =>
      Promise.resolve(u === YO ? RESTRINGIDO : u === OTRO ? { ...RESTRINGIDO, sucursalIds: [SUC_AJENA] } : null),
    );
    expect(ids(await conMovimientos().getMovimientos(EMP, { sesion_id: 's-difiere', usuarioId: OTRO }))).toEqual(['m-s-difiere']);
    expect(ids(await conMovimientos().getMovimientos(EMP, { usuarioId: OTRO }))).toContain('m-s-difiere');
  });

  it('restringido sin sesion_id: sesiones de su alcance (por sesión o por caja si la sesión no tiene) y las propias', async () => {
    expect(ids(await conMovimientos().getMovimientos(EMP, { usuarioId: YO })).sort()).toEqual(VISIBLES.map((v) => `m-${v}`).sort());
  });

  it('sucursal_id pedida (alcance total): por la sucursal de la sesión o, si es nula, la de su caja', async () => {
    const r = ids(await conMovimientos().getMovimientos(EMP, { sucursal_id: SUC_AJENA, usuarioId: 'u-admin' })).sort();
    expect(r).toEqual(['m-s-abri-yo', 'm-s-ajena', 'm-s-caja-ajena', 'm-s-cerre-yo', 'm-s-difiere']);
  });

  it('sesión propia con sucursal_id ajena explícita → 403 igual', async () => {
    const service = conMovimientos();
    service.prisma.empresas_sucursales.findFirst.mockResolvedValue({ id: SUC_AJENA });
    expect(await errorDe(service.getMovimientos(EMP, { sesion_id: 's-abri-yo', sucursal_id: SUC_AJENA, usuarioId: YO }))).toMatchObject(FUERA);
  });
});
