import { Prisma } from '@prisma/client';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { PagosProveedorService } from './pagos-proveedor.service';
import { cumple, Fila } from './where-en-memoria.testutil';

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

/**
 * Task 9 (plan 2026-10-28-orden-pago-cxp): lecturas de Cuentas a pagar (`findCuentasPagar` y su dashboard).
 *
 * La base es en memoria y evalúa el `where` de Prisma sobre las cuotas (ver `where-en-memoria.testutil.ts`): los
 * tests prueban qué cuotas salen y qué suma cada KPI, no la forma del objeto.
 *
 * El reloj está a las 22:30 del 05/10 en Paraguay (01:30 UTC del 06/10): hoy es el 05/10, así que la cuota que vence
 * el 05/10 todavía no está vencida y la del 04/10 sí.
 */

const AHORA = new Date('2026-10-06T01:30:00.000Z');
const dia = (ymd: string) => new Date(`${ymd}T00:00:00.000Z`);

const PYG = { id: 'mon-pyg', codigo: 'PYG', descripcion: 'Guaraní', simbolo: 'Gs.' };
const USD = { id: 'mon-usd', codigo: 'USD', descripcion: 'Dólar', simbolo: 'US$' };
const PROVEEDORES: Record<string, Fila> = {
  'prov-1': { id: 'prov-1', personas: { razon_social: 'ACME S.A.', ruc: '80000001', dv: '1' } },
  'prov-2': { id: 'prov-2', personas: { razon_social: 'Beta SRL', ruc: '80000002', dv: '2' } },
};
const GASTOS = [
  {
    id: 'g-1',
    empresa_id: 'emp-1',
    activo: true,
    sucursal_id: 's-1',
    establecimiento: '2',
    punto_expedicion: '1',
    numero_factura: '77',
    fecha_emision: dia('2026-09-20'),
    total: 150.5,
    ruc: null,
    descripcion: 'Flete',
  },
  {
    id: 'g-2',
    empresa_id: 'emp-1',
    activo: true,
    sucursal_id: 's-2',
    establecimiento: '2',
    punto_expedicion: '1',
    numero_factura: '78',
    fecha_emision: dia('2026-09-21'),
    total: 75,
    ruc: null,
    descripcion: 'Viático',
  },
  // Gasto cargado sin sucursal (en DOBA son todos): su deuda es de la empresa, no de una sucursal.
  {
    id: 'g-3',
    empresa_id: 'emp-1',
    activo: true,
    sucursal_id: null,
    establecimiento: '2',
    punto_expedicion: '1',
    numero_factura: '79',
    fecha_emision: dia('2026-09-22'),
    total: 90,
    ruc: null,
    descripcion: 'Honorarios',
  },
];

/** Una OP de la cuota (solo lo que mira `ordenes-abiertas.ts`). */
const enOp = (cuotaId: string, estado: string, over: Fila = {}) => ({
  id: `d-${cuotaId}-${estado}`,
  cuenta_pagar_id: cuotaId,
  orden_pago_id: `op-${cuotaId}`,
  monto: 1,
  created_at: dia('2026-10-01'),
  orden_pago_proveedor_cab: {
    id: `op-${cuotaId}-${estado}`,
    empresa_id: 'emp-1',
    activo: true,
    anulado: false,
    estado,
    numero_orden_pago: `001-001-${cuotaId}`,
    fecha_pago: dia('2026-10-03'),
    ...over,
  },
});

