import { NotFoundException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { hoyComoFechaPY } from 'src/lotes/hoy-py';
import { PagosProveedorService } from './pagos-proveedor.service';
import { FILTRO_CON_SALDO, whereEstadoCuota, whereEstadoOp } from './reglas-op';
import { cumple, Fila, valor } 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 8 (plan 2026-10-28-orden-pago-cxp): lecturas de OP (listado, dashboard, detalle, historial) y los endpoints
 * de lectura del formulario.
 *
 * La base es en memoria y evalúa el `where` de Prisma sobre las filas (AND/OR/NOT, `some`, `in`, `not`, rangos,
 * `contains`, con la semántica de NULL de SQL): los tests prueban qué órdenes salen, no la forma del objeto.
 */

const MEDIO_EFECTIVO = { id: 'mp-ef', codigo: 1, descripcion: 'Efectivo' };
const MEDIO_CHEQUE = { id: 'mp-ch', codigo: 2, descripcion: 'Cheque' };
const PYG = { id: 'mon-pyg', codigo: 'PYG', descripcion: 'Guaraní', simbolo: 'Gs.' };
const USD = { id: 'mon-usd', codigo: 'USD', descripcion: 'Dólar', simbolo: 'US$' };

const cuotaCompra = (id: string, numero = '123') => ({
  id,
  compra_id: `c-${id}`,
  origen_tipo: 'compra',
  origen_id: `c-${id}`,
  numero_cuota: 1,
  total_cuotas: 2,
  fecha_vencimiento: new Date('2026-10-10T00:00:00.000Z'),
  compra_cab: {
    id: `c-${id}`,
    establecimiento: '1',
    punto_expedicion: '1',
    numero_factura: numero,
    fecha_emision: new Date('2026-09-01T00:00:00.000Z'),
    total: 100000,
  },
});
const cuotaGasto = (id: string) => ({
  id,
  compra_id: null,
  origen_tipo: 'gasto',
  origen_id: 'g-1',
  numero_cuota: 1,
  total_cuotas: 1,
  fecha_vencimiento: null,
  compra_cab: null,
});
const linea = (cuota: Fila, medio: Fila = MEDIO_EFECTIVO, over: Fila = {}) => ({
  id: `d-${cuota.id}`,
  cuenta_pagar_id: cuota.id,
  medio_pago_id: medio.id,
  medio_pago: medio,
  cuenta_bancaria_id: null,
  cuenta_bancaria: null,
  cuentas_pagar: cuota,
  monto: 100000,
  ...over,
});

let n = 0;
const op = (id: string, over: Fila = {}): Fila => ({
  id,
  empresa_id: 'emp-1',
  activo: true,
  sucursal_id: 's-1',
  empresas_sucursales: { id: 's-1', descripcion: 'Casa central', punto_establecimiento: '001' },
  proveedor_id: 'prov-1',
  proveedores: { id: 'prov-1', personas: { razon_social: 'ACME S.A.', ruc: '80000001', dv: '1' } },
  usuario_id: 'u-creador',
  usuario: { nombres: 'Ana', apellidos: 'Pérez' },
  compra_id: null,
  compra_cab: null,
  origen: 'manual',
  estado: 'PAGADO',
  anulado: false,
  fecha_anulacion: null,
  motivo_anulacion: null,
  observaciones: null,
  moneda_id: PYG.id,
  moneda: PYG,
  cotizacion: 1,
  monto_total: 100000,
  numero_orden_pago: `001-001-${String(++n).padStart(7, '0')}`,
  fecha_pago: new Date('2026-10-05T00:00:00.000Z'),
  created_at: new Date('2026-10-05T13:00:00.000Z'),
  updated_at: new Date('2026-10-05T13:00:00.000Z'),
  orden_pago_proveedor_det: [linea(cuotaCompra(`cxp-${id}`))],
  ...over,
});

/** Una orden de cada caso que mira el listado y el dashboard. */
const ORDENES = () => [
  op('op-pyg'), // pagada PYG 100000
  op('op-usd', {
    moneda_id: USD.id,
    moneda: USD,
    monto_total: 150.5,
    orden_pago_proveedor_det: [linea(cuotaGasto('cxp-g'))],
  }),
  op('op-aplicada', { estado: 'APLICADO', monto_total: 50 }), // pagada (legacy)
  op('op-anulada', { anulado: true, monto_total: 999 }),
  op('op-espejo', { origen: 'compra_auto', compra_id: 'c-9', orden_pago_proveedor_det: [], monto_total: 5000 }),
  op('op-espejo-null', { origen: 'compra_auto', orden_pago_proveedor_det: [], estado: 'PENDIENTE' }),
  op('op-borrador', { estado: 'BORRADOR' }),
  op('op-aprobada', { estado: 'PENDIENTE' }),
  op('op-por-aprobar', { estado: 'PENDIENTE_APROBACION' }),
  op('op-rechazada', { estado: 'RECHAZADA' }),
  op('op-otra-sucursal', { sucursal_id: 's-2', empresas_sucursales: { id: 's-2', descripcion: 'Este' } }),
];

type Opciones = {
  ordenes?: Fila[];
  config?: Fila | null;
  sinTesoreria?: string[];
  movimientos?: Fila[];
  cheques?: Fila[];
  docs?: Fila[];
  logs?: Fila[];
  conContabilidad?: boolean;
  cuentasTes?: Fila[];
  reglas?: Fila[];
};

const armar = (o: Opciones = {}) => {
  const ordenes = o.ordenes ?? ORDENES();
  const filtrar = (filas: Fila[], where?: Fila) => filas.filter((f) => cumple(f, where));
  const ultimoPorFecha = (filas: Fila[]) => [...filas].sort((a, b) => valor(b.created_at) - valor(a.created_at));
  const prisma: any = {
    orden_pago_proveedor_cab: {
      findMany: jest.fn(async ({ where, skip = 0, take }: Fila = {}) => {
        const filas = filtrar(ordenes, where);
        return take ? filas.slice(skip, skip + take) : filas;
      }),
      findFirst: jest.fn(async ({ where }: Fila) => filtrar(ordenes, where)[0] ?? null),
      count: jest.fn(async ({ where }: Fila) => filtrar(ordenes, where).length),
      groupBy: jest.fn(async ({ where }: Fila) => {
        const porMoneda = new Map<string | null, number>();
        for (const f of filtrar(ordenes, where))
          porMoneda.set(f.moneda_id, (porMoneda.get(f.moneda_id) ?? 0) + Number(f.monto_total));
        return [...porMoneda].map(([moneda_id, suma]) => ({
          moneda_id,
          _sum: { monto_total: new Prisma.Decimal(suma) },
        }));
      }),
    },
    $queryRaw: jest.fn(async () => (o.sinTesoreria ?? []).map((id) => ({ id }))),
    config_compras: { findUnique: jest.fn().mockResolvedValue(o.config ?? {}), create: jest.fn() },
    moneda: {
      findMany: jest.fn(async ({ where }: Fila) => filtrar([PYG, USD], where)),
      findFirst: jest.fn(async ({ where }: Fila) => filtrar([PYG, USD], where)[0] ?? null),
    },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: PYG.id }) },
    empresa_medio_pago: { findMany: jest.fn().mockResolvedValue([]) },
    tes_movimientos: { findMany: jest.fn(async ({ where }: Fila) => filtrar(o.movimientos ?? [], where)) },
    tes_cheques: { findMany: jest.fn(async ({ where }: Fila) => filtrar(o.cheques ?? [], where)) },
    cont_documentos: { findMany: jest.fn(async ({ where }: Fila) => filtrar(o.docs ?? [], where)) },
    audit_logs: {
      findFirst: jest.fn(async ({ where }: Fila) => ultimoPorFecha(filtrar(o.logs ?? [], where))[0] ?? null),
      findMany: jest.fn(async ({ where }: Fila) => ultimoPorFecha(filtrar(o.logs ?? [], where))),
    },
    usuario: {
      findMany: jest.fn(async ({ where }: Fila) =>
        filtrar([{ id: 'u-jefe', nombres: 'Juan', apellidos: 'Jefe', username: 'jjefe' }], where),
      ),
    },
    gasto_cab: {
      findMany: jest.fn(async () => [
        {
          id: 'g-1',
          establecimiento: '2',
          punto_expedicion: '1',
          numero_factura: '77',
          fecha_emision: null,
          total: 150.5,
          sucursal_id: 's-1',
        },
      ]),
    },
    compra_cab: { findMany: jest.fn().mockResolvedValue([]) },
    proveedores: { findMany: jest.fn().mockResolvedValue([]) },
    cuentas_pagar: { findMany: jest.fn().mockResolvedValue([]), groupBy: jest.fn().mockResolvedValue([]) },
    tes_cuentas: {
      findMany: jest.fn(async ({ where }: Fila) => filtrar(o.cuentasTes ?? [], where)),
      findFirst: jest.fn(async ({ where }: Fila) => filtrar(o.cuentasTes ?? [], where)[0] ?? null),
    },
    tes_reglas: { findFirst: jest.fn(async ({ where }: Fila) => filtrar(o.reglas ?? [], where)[0] ?? null) },
    bancos: { findMany: jest.fn().mockResolvedValue([{ id: 'b-1', descripcion: 'Banco Itaú' }]) },
  };
  prisma.$transaction = jest.fn((arg: any) => (Array.isArray(arg) ? Promise.all(arg) : arg(prisma)));
  const contab = { tieneModuloContabilidad: jest.fn().mockResolvedValue(o.conContabilidad ?? true) };
  const service = new PagosProveedorService(prisma, contab as any, {} as any, {} as any);
  return { service, prisma };
};

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

