/**
 * Buscador global: `buscarPorNumero` encuentra facturas por número con el mismo alcance que el listado de Comprobantes
 * (sucursal del usuario vía `alcanceSucursalUsuario` + `filtroFiscalPorSucursal`), sin alcance propio, y siempre de la
 * empresa pedida. El `where` se evalúa contra filas en memoria para probar el criterio, no la forma del objeto.
 */
import { FacturasService } from './facturas.service';
import { alcanceSucursalUsuario, filtroFiscalPorSucursal } from 'src/utils/alcance-sucursal';

jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn(),
  filtroFiscalPorSucursal: jest.fn(),
}));
const alcanceMock = alcanceSucursalUsuario as jest.Mock;
const filtroMock = filtroFiscalPorSucursal as jest.Mock;

type Fila = { id: string; empresa_id: string; dest: string; dpunexp: string; dnumdoc: string };
const FILAS: Fila[] = [
  { id: 'propia', empresa_id: 'emp', dest: '001', dpunexp: '002', dnumdoc: '0000123' },
  { id: 'otra-sucursal', empresa_id: 'emp', dest: '002', dpunexp: '001', dnumdoc: '0000123' },
  { id: 'otra-empresa', empresa_id: 'emp-2', dest: '001', dpunexp: '002', dnumdoc: '0000123' },
  { id: 'otro-numero', empresa_id: 'emp', dest: '001', dpunexp: '002', dnumdoc: '0000999' },
];

function cumple(where: any, fila: any): boolean {
  return Object.entries(where).every(([k, w]: [string, any]) => {
    if (k === 'AND') return [].concat(w).every((x) => cumple(x, fila));
    if (k === 'OR') return [].concat(w).some((x) => cumple(x, fila));
    if (w !== null && typeof w === 'object') {
      if ('in' in w) return w.in.includes(fila[k]);
      if ('contains' in w) return String(fila[k]).includes(w.contains);
      return cumple(w, fila[k]);
    }
    return fila[k] === w;
  });
}

function servicio() {
  const prisma: any = {
    factura_cab: { findMany: jest.fn(({ where, take }: any) => Promise.resolve(FILAS.filter((f) => cumple(where, f)).slice(0, take))) },
  };
  return { svc: new (FacturasService as any)(prisma) as FacturasService, prisma };
}

const ids = (filas: Array<{ id: string }>) => filas.map((f) => f.id).sort();

describe('FacturasService.buscarPorNumero', () => {
  beforeEach(() => {
    alcanceMock.mockReset().mockResolvedValue(null);
    filtroMock.mockReset().mockResolvedValue(null);
  });

  it('número completo: exacto, solo de la empresa', async () => {
    const { svc } = servicio();
    expect(ids(await svc.buscarPorNumero('1-2-123', 'emp', 'usr', 5))).toEqual(['propia']);
  });

  it('solo dígitos: el número de documento que los contenga', async () => {
    const { svc } = servicio();
    expect(ids(await svc.buscarPorNumero('123', 'emp', 'usr', 5))).toEqual(['otra-sucursal', 'propia']);
  });

  it('sucursal ajena fuera: aplica el alcance de sucursal del usuario como el listado', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['suc-1'] });
    filtroMock.mockResolvedValue({ dest: { in: ['001'] } });
    const { svc } = servicio();
    expect(ids(await svc.buscarPorNumero('123', 'emp', 'usr', 5))).toEqual(['propia']);
    expect(alcanceMock).toHaveBeenCalledWith(expect.anything(), 'usr', 'emp');
    expect(filtroMock).toHaveBeenCalledWith(expect.anything(), { sucursalIds: ['suc-1'] }, undefined);
  });

  it('texto que no es número: no consulta', async () => {
    const { svc, prisma } = servicio();
    expect(await svc.buscarPorNumero('juan', 'emp', 'usr', 5)).toEqual([]);
    expect(prisma.factura_cab.findMany).not.toHaveBeenCalled();
  });

  it('pide el límite y lo mínimo (sin include pesado)', async () => {
    const { svc, prisma } = servicio();
    await svc.buscarPorNumero('123', 'emp', 'usr', 5);
    const args = prisma.factura_cab.findMany.mock.calls[0][0];
    expect(args.take).toBe(5);
    expect(args.include).toBeUndefined();
    expect(Object.keys(args.select).sort()).toEqual(['clientes', 'dest', 'dfeemide', 'dnumdoc', 'dpunexp', 'factura_subtotales', 'id', 'moneda']);
  });
});