const cuota = (id: string, over: Fila = {}): Fila => {
  const base: Fila = {
    id,
    empresa_id: 'emp-1',
    activo: true,
    estado: 'pendiente',
    proveedor_id: 'prov-1',
    moneda_id: PYG.id,
    numero_cuota: 1,
    total_cuotas: 1,
    fecha_emision: dia('2026-09-01'),
    fecha_vencimiento: dia('2026-10-20'),
    monto_original: 1000,
    monto_pagado: 0,
    saldo_pendiente: 1000,
    fecha_pago_programada: null,
    compra_id: `c-${id}`,
    origen_tipo: 'compra',
    origen_id: `c-${id}`,
    sucursal: 's-1',
    orden_pago_proveedor_det: [],
    created_at: dia('2026-09-01'),
    ...over,
  };
  base.proveedores = PROVEEDORES[base.proveedor_id];
  base.moneda = base.moneda_id === USD.id ? USD : PYG;
  base.compra_cab =
    base.origen_tipo === 'compra'
      ? {
          id: base.compra_id,
          sucursal_id: base.sucursal,
          establecimiento: '1',
          punto_expedicion: '1',
          numero_factura: id.replace(/\D/g, '') || '1',
          fecha_emision: dia('2026-09-01'),
          total: 1000,
          estado: 'registrada',
          anulado: false,
        }
      : null;
  delete base.sucursal;
  return base;
};

/**
 * Una cuota de cada caso:
 * - PYG: pendiente que vence hoy (en una OP en borrador), parcial (en una OP pagada: no cuenta), vencida con el
 *   `estado` guardado viejo (`pendiente`, en una OP rechazada: cuenta) y de otra sucursal, pagada, anulada;
 * - USD: vencida de un gasto de la sucursal 1 (en una OP anulada: no cuenta) y parcial de un gasto de la sucursal 2.
 */
const CUOTAS = () => [
  cuota('cxp-1', {
    fecha_vencimiento: dia('2026-10-05'),
    fecha_pago_programada: dia('2026-10-08'),
    orden_pago_proveedor_det: [enOp('cxp-1', 'BORRADOR')],
  }),
  cuota('cxp-2', {
    estado: 'parcial',
    monto_pagado: 600,
    saldo_pendiente: 400,
    orden_pago_proveedor_det: [enOp('cxp-2', 'PAGADO')],
  }),
  cuota('cxp-3', {
    proveedor_id: 'prov-2',
    fecha_vencimiento: dia('2026-10-04'),
    saldo_pendiente: 500,
    sucursal: 's-2',
    orden_pago_proveedor_det: [enOp('cxp-3', 'RECHAZADA')],
  }),
  cuota('cxp-4', { estado: 'pagada', monto_pagado: 2000, saldo_pendiente: 0 }),
  cuota('cxp-5', { estado: 'anulada', activo: false, saldo_pendiente: 300 }),
  cuota('cxp-6', {
    moneda_id: USD.id,
    origen_tipo: 'gasto',
    origen_id: 'g-1',
    compra_id: null,
    fecha_vencimiento: dia('2026-10-01'),
    monto_original: 150.5,
    saldo_pendiente: 150.5,
    orden_pago_proveedor_det: [enOp('cxp-6', 'BORRADOR', { anulado: true })],
  }),
  cuota('cxp-7', {
    moneda_id: USD.id,
    proveedor_id: 'prov-2',
    origen_tipo: 'gasto',
    origen_id: 'g-2',
    compra_id: null,
    estado: 'parcial',
    fecha_vencimiento: dia('2026-11-01'),
    monto_original: 75,
    monto_pagado: 25,
    saldo_pendiente: 50,
  }),
];

const suma = (filas: Fila[], campo: string) => filas.reduce((acc, f) => acc + Number(f[campo] ?? 0), 0);
const sumas = (filas: Fila[], campos: Fila = {}) =>
  Object.fromEntries(Object.keys(campos).map((c) => [c, filas.length ? new Prisma.Decimal(suma(filas, c)) : null]));