beforeEach(() => {
  alcanceMock.mockReset();
  alcanceMock.mockResolvedValue(null);
});

describe('findAll y getDashboard: qué órdenes entran', () => {
  it('findAll y getDashboard excluyen las OP sin líneas, también con origen_tipo', async () => {
    const { service } = armar();
    const todas = await service.findAll('emp-1', { usuarioId: 'u-1' });
    expect(todas.items.map((i: Fila) => i.id)).not.toEqual(expect.arrayContaining(['op-espejo']));
    expect(ids(todas)).not.toContain('op-espejo-null');
    expect(todas.total).toBe(9);

    // origen_tipo también filtra por las líneas: no pisa la condición «con líneas».
    const deGasto = await service.findAll('emp-1', { origen_tipo: 'gasto', usuarioId: 'u-1' });
    expect(ids(deGasto)).toEqual(['op-usd']);
    const automaticas = await service.findAll('emp-1', { origen: 'compra_auto', usuarioId: 'u-1' });
    expect(automaticas.total).toBe(0);

    const dash = await service.getDashboard('emp-1', { usuarioId: 'u-1' });
    expect(dash.ordenes).toBe(9);
    expect((await service.getDashboard('emp-1', { origen_tipo: 'compra', usuarioId: 'u-1' })).ordenes).toBe(8);
  });

  it('estado=aprobada filtra PENDIENTE (no el borrador) con whereEstadoOp', async () => {
    const { service, prisma } = armar();
    const r = await service.findAll('emp-1', { estado: 'aprobada', usuarioId: 'u-1' });
    expect(ids(r)).toEqual(['op-aprobada']);
    expect(prisma.orden_pago_proveedor_cab.count.mock.calls[0][0].where.AND).toContainEqual(whereEstadoOp('aprobada'));
    expect(ids(await service.findAll('emp-1', { estado: 'borrador', usuarioId: 'u-1' }))).toEqual(['op-borrador']);
    expect(ids(await service.findAll('emp-1', { estado: 'pagada', usuarioId: 'u-1' }))).toEqual([
      'op-aplicada',
      'op-otra-sucursal',
      'op-pyg',
      'op-usd',
    ]);
    expect(r.items[0].estado_clave).toBe('aprobada');
  });

  it('fecha_hasta 2026-10-05 incluye una OP de las 18:00 (y fecha_desde la de medianoche que graba el alta)', async () => {
    const ordenes = [
      op('op-medianoche'),
      op('op-18hs', { fecha_pago: new Date('2026-10-05T18:00:00.000Z') }),
      op('op-dia-siguiente', { fecha_pago: new Date('2026-10-06T00:00:00.000Z') }),
      op('op-dia-anterior', { fecha_pago: new Date('2026-10-04T23:59:00.000Z') }),
    ];
    const { service } = armar({ ordenes });
    const r = await service.findAll('emp-1', {
      fecha_desde: '2026-10-05',
      fecha_hasta: '2026-10-05',
      usuarioId: 'u-1',
    });
    expect(ids(r)).toEqual(['op-18hs', 'op-medianoche']);
    const dash = await service.getDashboard('emp-1', {
      fecha_desde: '2026-10-05',
      fecha_hasta: '2026-10-05',
      usuarioId: 'u-1',
    });
    expect(dash.ordenes).toBe(2);
  });

  it('findAll con alcance restringido filtra sucursal_id', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['s-2'], puntosEstablecimiento: [], depositoIds: [] });
    const { service, prisma } = armar();
    const r = await service.findAll('emp-1', { usuarioId: 'u-1' });
    expect(ids(r)).toEqual(['op-otra-sucursal']);
    expect(alcanceMock).toHaveBeenCalledWith(prisma, 'u-1', 'emp-1');
    expect((await service.getDashboard('emp-1', { usuarioId: 'u-1' })).ordenes).toBe(1);
  });

  it('tesoreria=pendiente filtra con idsSinTesoreria y sin_tesoreria cuenta lo mismo', async () => {
    // op-espejo (sin líneas) viene del SQL pero no entra al listado: el KPI cuenta sobre el mismo filtro.
    const { service, prisma } = armar({ sinTesoreria: ['op-pyg', 'op-espejo'] });
    const r = await service.findAll('emp-1', { tesoreria: 'pendiente', usuarioId: 'u-1' });
    expect(ids(r)).toEqual(['op-pyg']);
    const dash = await service.getDashboard('emp-1', { usuarioId: 'u-1' });
    expect(dash.sin_tesoreria).toBe(1);
    expect((await service.getDashboard('emp-1', { tesoreria: 'pendiente', usuarioId: 'u-1' })).ordenes).toBe(1);

    const sql = (prisma.$queryRaw.mock.calls[0][0] as Prisma.Sql).sql;
    expect(sql).toMatch(/NOT EXISTS[\s\S]*tes_movimientos/);
    expect(sql).toMatch(/NOT EXISTS[\s\S]*tes_cheques/);
    expect(sql).toContain('no_mueve_caja');
  });

  it('idsSinTesoreria: un $queryRaw con la empresa, manuales pagadas no anuladas y medios que mueven dinero', async () => {
    const { service, prisma } = armar({ sinTesoreria: ['op-1'] });
    await expect(service.idsSinTesoreria(prisma, 'emp-1')).resolves.toEqual(['op-1']);
    const q = prisma.$queryRaw.mock.calls[0][0] as Prisma.Sql;
    expect(q.values).toEqual(expect.arrayContaining(['emp-1', 'compra_auto', 'ORDEN_PAGO_PROVEEDOR', 'ANULADO']));
    expect(q.values).toContainEqual(['PAGADO', 'APLICADO', 'aplicado']);
    expect(q.values).toContainEqual([11]);
  });
});

describe('getDashboard: KPIs', () => {
  it('por_moneda separa PYG y USD y solo suma PAGADO no anuladas', async () => {
    const { service } = armar();
    const dash = await service.getDashboard('emp-1', { usuarioId: 'u-1' });
    // PYG: op-pyg 100000 + op-aplicada 50 + op-otra-sucursal 100000; la anulada (999) y la espejo (5000) no.
    expect(dash.por_moneda).toEqual([
      { codigo: 'PYG', monto: '200050.00' },
      { codigo: 'USD', monto: '150.50' },
    ]);
    expect(Object.keys(dash).sort()).toEqual(
      ['anuladas', 'ordenes', 'por_aprobar', 'por_ejecutar', 'por_moneda', 'rechazadas', 'sin_tesoreria'].sort(),
    );
    expect(dash).toMatchObject({ por_aprobar: 1, rechazadas: 1, anuladas: 1 });
  });

  it('por_ejecutar cuenta borradores solo sin aprobación', async () => {
    const sinAprobacion = armar({ config: { requiere_aprobacion: false, permite_pago_sin_aprobacion: true } });
    expect((await sinAprobacion.service.getDashboard('emp-1', { usuarioId: 'u-1' })).por_ejecutar).toBe(2);
    const conAprobacion = armar({ config: { requiere_aprobacion: true, permite_pago_sin_aprobacion: false } });
    expect((await conAprobacion.service.getDashboard('emp-1', { usuarioId: 'u-1' })).por_ejecutar).toBe(1);
  });
});