const armar = (cuotas: Fila[] = CUOTAS()) => {
  const filtrar = (where?: Fila) => cuotas.filter((f) => cumple(f, where));
  const prisma: any = {
    cuentas_pagar: {
      findMany: jest.fn(async ({ where, skip = 0, take }: Fila = {}) => {
        const filas = filtrar(where);
        return take ? filas.slice(skip, skip + take) : filas;
      }),
      count: jest.fn(async ({ where }: Fila) => filtrar(where).length),
      aggregate: jest.fn(async ({ where, _sum }: Fila) => ({ _sum: sumas(filtrar(where), _sum) })),
      groupBy: jest.fn(async ({ by, where, _sum }: Fila) => {
        const grupos = new Map<string, Fila[]>();
        for (const f of filtrar(where)) {
          const clave = JSON.stringify(by.map((k: string) => f[k] ?? null));
          grupos.set(clave, [...(grupos.get(clave) ?? []), f]);
        }
        return [...grupos].map(([clave, filas]) => ({
          ...Object.fromEntries(by.map((k: string, i: number) => [k, JSON.parse(clave)[i]])),
          _sum: sumas(filas, _sum),
        }));
      }),
    },
    orden_pago_proveedor_det: {
      findMany: jest.fn(async ({ where }: Fila) =>
        cuotas.flatMap((c) => c.orden_pago_proveedor_det).filter((d) => cumple(d, where)),
      ),
    },
    gasto_cab: { findMany: jest.fn(async ({ where }: Fila) => GASTOS.filter((g) => cumple(g, where))) },
    compra_cab: { findMany: jest.fn().mockResolvedValue([]) },
    moneda: { findMany: jest.fn(async ({ where }: Fila) => [PYG, USD].filter((m) => cumple(m, where))) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: PYG.id }) },
  };
  prisma.$transaction = jest.fn((arg: any) => (Array.isArray(arg) ? Promise.all(arg) : arg(prisma)));
  const service = new PagosProveedorService(prisma, {} as any, {} as any, {} as any);
  return { service, prisma };
};

const ids = (r: { items: Fila[] }) => r.items.map((i) => i.id).sort();

beforeEach(() => {
  jest.useFakeTimers({ now: AHORA, doNotFake: ['nextTick', 'setImmediate', 'queueMicrotask'] });
  alcanceMock.mockReset();
  alcanceMock.mockResolvedValue(null);
});
afterEach(() => jest.useRealTimers());