describe('findAll: forma de la fila', () => {
  it('documentos: una cuota → ref; dos de factura y gasto → cantidad 2, mixto', async () => {
    const ordenes = [
      op('op-una'),
      op('op-mixta', { orden_pago_proveedor_det: [linea(cuotaCompra('cxp-1', '555')), linea(cuotaGasto('cxp-2'))] }),
      op('op-gasto', { orden_pago_proveedor_det: [linea(cuotaGasto('cxp-3'))] }),
    ];
    const { service } = armar({ ordenes });
    const r = await service.findAll('emp-1', { usuarioId: 'u-1' });
    const por = new Map(r.items.map((i: Fila) => [i.id, i]));
    expect(por.get('op-una').documentos).toEqual({ ref: '001-001-0000123', cantidad: 1, origen: 'compra' });
    expect(por.get('op-mixta').documentos).toEqual({ ref: null, cantidad: 2, origen: 'mixto' });
    expect(por.get('op-gasto').documentos).toEqual({ ref: '002-001-0000077', cantidad: 1, origen: 'gasto' });
    expect(por.get('op-una').sucursal).toEqual({ id: 's-1', descripcion: 'Casa central' });
    expect(por.get('op-una').moneda).toMatchObject({ codigo: 'PYG' });
  });

  it('tesoreria_estado y contabilidad_estado en lote (una consulta por tabla para la página)', async () => {
    const { service, prisma } = armar({
      ordenes: [op('op-a'), op('op-b'), op('op-c', { estado: 'BORRADOR' })],
      movimientos: [
        { empresa_id: 'emp-1', origen_tipo: 'ORDEN_PAGO_PROVEEDOR', origen_id: 'op-a', estado: 'CONFIRMADO' },
      ],
      docs: [
        {
          id: 'doc-a',
          empresa_id: 'emp-1',
          origen_tipo: 'orden_pago_proveedor_cab',
          origen_id: 'op-a',
          estado: 'CONFIRMADO',
        },
        {
          id: 'doc-b-viejo',
          empresa_id: 'emp-1',
          origen_tipo: 'orden_pago_proveedor_cab',
          origen_id: 'op-b',
          estado: 'REVERTIDO',
          created_at: new Date('2026-10-01'),
        },
        {
          id: 'doc-b',
          empresa_id: 'emp-1',
          origen_tipo: 'orden_pago_proveedor_cab',
          origen_id: 'op-b',
          estado: 'BORRADOR',
          created_at: new Date('2026-10-05'),
        },
      ],
    });
    const r = await service.findAll('emp-1', { usuarioId: 'u-1' });
    const por = new Map(r.items.map((i: Fila) => [i.id, i]));
    expect(por.get('op-a')).toMatchObject({ tesoreria_estado: 'CONFIRMADO', contabilidad_estado: 'ASENTADO' });
    expect(por.get('op-b')).toMatchObject({ tesoreria_estado: 'PENDIENTE', contabilidad_estado: 'BORRADOR' });
    expect(por.get('op-c')).toMatchObject({ tesoreria_estado: null, contabilidad_estado: null });
    expect(prisma.tes_movimientos.findMany).toHaveBeenCalledTimes(1);
    expect(prisma.cont_documentos.findMany).toHaveBeenCalledTimes(1);
  });
});