describe('findCuentasPagar: filtro de estado con un solo criterio', () => {
  it('estado=vencida usa hoy de Paraguay y coincide con el KPI vencidas', async () => {
    const { service } = armar();
    const r = await service.findCuentasPagar('emp-1', { estado: 'vencida', usuarioId: 'u-1' });
    // cxp-1 vence hoy (05/10 en Paraguay, aunque en UTC ya es el 06): no está vencida.
    expect(ids(r)).toEqual(['cxp-3', 'cxp-6']);
    expect(r.items.map((i: Fila) => i.estado_clave)).toEqual(['vencida', 'vencida']);
    const dash = await service.getCuentasPagarDashboard('emp-1', { usuarioId: 'u-1' });
    expect(dash.vencidas).toBe(r.total);
    expect((await service.getCuentasPagarDashboard('emp-1', { estado: 'vencida', usuarioId: 'u-1' })).cuotas).toBe(2);
  });

  it('estado=pendiente no trae parciales ni vencidas; con_saldo trae las tres', async () => {
    const { service } = armar();
    expect(ids(await service.findCuentasPagar('emp-1', { estado: 'pendiente', usuarioId: 'u-1' }))).toEqual(['cxp-1']);
    expect(ids(await service.findCuentasPagar('emp-1', { estado: 'parcial', usuarioId: 'u-1' }))).toEqual([
      'cxp-2',
      'cxp-7',
    ]);
    const conSaldo = await service.findCuentasPagar('emp-1', { estado: 'con_saldo', usuarioId: 'u-1' });
    expect(ids(conSaldo)).toEqual(['cxp-1', 'cxp-2', 'cxp-3', 'cxp-6', 'cxp-7']);
    expect(new Set(conSaldo.items.map((i: Fila) => i.estado_clave))).toEqual(
      new Set(['pendiente', 'parcial', 'vencida']),
    );
    expect(ids(await service.findCuentasPagar('emp-1', { estado: 'pagada', usuarioId: 'u-1' }))).toEqual(['cxp-4']);
  });

  it('estado=anulada trae las anuladas (activo = false incluidas)', async () => {
    const { service } = armar();
    const r = await service.findCuentasPagar('emp-1', { estado: 'anulada', usuarioId: 'u-1' });
    expect(ids(r)).toEqual(['cxp-5']);
    expect(r.items[0].estado_clave).toBe('anulada');
  });

  it('sin estado trae todas (Reportes), con estado_clave en cada fila', async () => {
    const { service } = armar();
    const r = await service.findCuentasPagar('emp-1', { usuarioId: 'u-1' });
    // Las activas, como hoy: Reportes no manda estado y su total no cambia.
    expect(ids(r)).toEqual(['cxp-1', 'cxp-2', 'cxp-3', 'cxp-4', 'cxp-6', 'cxp-7']);
    expect(Object.fromEntries(r.items.map((i: Fila) => [i.id, i.estado_clave]))).toEqual({
      'cxp-1': 'pendiente',
      'cxp-2': 'parcial',
      'cxp-3': 'vencida',
      'cxp-4': 'pagada',
      'cxp-6': 'vencida',
      'cxp-7': 'parcial',
    });
  });

  it('activo NULL cuenta como activa (como estadoCuotaPagar): sale sin estado y en su estado, no en anulada', async () => {
    const cuotas = [...CUOTAS(), cuota('cxp-8', { activo: null })];
    const { service } = armar(cuotas);
    expect(ids(await service.findCuentasPagar('emp-1', { usuarioId: 'u-1' }))).toContain('cxp-8');
    expect(ids(await service.findCuentasPagar('emp-1', { estado: 'pendiente', usuarioId: 'u-1' }))).toEqual([
      'cxp-1',
      'cxp-8',
    ]);
    expect(ids(await service.findCuentasPagar('emp-1', { estado: 'anulada', usuarioId: 'u-1' }))).toEqual(['cxp-5']);
    // el dashboard usa el mismo where: 6 activas + la NULL
    expect((await service.getCuentasPagarDashboard('emp-1', { usuarioId: 'u-1' })).cuotas).toBe(7);
  });

  it('el origen de la fila y las órdenes abiertas se leen en paralelo', async () => {
    const { service, prisma } = armar();
    let soltarGastos!: () => void;
    const gastos = prisma.gasto_cab.findMany.getMockImplementation();
    prisma.gasto_cab.findMany.mockImplementation(
      (args: Fila) => new Promise((ok) => (soltarGastos = () => ok(gastos!(args)))),
    );
    const r = service.findCuentasPagar('emp-1', { usuarioId: 'u-1' });
    // con los gastos todavía sin responder, ya se pidieron las órdenes abiertas
    await new Promise((ok) => setImmediate(ok));
    expect(prisma.orden_pago_proveedor_det.findMany).toHaveBeenCalled();
    soltarGastos();
    await expect(r).resolves.toMatchObject({ total: 6 });
  });

  it('fecha_desde / fecha_hasta son días de calendario de la columna DATE (sin desfase de zona)', async () => {
    const { service } = armar();
    const r = await service.findCuentasPagar('emp-1', {
      fecha_desde: '2026-10-05',
      fecha_hasta: '2026-10-05',
      usuarioId: 'u-1',
    });
    expect(ids(r)).toEqual(['cxp-1']);
    const hasta4 = await service.findCuentasPagar('emp-1', { fecha_hasta: '2026-10-04', usuarioId: 'u-1' });
    expect(ids(hasta4)).toEqual(['cxp-3', 'cxp-6']);
  });

  it('moneda_id, proveedor_id y origen_tipo filtran', async () => {
    const { service } = armar();
    expect(ids(await service.findCuentasPagar('emp-1', { moneda_id: USD.id, usuarioId: 'u-1' }))).toEqual([
      'cxp-6',
      'cxp-7',
    ]);
    expect(ids(await service.findCuentasPagar('emp-1', { proveedor_id: 'prov-2', usuarioId: 'u-1' }))).toEqual([
      'cxp-3',
      'cxp-7',
    ]);
    expect(ids(await service.findCuentasPagar('emp-1', { origen_tipo: 'gasto', usuarioId: 'u-1' }))).toEqual([
      'cxp-6',
      'cxp-7',
    ]);
  });
});

describe('findCuentasPagar: forma de la fila y paginado', () => {
  it('documento_ref, orden_abierta, fecha_pago_programada y moneda.codigo', async () => {
    const { service } = armar();
    const r = await service.findCuentasPagar('emp-1', { usuarioId: 'u-1' });
    const fila = (id: string) => r.items.find((i: Fila) => i.id === id);
    expect(fila('cxp-1')).toMatchObject({
      documento_ref: '001-001-0000001',
      orden_abierta: {
        orden_id: 'op-cxp-1-BORRADOR',
        numero: '001-001-cxp-1',
        estado: 'BORRADOR',
        fecha_pago: '2026-10-03',
      },
      fecha_pago_programada: dia('2026-10-08'),
      moneda: { codigo: 'PYG' },
      origen_tipo: 'compra',
    });
    expect(fila('cxp-3').orden_abierta).toMatchObject({ estado: 'RECHAZADA' });
    // Pagada o anulada no es abierta.
    expect(fila('cxp-2').orden_abierta).toBeNull();
    expect(fila('cxp-6').orden_abierta).toBeNull();
    expect(fila('cxp-6')).toMatchObject({
      documento_ref: '002-001-0000077',
      origen_tipo: 'gasto',
      moneda: { codigo: 'USD' },
    });
    expect(fila('cxp-4').fecha_pago_programada).toBeNull();
  });

  it('el tope de limit es 100 y la respuesta lo dice', async () => {
    const { service, prisma } = armar();
    const r = await service.findCuentasPagar('emp-1', { limit: '500', usuarioId: 'u-1' });
    expect(r.limit).toBe(100);
    expect(prisma.cuentas_pagar.findMany.mock.calls[0][0].take).toBe(100);
    expect(r).toMatchObject({ total: 6, page: 1, lastPage: 1 });
  });
});