describe('findOne', () => {
  it('findOne de otra sucursal del alcance → 404 (también el PDF y el historial)', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['s-2'], puntosEstablecimiento: [], depositoIds: [] });
    const { service } = armar();
    await expect(service.findOne('op-pyg', 'emp-1', undefined, 'u-1')).rejects.toBeInstanceOf(NotFoundException);
    await expect(service.generatePdf('op-pyg', 'emp-1', 'u-1')).rejects.toBeInstanceOf(NotFoundException);
    await expect(service.getHistorial('op-pyg', 'emp-1', 'u-1')).rejects.toBeInstanceOf(NotFoundException);
    await expect(service.findOne('op-otra-sucursal', 'emp-1', undefined, 'u-1')).resolves.toMatchObject({
      id: 'op-otra-sucursal',
    });
    // Sin usuario (lecturas internas después de escribir) no hay alcance.
    await expect(service.findOne('op-pyg', 'emp-1')).resolves.toMatchObject({ id: 'op-pyg' });
  });

  it('findOne trae tesoreria con el cheque y contabilidad con aviso_mapeo', async () => {
    const cuota = cuotaCompra('cxp-1');
    const orden = op('op-ch', {
      orden_pago_proveedor_det: [
        linea(cuota, MEDIO_CHEQUE, {
          cuenta_bancaria_id: 'tes-1',
          cuenta_bancaria: { id: 'tes-1', nombre: 'Itaú CC' },
          numero_cheque: '123',
        }),
      ],
    });
    const cheque = {
      id: 'ch-1',
      empresa_id: 'emp-1',
      origen_tipo: 'ORDEN_PAGO_PROVEEDOR',
      origen_id: 'op-ch',
      numero_cheque: '123',
      banco_emisor: 'Banco Itaú',
      titular: 'Novasis',
      estado: 'EN_CARTERA',
      cuenta: { id: 'tes-1', nombre: 'Itaú CC' },
      fecha_emision: new Date('2026-10-05T00:00:00.000Z'),
      fecha_vencimiento: new Date('2026-10-20T00:00:00.000Z'),
    };
    const { service } = armar({
      ordenes: [orden],
      cheques: [cheque],
      docs: [
        {
          id: 'doc-1',
          empresa_id: 'emp-1',
          origen_tipo: 'orden_pago_proveedor_cab',
          origen_id: 'op-ch',
          estado: 'BORRADOR',
        },
      ],
      logs: [
        {
          id: 'log-viejo',
          empresa_id: 'emp-1',
          action: 'CONT_FALTA_MAPEO',
          entity_type: 'orden_pago_proveedor_cab',
          entity_id: 'op-ch',
          descripcion: 'aviso viejo',
          created_at: new Date('2026-10-04'),
        },
        {
          id: 'log-1',
          empresa_id: 'emp-1',
          action: 'CONT_FALTA_MAPEO',
          entity_type: 'orden_pago_proveedor_cab',
          entity_id: 'op-ch',
          descripcion: 'Falta que el contador mapee: PROVEEDORES.',
          created_at: new Date('2026-10-05'),
        },
      ],
    });
    const r: Fila = await service.findOne('op-ch', 'emp-1', undefined, 'u-1');

    expect(r.estado_clave).toBe('pagada');
    expect(r.usuario).toEqual({ nombres: 'Ana', apellidos: 'Pérez' });
    expect(r.factura_origen).toBeNull();
    expect(r.rechazo).toBeNull();
    expect(r.tesoreria).toEqual({
      estado: 'EN_CARTERA',
      movimientos: [],
      cheques: [
        {
          id: 'ch-1',
          numero_cheque: '123',
          banco: 'Banco Itaú',
          titular: 'Novasis',
          estado: 'EN_CARTERA',
          cuenta: { id: 'tes-1', nombre: 'Itaú CC' },
          fecha_emision: cheque.fecha_emision,
          fecha_cobro: cheque.fecha_vencimiento,
        },
      ],
    });
    expect(r.contabilidad).toEqual({
      estado: 'BORRADOR',
      documento_id: 'doc-1',
      aviso_mapeo: 'Falta que el contador mapee: PROVEEDORES.',
    });
    // F6: los planos, con el mismo valor que los anidados.
    expect(r.tesoreria_estado).toBe('EN_CARTERA');
    expect(r.contabilidad_estado).toBe('BORRADOR');
    const det = r.orden_pago_proveedor_det[0];
    expect(det.medio_pago).toEqual({ id: 'mp-ch', descripcion: 'Cheque', codigo: 2, tipo: 'CHEQUE' });
    expect(det.cuenta_bancaria).toEqual({ id: 'tes-1', nombre: 'Itaú CC' });
    expect(det.cuentas_pagar.total_cuotas).toBe(2);
  });

  it('el egreso con su cuenta; sin módulo contable, contabilidad null; automática con factura_origen', async () => {
    const movimiento = {
      id: 'mov-1',
      empresa_id: 'emp-1',
      origen_tipo: 'ORDEN_PAGO_PROVEEDOR',
      origen_id: 'op-pyg',
      cuenta: { id: 'tes-1', nombre: 'Caja', moneda: 'PYG' },
      monto: 100000,
      estado: 'CONFIRMADO',
      fecha: new Date('2026-10-05T00:00:00.000Z'),
    };
    const auto = op('op-auto', {
      origen: 'compra_auto',
      compra_id: 'c-9',
      compra_cab: { id: 'c-9', establecimiento: '1', punto_expedicion: '2', numero_factura: '345' },
    });
    const { service } = armar({ ordenes: [op('op-pyg'), auto], movimientos: [movimiento], conContabilidad: false });
    const r: Fila = await service.findOne('op-pyg', 'emp-1');
    expect(r.tesoreria).toEqual({
      estado: 'CONFIRMADO',
      movimientos: [
        {
          id: 'mov-1',
          cuenta: { id: 'tes-1', nombre: 'Caja', moneda: 'PYG' },
          monto: 100000,
          estado: 'CONFIRMADO',
          fecha: movimiento.fecha,
        },
      ],
      cheques: [],
    });
    expect(r.contabilidad).toBeNull();
    expect(r.contabilidad_estado).toBeNull();
    const a: Fila = await service.findOne('op-auto', 'emp-1');
    expect(a.factura_origen).toEqual({ id: 'c-9', numero: '001-002-0000345' });
    expect(a.tesoreria_estado).toBeNull();
  });

  it('rechazo: el último REJECT de la auditoría; en las viejas, el texto de observaciones', async () => {
    const logs = [
      {
        id: 'l-1',
        empresa_id: 'emp-1',
        entity_type: 'orden_pago_proveedor',
        entity_id: 'op-r',
        action: 'REJECT',
        user_id: 'u-jefe',
        descripcion: 'primer motivo',
        new_value: { motivo: 'primer motivo' },
        created_at: new Date('2026-10-01T10:00:00Z'),
      },
      {
        id: 'l-2',
        empresa_id: 'emp-1',
        entity_type: 'orden_pago_proveedor',
        entity_id: 'op-r',
        action: 'REJECT',
        user_id: 'u-jefe',
        descripcion: 'Falta la factura',
        new_value: { motivo: 'Falta la factura' },
        created_at: new Date('2026-10-02T10:00:00Z'),
      },
    ];
    const vieja = op('op-vieja', {
      estado: 'RECHAZADA',
      observaciones: '[RECHAZO] sin respaldo',
      updated_at: new Date('2026-09-01T12:00:00Z'),
    });
    const { service } = armar({ ordenes: [op('op-r', { estado: 'RECHAZADA' }), vieja], logs });
    const r: Fila = await service.findOne('op-r', 'emp-1');
    expect(r.rechazo).toEqual({
      usuario: { nombres: 'Juan', apellidos: 'Jefe' },
      fecha: new Date('2026-10-02T10:00:00Z'),
      motivo: 'Falta la factura',
    });
    const v: Fila = await service.findOne('op-vieja', 'emp-1');
    expect(v.rechazo).toEqual({
      usuario: null,
      fecha: new Date('2026-09-01T12:00:00Z'),
      motivo: '[RECHAZO] sin respaldo',
    });
  });
});