describe('getCuentasPagarDashboard', () => {
  it('por_moneda con saldo, vencido y pagado de PYG y USD', async () => {
    const { service } = armar();
    const dash = await service.getCuentasPagarDashboard('emp-1', { usuarioId: 'u-1' });
    expect(dash.por_moneda).toEqual([
      // saldo: 1000 + 400 + 500; vencido: cxp-3; pagado: 600 + 2000
      { codigo: 'PYG', saldo: '1900.00', vencido: '500.00', pagado: '2600.00' },
      // saldo: 150.5 + 50; vencido: cxp-6; pagado: 25
      { codigo: 'USD', saldo: '200.50', vencido: '150.50', pagado: '25.00' },
    ]);
    expect(dash).toMatchObject({ cuotas: 6, vencidas: 2 });
  });

  it('las claves viejas del dashboard siguen con los mismos valores', async () => {
    const cuotas = CUOTAS();
    const { service } = armar(cuotas);
    // Lo que calculaba el dashboard viejo, sobre las activas (es lo que lee pages/CuentasPagar.jsx).
    const activas = cuotas.filter((c) => c.activo);
    const conSaldo = activas.filter((c) => c.saldo_pendiente > 0);
    const viejas = {
      total: activas.length,
      pendientes: conSaldo.filter((c) => ['pendiente', 'parcial', 'vencida'].includes(c.estado)).length,
      pagadas: activas.filter((c) => c.estado === 'pagada').length,
      saldo_pendiente_total: suma(conSaldo, 'saldo_pendiente'),
      monto_pagado_total: suma(activas, 'monto_pagado'),
    };
    expect(viejas).toEqual({
      total: 6,
      pendientes: 5,
      pagadas: 1,
      saldo_pendiente_total: 2100.5,
      monto_pagado_total: 2625,
    });

    const dash = await service.getCuentasPagarDashboard('emp-1', { usuarioId: 'u-1' });
    expect(dash).toMatchObject(viejas);
    expect(Object.keys(dash).sort()).toEqual(
      [
        'cuotas',
        'vencidas',
        'en_orden',
        'por_moneda',
        'total',
        'pendientes',
        'pagadas',
        'saldo_pendiente_total',
        'monto_pagado_total',
      ].sort(),
    );

    // Con las fechas de emisión que manda Reportes, las mismas cuentas sobre el período.
    const reportes = await service.getCuentasPagarDashboard('emp-1', {
      fecha_tipo: 'emision',
      fecha_desde: '2026-09-01',
      fecha_hasta: '2026-09-30',
      usuarioId: 'u-1',
    });
    expect(reportes).toMatchObject(viejas);
    const fuera = await service.getCuentasPagarDashboard('emp-1', {
      fecha_tipo: 'emision',
      fecha_desde: '2026-10-01',
      usuarioId: 'u-1',
    });
    expect(fuera).toMatchObject({
      total: 0,
      pendientes: 0,
      pagadas: 0,
      saldo_pendiente_total: 0,
      monto_pagado_total: 0,
    });
  });

  it('el dashboard respeta busqueda, estado y proveedor', async () => {
    const { service } = armar();
    const busqueda = await service.getCuentasPagarDashboard('emp-1', { busqueda: 'beta', usuarioId: 'u-1' });
    expect(busqueda.cuotas).toBe(2); // cxp-3 y cxp-7, de Beta SRL
    expect(busqueda.por_moneda.map((m: Fila) => m.codigo)).toEqual(['PYG', 'USD']);

    const conSaldoProv1 = await service.getCuentasPagarDashboard('emp-1', {
      estado: 'con_saldo',
      proveedor_id: 'prov-1',
      usuarioId: 'u-1',
    });
    expect(conSaldoProv1).toMatchObject({ cuotas: 3, vencidas: 1, total: 3 }); // cxp-1, cxp-2, cxp-6
    expect(conSaldoProv1.por_moneda).toEqual([
      { codigo: 'PYG', saldo: '1400.00', vencido: '0.00', pagado: '600.00' },
      { codigo: 'USD', saldo: '150.50', vencido: '150.50', pagado: '0.00' },
    ]);

    const usd = await service.getCuentasPagarDashboard('emp-1', { moneda_id: USD.id, usuarioId: 'u-1' });
    expect(usd.por_moneda.map((m: Fila) => m.codigo)).toEqual(['USD']);
  });

  it('en_orden cuenta las cuotas en una OP abierta', async () => {
    const { service } = armar();
    // cxp-1 (borrador) y cxp-3 (rechazada); no cxp-2 (pagada) ni cxp-6 (anulada).
    expect((await service.getCuentasPagarDashboard('emp-1', { usuarioId: 'u-1' })).en_orden).toBe(2);
    expect(
      (await service.getCuentasPagarDashboard('emp-1', { proveedor_id: 'prov-1', usuarioId: 'u-1' })).en_orden,
    ).toBe(1);
  });

  it('una moneda sin código se omite de por_moneda con un WARN', async () => {
    const { service } = armar([...CUOTAS(), cuota('cxp-9', { moneda_id: 'mon-borrada' })]);
    const warn = jest.spyOn((service as any).logger, 'warn').mockImplementation(() => undefined);
    const dash = await service.getCuentasPagarDashboard('emp-1', { usuarioId: 'u-1' });
    expect(dash.por_moneda.map((m: Fila) => m.codigo)).toEqual(['PYG', 'USD']);
    expect(warn).toHaveBeenCalledWith(expect.stringContaining('mon-borrada'));
  });
});

describe('alcance por la sucursal del documento', () => {
  it('alcance restringido: ve la cuota de su factura y la de su gasto, no la de otra sucursal', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['s-1'], puntosEstablecimiento: [], depositoIds: [] });
    const { service, prisma } = armar();
    const r = await service.findCuentasPagar('emp-1', { usuarioId: 'u-1' });
    // cxp-1, cxp-2 y cxp-4 son facturas de s-1; cxp-6 es el gasto g-1 de s-1. cxp-3 (factura) y cxp-7 (gasto) son de s-2.
    expect(ids(r)).toEqual(['cxp-1', 'cxp-2', 'cxp-4', 'cxp-6']);
    expect(alcanceMock).toHaveBeenCalledWith(prisma, 'u-1', 'emp-1');

    const dash = await service.getCuentasPagarDashboard('emp-1', { usuarioId: 'u-1' });
    expect(dash).toMatchObject({ cuotas: 4, total: 4, vencidas: 1, en_orden: 1 });
    expect(dash.por_moneda).toEqual([
      { codigo: 'PYG', saldo: '1400.00', vencido: '0.00', pagado: '2600.00' },
      { codigo: 'USD', saldo: '150.50', vencido: '150.50', pagado: '0.00' },
    ]);
  });

  it('la deuda sin sucursal es de la empresa: la cuota de un gasto sin sucursal la ve cualquiera', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['s-1'], puntosEstablecimiento: [], depositoIds: [] });
    const { service } = armar([
      cuota('sin-suc', { origen_tipo: 'gasto', origen_id: 'g-3', compra_id: null }),
      cuota('de-s2', { origen_tipo: 'gasto', origen_id: 'g-2', compra_id: null }),
      cuota('sin-origen', { origen_tipo: null, origen_id: null, compra_id: null }),
    ]);
    const r = await service.findCuentasPagar('emp-1', { usuarioId: 'u-1' });
    expect([...ids(r)].sort()).toEqual(['sin-origen', 'sin-suc']);
  });

  it('sin usuario (lectura interna) o sin restricción, ve todas', async () => {
    const { service } = armar();
    expect((await service.findCuentasPagar('emp-1', {})).total).toBe(6);
    expect(alcanceMock).not.toHaveBeenCalled();
  });
});

describe('revisión final: un solo criterio de «cuota con saldo» en el formulario, el buscador y el alta', () => {
  /** Con lo que leen `getCuentasPendientes` y `proveedoresConSaldo` además de las cuotas. */
  const armarFormulario = (cuotas: Fila[]) => {
    const r = armar(cuotas);
    r.prisma.proveedores = {
      findFirst: jest.fn(({ where }: Fila) => Promise.resolve(PROVEEDORES[where.id] ?? null)),
      findMany: jest.fn(({ where }: Fila) =>
        Promise.resolve(
          Object.values(PROVEEDORES).filter((p) =>
            cuotas.some((c) => c.proveedor_id === p.id && cumple(c, where.cuentas_pagar.some)),
          ),
        ),
      ),
    };
    return r;
  };

  it('una cuota legacy con activo NULL y saldo sale en el formulario y en el buscador; una anulada en ninguno', async () => {
    const legacy = cuota('cxp-10', { activo: null, estado: 'PENDIENTE', saldo_pendiente: 700 });
    const anulada = cuota('cxp-11', { proveedor_id: 'prov-2', estado: 'anulada', saldo_pendiente: 300 });
    const { service } = armarFormulario([legacy, anulada]);

    const pendientes = await service.getCuentasPendientes('emp-1', 'prov-1', 'u-1');
    expect(pendientes.items.map((i: Fila) => i.id)).toEqual(['cxp-10']);
    const proveedores = await service.proveedoresConSaldo('emp-1', 'u-1');
    expect(proveedores.map((p) => p.id)).toEqual(['prov-1']);

    const deLaAnulada = await service.getCuentasPendientes('emp-1', 'prov-2', 'u-1');
    expect(deLaAnulada.items).toEqual([]);
  });
});