describe('getHistorial', () => {
  it('getHistorial de una vieja arma create y cancel', async () => {
    const vieja = op('op-vieja', {
      anulado: true,
      estado: 'ANULADA',
      usuario: { id: 'u-creador', nombres: 'Ana', apellidos: 'Pérez', username: 'aperez' },
      created_at: new Date('2026-09-01T12:00:00Z'),
      fecha_anulacion: new Date('2026-09-03T12:00:00Z'),
      motivo_anulacion: 'Pago duplicado',
    });
    const { service } = armar({ ordenes: [vieja] });
    const h = await service.getHistorial('op-vieja', 'emp-1', 'u-1');
    expect(h.orden_id).toBe('op-vieja');
    expect(h.numero).toBe(vieja.numero_orden_pago);
    expect(h.events).toEqual([
      {
        id: 'op-anulada-op-vieja',
        accion: 'cancel',
        comentario: 'Orden de pago anulada: Pago duplicado',
        created_at: new Date('2026-09-03T12:00:00Z'),
        usuario: null,
      },
      {
        id: 'op-created-op-vieja',
        accion: 'create',
        comentario: `Orden de pago ${vieja.numero_orden_pago} creada`,
        created_at: new Date('2026-09-01T12:00:00Z'),
        usuario: { id: 'u-creador', nombres: 'Ana', apellidos: 'Pérez', username: 'aperez' },
      },
    ]);
  });

  it('con auditoría: acciones en minúscula, usuario y comentario, sin eventos sintéticos repetidos', async () => {
    const logs = [
      {
        id: 'l-1',
        empresa_id: 'emp-1',
        entity_type: 'orden_pago_proveedor',
        entity_id: 'op-n',
        action: 'CREATE',
        user_id: 'u-jefe',
        descripcion: 'Orden creada',
        created_at: new Date('2026-10-05T10:00:00Z'),
      },
      {
        id: 'l-2',
        empresa_id: 'emp-1',
        entity_type: 'orden_pago_proveedor',
        entity_id: 'op-n',
        action: 'CANCEL',
        user_id: 'u-jefe',
        descripcion: 'Mal cargada',
        created_at: new Date('2026-10-05T11:00:00Z'),
      },
      {
        id: 'l-3',
        empresa_id: 'emp-1',
        entity_type: 'orden_pago_proveedor',
        entity_id: 'op-n',
        action: 'RETRY_TESORERIA',
        user_id: null,
        descripcion: null,
        created_at: new Date('2026-10-05T10:30:00Z'),
      },
    ];
    const { service } = armar({ ordenes: [op('op-n', { anulado: true })], logs });
    const h = await service.getHistorial('op-n', 'emp-1');
    expect(h.events.map((e) => [e.accion, e.usuario?.nombres ?? null])).toEqual([
      ['cancel', 'Juan'],
      ['retry_tesoreria', null],
      ['create', 'Juan'],
    ]);
    expect(h.events[1].comentario).toBe('Reintento de registro en Tesorería');
  });
});

describe('endpoints del formulario', () => {
  it('proveedoresConSaldo con saldo por moneda', async () => {
    const { service, prisma } = armar();
    prisma.proveedores.findMany.mockResolvedValue([
      { id: 'prov-1', personas: { razon_social: 'ACME S.A.', ruc: '80000001', dv: '1' } },
      { id: 'prov-2', personas: { razon_social: 'Beta', ruc: '80000002', dv: '2' } },
    ]);
    prisma.cuentas_pagar.groupBy.mockResolvedValue([
      {
        proveedor_id: 'prov-1',
        moneda_id: 'mon-pyg',
        _sum: { saldo_pendiente: new Prisma.Decimal(300000) },
        _count: { _all: 2 },
      },
      {
        proveedor_id: 'prov-1',
        moneda_id: 'mon-usd',
        _sum: { saldo_pendiente: new Prisma.Decimal('120.5') },
        _count: { _all: 1 },
      },
      {
        proveedor_id: 'prov-2',
        moneda_id: 'mon-pyg',
        _sum: { saldo_pendiente: new Prisma.Decimal(50) },
        _count: { _all: 1 },
      },
    ]);
    const r = await service.proveedoresConSaldo('emp-1', 'u-1', 'ac');
    expect(r).toEqual([
      {
        id: 'prov-1',
        razon_social: 'ACME S.A.',
        ruc: '80000001',
        dv: '1',
        saldos: [
          { moneda: { id: 'mon-pyg', codigo: 'PYG' }, saldo: '300000.00', cuotas: 2 },
          { moneda: { id: 'mon-usd', codigo: 'USD' }, saldo: '120.50', cuotas: 1 },
        ],
      },
      {
        id: 'prov-2',
        razon_social: 'Beta',
        ruc: '80000002',
        dv: '2',
        saldos: [{ moneda: { id: 'mon-pyg', codigo: 'PYG' }, saldo: '50.00', cuotas: 1 }],
      },
    ]);
    const args = prisma.proveedores.findMany.mock.calls[0][0];
    expect(args.take).toBe(20);
    expect(args.orderBy).toEqual({ personas: { razon_social: 'asc' } });
    expect(args.where).toMatchObject({ empresa_id: 'emp-1', activo: true });
    const cuotas = args.where.cuentas_pagar.some;
    expect(cuotas.AND).toContainEqual(whereEstadoCuota(FILTRO_CON_SALDO, hoyComoFechaPY()));
    expect(JSON.stringify(args.where.personas)).toContain('"contains":"ac"');
    // El saldo se agrupa con el mismo filtro de cuotas.
    expect(prisma.cuentas_pagar.groupBy.mock.calls[0][0].where.AND).toContainEqual(
      whereEstadoCuota(FILTRO_CON_SALDO, hoyComoFechaPY()),
    );
  });

  /**
   * Las cuotas del alcance, probadas sobre filas: la de su factura y la de un gasto suyo; la que no tiene sucursal
   * que mirar (gasto sin sucursal — en DOBA son todos —, factura sin sucursal o cuota sin documento) es de la
   * empresa y también la ve; las de otra sucursal, no. El mock de `gasto_cab` devuelve `g-1` como gasto ajeno.
   */
  const CASOS_ALCANCE = [
    { fila: { compra_id: 'c-1', compra_cab: { sucursal_id: 's-1' }, origen_tipo: 'compra' }, visible: true },
    { fila: { compra_id: 'c-2', compra_cab: { sucursal_id: 's-2' }, origen_tipo: 'compra' }, visible: false },
    { fila: { compra_id: 'c-3', compra_cab: { sucursal_id: null }, origen_tipo: 'compra' }, visible: true },
    { fila: { compra_id: null, compra_cab: null, origen_tipo: 'gasto', origen_id: 'g-1' }, visible: false },
    { fila: { compra_id: null, compra_cab: null, origen_tipo: 'gasto', origen_id: 'g-sin-suc' }, visible: true },
    { fila: { compra_id: null, compra_cab: null, origen_tipo: null, origen_id: null }, visible: true },
  ];
  const verAlcance = (where: Fila) => {
    const alcance = (where.AND as Fila[]).find((w) => Array.isArray(w.OR) && JSON.stringify(w).includes('compra_cab'));
    expect(alcance).toBeDefined();
    for (const { fila, visible } of CASOS_ALCANCE) expect([fila, cumple(fila, alcance)]).toEqual([fila, visible]);
  };

  it('proveedoresConSaldo con alcance: las cuotas de sus sucursales y las que no tienen sucursal', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['s-1'], puntosEstablecimiento: [], depositoIds: [] });
    const { service, prisma } = armar();
    await service.proveedoresConSaldo('emp-1', 'u-1');
    verAlcance(prisma.proveedores.findMany.mock.calls[0][0].where.cuentas_pagar.some);
  });

  it('getCuentasPendientes con alcance (criterio de CxP)', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['s-1'], puntosEstablecimiento: [], depositoIds: [] });
    const { service, prisma } = armar();
    prisma.proveedores.findFirst = jest.fn().mockResolvedValue({ id: 'prov-1' });
    prisma.orden_pago_proveedor_det = { findMany: jest.fn().mockResolvedValue([]) };
    await service.getCuentasPendientes('emp-1', 'prov-1', 'u-1');
    verAlcance(prisma.cuentas_pagar.findMany.mock.calls[0][0].where);
  });

  const CUENTAS = [
    {
      id: 'tes-pyg',
      empresa_id: 'emp-1',
      activo: true,
      nombre: 'Banco PYG',
      moneda: 'PYG',
      tipo: 'BANCO_CC',
      banco_id: 'b-1',
    },
    {
      id: 'tes-usd',
      empresa_id: 'emp-1',
      activo: true,
      nombre: 'Banco USD',
      moneda: 'USD',
      tipo: 'BANCO_CC',
      banco_id: null,
    },
    {
      id: 'tes-eur',
      empresa_id: 'emp-1',
      activo: true,
      nombre: 'Banco EUR',
      moneda: 'EUR',
      tipo: 'BANCO_CC',
      banco_id: null,
    },
    {
      id: 'tes-inactiva',
      empresa_id: 'emp-1',
      activo: false,
      nombre: 'Vieja',
      moneda: 'PYG',
      tipo: 'CAJA_CHICA',
      banco_id: null,
    },
  ];

  it('cuentasPago para USD devuelve las USD y las PYG; para PYG solo las PYG', async () => {
    const { service } = armar({ cuentasTes: CUENTAS });
    expect(await service.cuentasPago('emp-1', USD.id)).toEqual([
      { id: 'tes-pyg', nombre: 'Banco PYG', moneda: 'PYG', tipo: 'BANCO_CC', banco: 'Banco Itaú' },
      { id: 'tes-usd', nombre: 'Banco USD', moneda: 'USD', tipo: 'BANCO_CC', banco: null },
    ]);
    expect((await service.cuentasPago('emp-1', PYG.id)).map((c) => c.id)).toEqual(['tes-pyg']);
  });

  it('cuentaPago sin regla → cuenta null y el aviso de hoy', async () => {
    const { service } = armar({ cuentasTes: CUENTAS });
    expect(await service.cuentaPago('emp-1', { medio_pago_id: 'mp-ef', moneda_id: PYG.id })).toEqual({
      cuenta: null,
      conversion: null,
      avisos: [
        'No existe una regla de Tesorería para "Pago a proveedor". Configurá la cuenta en Configuración > Tesorería > Reglas.',
      ],
    });
  });

  it('cuentaPago con regla: la cuenta, y en USD desde una cuenta PYG la conversión con la cotización', async () => {
    const reglas = [
      {
        empresa_id: 'emp-1',
        tipo_operacion: 'PAGO_PROVEEDOR',
        medio_pago_id: null,
        activo: true,
        cuenta_id: 'tes-pyg',
        tipo_tesoreria: null,
      },
    ];
    const { service } = armar({ cuentasTes: CUENTAS, reglas });
    expect(await service.cuentaPago('emp-1', { medio_pago_id: 'mp-ef', moneda_id: USD.id, cotizacion: 7300 })).toEqual({
      cuenta: { id: 'tes-pyg', nombre: 'Banco PYG', moneda: 'PYG' },
      conversion: { tc: 7300 },
      avisos: [],
    });
    expect(await service.cuentaPago('emp-1', { medio_pago_id: 'mp-ef', moneda_id: PYG.id })).toEqual({
      cuenta: { id: 'tes-pyg', nombre: 'Banco PYG', moneda: 'PYG' },
      conversion: null,
      avisos: [],
    });
  });

  it('cuentaPago: la cuenta de la regla no acepta la moneda de la orden → lo avisa', async () => {
    const reglas = [
      {
        empresa_id: 'emp-1',
        tipo_operacion: 'PAGO_PROVEEDOR',
        medio_pago_id: null,
        activo: true,
        cuenta_id: 'tes-usd',
        tipo_tesoreria: null,
      },
    ];
    const { service } = armar({ cuentasTes: CUENTAS, reglas });
    const r = await service.cuentaPago('emp-1', { medio_pago_id: 'mp-ef', moneda_id: PYG.id });
    expect(r.cuenta).toEqual({ id: 'tes-usd', nombre: 'Banco USD', moneda: 'USD' });
    expect(r.avisos).toEqual([
      'El pago está en guaraníes y la cuenta "Banco USD" está en USD. Elegí una cuenta en guaraníes.',
    ]);
  });
});

describe('minors de la Task 8 (arreglados en la Task 9)', () => {
  it('tesoreria=pendiente: idsSinTesoreria corre una vez en el dashboard y con el alcance del usuario', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['s-2'], puntosEstablecimiento: [], depositoIds: [] });
    const { service, prisma } = armar({ sinTesoreria: ['op-otra-sucursal'] });
    const dash = await service.getDashboard('emp-1', { tesoreria: 'pendiente', usuarioId: 'u-1' });
    expect(dash.ordenes).toBe(1);
    expect(dash.sin_tesoreria).toBe(1);
    expect(prisma.$queryRaw).toHaveBeenCalledTimes(1);
    const q = prisma.$queryRaw.mock.calls[0][0] as Prisma.Sql;
    expect(q.sql).toContain('sucursal_id');
    expect(q.values).toContainEqual(['s-2']);

    // El listado también: una sola vez y con el alcance.
    prisma.$queryRaw.mockClear();
    const r = await service.findAll('emp-1', { tesoreria: 'pendiente', usuarioId: 'u-1' });
    expect(ids(r)).toEqual(['op-otra-sucursal']);
    expect(prisma.$queryRaw).toHaveBeenCalledTimes(1);
    expect((prisma.$queryRaw.mock.calls[0][0] as Prisma.Sql).values).toContainEqual(['s-2']);
  });

  it('idsSinTesoreria sin alcance (lecturas internas o usuario sin restricción) no filtra sucursal', async () => {
    const { service, prisma } = armar({ sinTesoreria: ['op-pyg'] });
    await service.getDashboard('emp-1', { usuarioId: 'u-1' });
    const q = prisma.$queryRaw.mock.calls[0][0] as Prisma.Sql;
    expect(q.sql).not.toContain('sucursal_id');
  });

  it('por_moneda: una moneda sin código se omite del KPI con un WARN (nunca un código vacío)', async () => {
    const ordenes = [op('op-pyg'), op('op-fantasma', { moneda_id: 'mon-borrada', moneda: null, monto_total: 7 })];
    const { service } = armar({ ordenes });
    const warn = jest.spyOn((service as any).logger, 'warn').mockImplementation(() => undefined);
    const dash = await service.getDashboard('emp-1', { usuarioId: 'u-1' });
    expect(dash.por_moneda).toEqual([{ codigo: 'PYG', monto: '100000.00' }]);
    expect(warn).toHaveBeenCalledWith(expect.stringContaining('mon-borrada'));
  });

  it('proveedoresConSaldo: la moneda NULL (legacy) se agrupa con la base, que se consulta una sola vez', async () => {
    const { service, prisma } = armar();
    prisma.proveedores.findMany.mockResolvedValue([
      { id: 'prov-1', personas: { razon_social: 'ACME S.A.', ruc: '80000001', dv: '1' } },
    ]);
    prisma.cuentas_pagar.groupBy.mockResolvedValue([
      {
        proveedor_id: 'prov-1',
        moneda_id: 'mon-pyg',
        _sum: { saldo_pendiente: new Prisma.Decimal(10) },
        _count: { _all: 1 },
      },
      {
        proveedor_id: 'prov-1',
        moneda_id: null,
        _sum: { saldo_pendiente: new Prisma.Decimal(5) },
        _count: { _all: 2 },
      },
    ]);
    const [p] = await service.proveedoresConSaldo('emp-1', 'u-1');
    expect(p.saldos).toEqual([{ moneda: { id: 'mon-pyg', codigo: 'PYG' }, saldo: '15.00', cuotas: 3 }]);
    expect(prisma.empresa_monedas.findFirst).toHaveBeenCalledTimes(1);
  });

  it('proveedoresConSaldo: el saldo en una moneda sin código se omite con un WARN', async () => {
    const { service, prisma } = armar();
    const warn = jest.spyOn((service as any).logger, 'warn').mockImplementation(() => undefined);
    prisma.proveedores.findMany.mockResolvedValue([
      { id: 'prov-1', personas: { razon_social: 'ACME S.A.', ruc: '80000001', dv: '1' } },
    ]);
    prisma.cuentas_pagar.groupBy.mockResolvedValue([
      {
        proveedor_id: 'prov-1',
        moneda_id: 'mon-pyg',
        _sum: { saldo_pendiente: new Prisma.Decimal(10) },
        _count: { _all: 1 },
      },
      {
        proveedor_id: 'prov-1',
        moneda_id: 'mon-borrada',
        _sum: { saldo_pendiente: new Prisma.Decimal(5) },
        _count: { _all: 1 },
      },
    ]);
    const [p] = await service.proveedoresConSaldo('emp-1', 'u-1');
    expect(p.saldos).toEqual([{ moneda: { id: 'mon-pyg', codigo: 'PYG' }, saldo: '10.00', cuotas: 1 }]);
    expect(warn).toHaveBeenCalledWith(expect.stringContaining('mon-borrada'));
  });
});
