/**
 * Monedas honestas en los seis endpoints del Tablero (T3): con «Convertido» cada documento se convierte con SU
 * cotización a la moneda base; el que no tiene cotización sale de todos los agregados convertidos y solo queda en
 * `por_moneda` y `sin_cotizacion`; con una moneda elegida se filtra esa moneda (la base incluye los documentos sin
 * moneda, F2). Contrato aditivo (F14): los campos viejos siguen y lo nuevo va en campos nuevos.
 */
process.env.TZ = 'UTC';

import { CobrosService } from 'src/cobros/cobros.service';
import { ComprasService } from 'src/compras/compras.service';
import { FacturasService } from 'src/facturas/facturas.service';
import { PresupuestosDashboardService } from 'src/presupuestos/presupuestos-dashboard.service';
import { ReportesRentabilidadService } from 'src/reportes-rentabilidad/reportes-rentabilidad.service';
import { TesoreriaService } from 'src/tesoreria/tesoreria.service';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';

// Tablero «lo mío» (A2): estos tests miran el alcance por sucursal y las monedas, no el alcance propio: TODO.
jest.mock('src/utils/alcance-propio', () => ({
  ...jest.requireActual('src/utils/alcance-propio'),
  resolverAlcancePropio: jest.fn().mockResolvedValue({ tipo: 'TODO' }),
}));
jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn().mockResolvedValue(null),
}));
(alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null);

const PYG = '22222222-2222-4222-8222-222222222222';
const USD = '11111111-1111-4111-8111-111111111111';
const MONEDAS: Record<string, { id: string; codigo: string }> = { [PYG]: { id: PYG, codigo: 'PYG' }, [USD]: { id: USD, codigo: 'USD' } };

function crearPrisma() {
  const prisma: any = {
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: PYG }) },
    moneda: {
      findFirst: jest.fn().mockResolvedValue(MONEDAS[PYG]),
      findUnique: jest.fn(({ where }) => Promise.resolve(MONEDAS[where.id] ?? null)),
      findMany: jest.fn(({ where }) => Promise.resolve((where.id.in as string[]).map((id) => MONEDAS[id]).filter(Boolean))),
    },
    empresas_sucursales: { findMany: jest.fn().mockResolvedValue([]), findFirst: jest.fn().mockResolvedValue(null) },
    factura_cab: { findMany: jest.fn().mockResolvedValue([]) },
    factura_det: { findMany: jest.fn().mockResolvedValue([]), aggregate: jest.fn().mockResolvedValue({ _sum: { dcantproser: 0 } }) },
    factura_cuotas: { findMany: jest.fn().mockResolvedValue([]) },
    recibos_cobro: {
      aggregate: jest.fn().mockResolvedValue({ _sum: { monto_total: 0 } }),
      groupBy: jest.fn().mockResolvedValue([]),
    },
    compra_cab: { findMany: jest.fn().mockResolvedValue([]), count: jest.fn().mockResolvedValue(0) },
    nota_credito_compra_cab: { findMany: jest.fn().mockResolvedValue([]) },
    presupuesto_cab: { groupBy: jest.fn().mockResolvedValue([]), findMany: jest.fn().mockResolvedValue([]), count: jest.fn().mockResolvedValue(0) },
    presupuesto_config: { findUnique: jest.fn().mockResolvedValue(null) },
    movimiento_cajas: { findMany: jest.fn().mockResolvedValue([]), count: jest.fn().mockResolvedValue(0) },
    $queryRaw: jest.fn().mockResolvedValue([]),
    $transaction: jest.fn((ops: Promise<unknown>[]) => Promise.all(ops)),
  };
  return prisma;
}

const whereJson = (mock: jest.Mock, n = 0) => JSON.stringify(mock.mock.calls[n][0].where);

// ─────────────────────────── ventas ───────────────────────────

const factura = (o: { codigo: 'PYG' | 'USD' | null; dtotope: number; dtotiva: number; dticam?: number | null; dtotalgs?: number | null; cliente?: string; det?: any[] }) => ({
  cliente_id: o.cliente ?? 'c1',
  dfeemide: new Date('2026-11-07T13:30:00Z'),
  dticam: o.dticam ?? null,
  moneda_id: o.codigo ? MONEDAS[o.codigo === 'PYG' ? PYG : USD].id : null,
  moneda: o.codigo ? { id: o.codigo === 'PYG' ? PYG : USD, codigo: o.codigo, simbolo: '$', descripcion: o.codigo } : null,
  condicion_operacion: { codigo: 1, descripcion: 'Contado' },
  factura_subtotales: [{ dtotope: o.dtotope, dtotiva: o.dtotiva, dtotalgs: o.dtotalgs ?? null }],
  factura_det: o.det ?? [],
});
const item = (monto: number, cat = 'Cat') => ({
  dcantproser: 1,
  dtotopeitem: monto,
  dtotopegs: null,
  dticamit: null,
  producto_id: `p-${monto}`,
  ddesproser: 'x',
  productos: { descripcion: `P${monto}`, categoria: { descripcion: cat } },
});

async function ventas(facturas: any[], monedaId?: string, anteriores: any[] = []) {
  const prisma = crearPrisma();
  prisma.factura_cab.findMany.mockImplementation(({ select }: any) => Promise.resolve(select.factura_det ? facturas : anteriores));
  const r = await new (FacturasService as any)(prisma).getDashboardVentas('emp', { monedaId, usuarioId: 'usr' });
  return { r, prisma };
}

describe('GET /facturas/dashboard', () => {
  const pyg = factura({ codigo: 'PYG', dtotope: 1000000, dtotiva: 90909, det: [item(1000000)] });
  const usd = factura({ codigo: 'USD', dtotope: 100, dtotiva: 9.09, dticam: 7300, cliente: 'c2', det: [item(100)] });
  const usdSinCot = factura({ codigo: 'USD', dtotope: 100, dtotiva: 9.09, cliente: 'c2', det: [item(100)] });

  it('convertido: cada factura con su cotización; moneda base y por_moneda sin convertir', async () => {
    const { r } = await ventas([pyg, usd]);
    expect(r.actual.ventas).toBe(1730000);
    expect(r.actual.iva).toBe(90909 + 66357);
    expect(r.moneda).toEqual({ codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.convertido_a_pyg).toBe(true);
    expect(r.sin_cotizacion).toBe(0);
    expect(r.actual.por_moneda).toEqual([
      { codigo: 'PYG', ventas: '1000000.00', iva: '90909.00', facturas: 1 },
      { codigo: 'USD', ventas: '100.00', iva: '9.09', facturas: 1 },
    ]);
    expect(r.por_moneda).toEqual(r.actual.por_moneda);
    expect(r.actual.topProductos.map((p: any) => p.monto).sort()).toEqual([1000000, 730000]);
  });

  it('con moneda_id USD: filtra USD y no convierte', async () => {
    const { r, prisma } = await ventas([usd], USD);
    expect(r.actual.ventas).toBe(100);
    expect(r.moneda).toEqual({ codigo: 'USD' });
    expect(r.convertido).toBe(false);
    expect(r.convertido_a_pyg).toBe(false);
    expect(whereJson(prisma.factura_cab.findMany)).toContain(`{"moneda_id":"${USD}"}`);
  });

  it('con la moneda base: también las facturas sin moneda (F2)', async () => {
    const { prisma } = await ventas([pyg], PYG);
    expect(whereJson(prisma.factura_cab.findMany)).toContain(`{"OR":[{"moneda_id":"${PYG}"},{"moneda_id":null}]}`);
  });

  it('una factura sin moneda vale en la base', async () => {
    const { r } = await ventas([factura({ codigo: null, dtotope: 5000, dtotiva: 0 })]);
    expect(r.actual.ventas).toBe(5000);
    expect(r.actual.por_moneda).toEqual([{ codigo: 'PYG', ventas: '5000.00', iva: '0.00', facturas: 1 }]);
  });

  it('dtotalgs manda sobre dticam cuando la base es PYG', async () => {
    const { r } = await ventas([factura({ codigo: 'USD', dtotope: 100, dtotiva: 0, dtotalgs: 731000, dticam: 7300 })]);
    expect(r.actual.ventas).toBe(731000);
  });

  it('USD sin cotización: fuera de cada agregado convertido, en por_moneda y en sin_cotizacion', async () => {
    const { r } = await ventas([pyg, usdSinCot], undefined, [usdSinCot]);
    const a = r.actual;
    expect(a.ventas).toBe(1000000);
    expect(a.iva).toBe(90909);
    expect(a.facturas).toBe(1);
    expect(a.ticketPromedio).toBe(1000000);
    expect(a.clientesAtendidos).toBe(1);
    expect(a.contado.ventas).toBe(1000000);
    expect(a.ventasPorHora).toEqual([{ hora: '13:00', ventas: 1000000 }]);
    expect(a.topProductos.map((p: any) => p.monto)).toEqual([1000000]);
    expect(a.ventasPorCategoria).toEqual([{ categoria: 'Cat', monto: 1000000, porcentaje: 100 }]);
    expect(a.por_moneda).toEqual([
      { codigo: 'PYG', ventas: '1000000.00', iva: '90909.00', facturas: 1 },
      { codigo: 'USD', ventas: '100.00', iva: '9.09', facturas: 1 },
    ]);
    expect(a.sin_cotizacion).toBe(1);
    expect(r.sin_cotizacion).toBe(1);
    expect(r.anterior.ventas).toBe(0);
    expect(r.anterior.sin_cotizacion).toBe(1);
    expect(r.anterior.por_moneda).toEqual([{ codigo: 'USD', ventas: '100.00', iva: '9.09', facturas: 1 }]);
    // El desglose viejo (moneda original) sigue igual.
    expect(a.desglosePorMoneda.map((d: any) => d.ventas).sort()).toEqual([100, 1000000]);
  });

  it('iva junto a ganancias, en actual y anterior', async () => {
    const { r } = await ventas([pyg, usd], undefined, [pyg]);
    expect(r.actual.iva).toBe(r.actual.ganancias);
    expect(r.anterior.iva).toBe(r.anterior.ganancias);
    expect(r.anterior.iva).toBe(90909);
  });

  // `dfeemide` se graba con `nowAsuncionNaive`: «13:30 grabado» es 13:30 en Paraguay, con cualquier TZ del proceso.
  it('ventasPorHora con la hora de Paraguay tal como se graba (TZ del proceso = UTC)', async () => {
    const { r } = await ventas([pyg]);
    expect(r.actual.ventasPorHora).toEqual([{ hora: '13:00', ventas: 1000000 }]);
  });

  it('en_moneda (forma uniforme del Tablero) trae actual y anterior en moneda.codigo', async () => {
    const { r } = await ventas([pyg, usd], undefined, [pyg]);
    expect(r.en_moneda.actual.ventas).toBe(1730000);
    expect(r.en_moneda.actual).toEqual(r.actual);
    expect(r.en_moneda.anterior).toEqual(r.anterior);
  });

  it('el IVA sale redondeado a 2 decimales', async () => {
    const { r } = await ventas([factura({ codigo: 'PYG', dtotope: 1, dtotiva: 0.1 }), factura({ codigo: 'PYG', dtotope: 1, dtotiva: 0.2 })]);
    expect(r.actual.iva).toBe(0.3);
    expect(r.actual.ganancias).toBe(0.3);
  });
});

// ─────────────────────────── compras ───────────────────────────

describe('GET /compras/dashboard', () => {
  const compra = (codigo: string | null, total: number, cotizacion: number | null) => ({ total, cotizacion, moneda: codigo ? { codigo } : null });

  async function compras(actual: any[], nc: any[] = [], moneda_id?: string) {
    const prisma = crearPrisma();
    prisma.compra_cab.findMany.mockResolvedValueOnce(actual).mockResolvedValueOnce([]);
    prisma.nota_credito_compra_cab.findMany.mockResolvedValue(nc);
    const r = await new (ComprasService as any)(prisma).getDashboard('emp', { moneda_id, usuarioId: 'usr' });
    return { r, prisma };
  }

  it('convertido con la cotización de cada compra y de cada NC', async () => {
    const { r } = await compras([compra('PYG', 1000000, 1), compra('USD', 100, 7300)], [compra('USD', 10, 7200)]);
    expect(r.total_compras).toBe(1730000);
    expect(r.total_nc_compras).toBe(72000);
    expect(r.total_neto).toBe(1658000);
    expect(r.en_moneda).toEqual({ total_compras: 1730000, total_compras_anterior: 0, total_nc_compras: 72000, total_neto: 1658000, variacion_pct: 0 });
    expect(r.moneda).toEqual({ codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.sin_cotizacion).toBe(0);
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', total_compras: '1000000.00', total_nc_compras: '0.00' },
      { codigo: 'USD', total_compras: '100.00', total_nc_compras: '10.00' },
    ]);
  });

  it('USD sin cotización (el default 1, F18): fuera del total, en por_moneda y en sin_cotizacion', async () => {
    const { r } = await compras([compra('PYG', 1000000, 1), compra('USD', 100, 1)], [compra('USD', 10, null)]);
    expect(r.total_compras).toBe(1000000);
    expect(r.total_nc_compras).toBe(0);
    expect(r.sin_cotizacion).toBe(2);
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', total_compras: '1000000.00', total_nc_compras: '0.00' },
      { codigo: 'USD', total_compras: '100.00', total_nc_compras: '10.00' },
    ]);
  });

  it('con moneda_id USD: filtra USD (compras y NC) y no convierte', async () => {
    const { r, prisma } = await compras([compra('USD', 100, 7300)], [], USD);
    expect(r.total_compras).toBe(100);
    expect(r.moneda).toEqual({ codigo: 'USD' });
    expect(r.convertido).toBe(false);
    expect(whereJson(prisma.compra_cab.findMany)).toContain(`{"moneda_id":"${USD}"}`);
    expect(whereJson(prisma.nota_credito_compra_cab.findMany)).toContain(`{"moneda_id":"${USD}"}`);
  });

  it('con la base: las compras sin moneda entran (F2)', async () => {
    const { prisma } = await compras([], [], PYG);
    expect(whereJson(prisma.compra_cab.findMany)).toContain(`{"OR":[{"moneda_id":"${PYG}"},{"moneda_id":null}]}`);
  });
});

// ─────────────────────────── presupuestos ───────────────────────────

describe('GET /presupuestos/dashboard', () => {
  const presu = (codigo: string | null, total: number, tipo_cambio_usd: number | null, estado = 'SENT') => ({
    estado,
    total,
    tipo_cambio_usd,
    moneda: codigo ? { codigo } : null,
    fecha_emision: new Date(),
    fecha_conversion: estado === 'CONVERTED' ? new Date() : null,
  });

  async function presupuestos(docs: any[], moneda_id?: string) {
    const prisma = crearPrisma();
    prisma.presupuesto_cab.groupBy.mockResolvedValue([{ estado: 'SENT', _count: { _all: docs.length }, _sum: { total: docs.reduce((s, d) => s + d.total, 0) } }]);
    prisma.presupuesto_cab.findMany.mockResolvedValue(docs);
    const r = await new PresupuestosDashboardService(prisma).getDashboard('emp', { moneda_id }, 'usr');
    return { r, prisma };
  }

  it('PYG 500.000 + USD 50 (7300): convertido 865.000; el campo viejo sigue en 500.050', async () => {
    const { r } = await presupuestos([presu('PYG', 500000, null), presu('USD', 50, 7300, 'CONVERTED')]);
    expect(r.resumen.monto_total).toBe(500050);
    expect(r.en_moneda.resumen.monto_total).toBe(865000);
    expect(r.en_moneda.resumen.monto_convertido).toBe(365000);
    expect(r.en_moneda.resumen.monto_pipeline).toBe(500000);
    expect(r.en_moneda.por_estado).toEqual(
      expect.arrayContaining([
        { estado: 'SENT', count: 1, monto: 500000 },
        { estado: 'CONVERTED', count: 1, monto: 365000 },
      ]),
    );
    const mes = r.en_moneda.por_mes[r.en_moneda.por_mes.length - 1];
    expect(mes.emitidos_monto).toBe(865000);
    expect(mes.convertidos_monto).toBe(365000);
    expect(r.moneda).toEqual({ codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.sin_cotizacion).toBe(0);
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', total: '500000.00', convertido: '0.00' },
      { codigo: 'USD', total: '50.00', convertido: '50.00' },
    ]);
  });

  it('USD sin cotización: fuera del convertido, en por_moneda y en sin_cotizacion', async () => {
    const { r } = await presupuestos([presu('PYG', 500000, null), presu('USD', 50, null)]);
    expect(r.en_moneda.resumen.monto_total).toBe(500000);
    expect(r.en_moneda.por_estado).toEqual([{ estado: 'SENT', count: 1, monto: 500000 }]);
    expect(r.en_moneda.por_mes[r.en_moneda.por_mes.length - 1].emitidos_monto).toBe(500000);
    expect(r.sin_cotizacion).toBe(1);
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', total: '500000.00', convertido: '0.00' },
      { codigo: 'USD', total: '50.00', convertido: '0.00' },
    ]);
  });

  it('un presupuesto en EUR no se convierte con tipo_cambio_usd: queda en sin_cotizacion', async () => {
    const { r } = await presupuestos([presu('PYG', 500000, null), presu('EUR', 50, 7300)]);
    expect(r.en_moneda.resumen.monto_total).toBe(500000);
    expect(r.sin_cotizacion).toBe(1);
    expect(r.por_moneda).toContainEqual({ codigo: 'EUR', total: '50.00', convertido: '0.00' });
  });

  it('con moneda_id USD: filtra USD en todas las consultas', async () => {
    const { r, prisma } = await presupuestos([presu('USD', 50, 7300)], USD);
    expect(r.en_moneda.resumen.monto_total).toBe(50);
    expect(r.moneda).toEqual({ codigo: 'USD' });
    expect(whereJson(prisma.presupuesto_cab.groupBy)).toContain(`{"moneda_id":"${USD}"}`);
    expect(whereJson(prisma.presupuesto_cab.findMany)).toContain(`{"moneda_id":"${USD}"}`);
    expect(whereJson(prisma.presupuesto_cab.count)).toContain(`{"moneda_id":"${USD}"}`);
  });
});

// ─────────────────────────── cuentas a cobrar ───────────────────────────

describe('GET /cobros/cuentas-cobrar/dashboard', () => {
  const manana = new Date(Date.now() + 2 * 86400000);
  const cuota = (codigo: string | null, saldo: number, dticam: number | null) => ({
    id: `q-${codigo}-${saldo}`,
    estado: 'pendiente',
    saldo_pendiente: saldo,
    dmoncuota: saldo,
    dvenccuo: manana,
    factura_cab: {
      id: `f-${codigo}-${saldo}`,
      dest: '001',
      dpunexp: '001',
      dnumdoc: '1',
      dticam,
      moneda: codigo ? { codigo } : null,
      total_notas_credito: 0,
      clientes: { id: 'c1', personas: { razon_social: 'Cliente' } },
    },
  });

  async function cxc(cuotas: any[], recibos: any[] = [], moneda_id?: string) {
    const prisma = crearPrisma();
    prisma.factura_cuotas.findMany.mockResolvedValue(cuotas);
    prisma.recibos_cobro.groupBy.mockResolvedValue(recibos);
    const r = await new (CobrosService as any)(prisma).getCuentasCobrarDashboard('emp', { moneda_id }, 'usr');
    return { r, prisma };
  }

  it('cuota USD 200 de una factura con dticam 7000: 1.400.000 convertido; el campo viejo sigue', async () => {
    const { r } = await cxc([cuota('USD', 200, 7000)], [{ moneda_id: USD, cotizacion: 7000, _sum: { monto_total: 10 }, _count: { _all: 1 } }]);
    expect(r.total_pendiente).toBe(200);
    expect(r.en_moneda.total_pendiente).toBe(1400000);
    expect(r.en_moneda.total_al_dia).toBe(1400000);
    expect(r.en_moneda.total_vencido).toBe(0);
    expect(r.en_moneda.total_cobrado).toBe(70000);
    expect(r.en_moneda.aging_buckets.al_dia).toEqual({ monto: 1400000, cantidad: 1 });
    expect(r.moneda).toEqual({ codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.por_moneda).toEqual([{ codigo: 'USD', pendiente: '200.00', vencido: '0.00', al_dia: '200.00', cobrado: '10.00' }]);
    expect(r.proximos_vencimientos[0].moneda).toEqual({ codigo: 'USD' });
  });

  it('con moneda_id USD: 200 y el filtro en cuotas y recibos', async () => {
    const { r, prisma } = await cxc([cuota('USD', 200, 7000)], [], USD);
    expect(r.en_moneda.total_pendiente).toBe(200);
    expect(r.moneda).toEqual({ codigo: 'USD' });
    expect(whereJson(prisma.factura_cuotas.findMany)).toContain(`{"moneda_id":"${USD}"}`);
    expect(whereJson(prisma.recibos_cobro.groupBy)).toContain(`{"moneda_id":"${USD}"}`);
    expect(whereJson(prisma.recibos_cobro.aggregate)).toContain(`{"moneda_id":"${USD}"}`);
  });

  it('con la base: cuotas y recibos sin moneda entran (F2)', async () => {
    const { prisma } = await cxc([], [], PYG);
    const conNull = `{"OR":[{"moneda_id":"${PYG}"},{"moneda_id":null}]}`;
    expect(whereJson(prisma.factura_cuotas.findMany)).toContain(conNull);
    expect(whereJson(prisma.recibos_cobro.groupBy)).toContain(conNull);
  });

  it('USD sin cotización: fuera del convertido (cuota y recibo), en por_moneda y en sin_cotizacion', async () => {
    const { r } = await cxc(
      [cuota('PYG', 5000, null), cuota('USD', 200, null)],
      [
        { moneda_id: null, cotizacion: null, _sum: { monto_total: 3000 }, _count: { _all: 2 } },
        { moneda_id: USD, cotizacion: null, _sum: { monto_total: 10 }, _count: { _all: 1 } },
      ],
    );
    expect(r.en_moneda.total_pendiente).toBe(5000);
    expect(r.en_moneda.aging_buckets.al_dia).toEqual({ monto: 5000, cantidad: 1 });
    expect(r.en_moneda.total_cobrado).toBe(3000);
    expect(r.sin_cotizacion).toBe(2);
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', pendiente: '5000.00', vencido: '0.00', al_dia: '5000.00', cobrado: '3000.00' },
      { codigo: 'USD', pendiente: '200.00', vencido: '0.00', al_dia: '200.00', cobrado: '10.00' },
    ]);
  });
});

// ─────────────────────────── rentabilidad ───────────────────────────

describe('GET /reportes/rentabilidad/dashboard', () => {
  const det = (codigo: string | null, ingresos: number, costo: number, dticam: number | null, factura: string) => ({
    producto_id: `p-${factura}`,
    factura_cab_id: factura,
    dcantproser: 1,
    dtotopeitem: ingresos,
    costo_unitario_venta: null,
    costo_total_venta: costo,
    productos: { id: `p-${factura}`, descripcion: 'P', cod_producto: 'C', precio_costo: null, categoria: null },
    factura_cab: { cliente_id: 'c1', dest: '001', dticam, moneda_id: codigo ? (codigo === 'USD' ? USD : PYG) : null, moneda: codigo ? { codigo } : null, clientes: { id: 'c1', personas: { razon_social: 'C', ruc: null, dv: null } } },
    deposito: null,
  });

  async function rentabilidad(dets: any[], moneda_id?: string) {
    const prisma = crearPrisma();
    prisma.factura_det.findMany.mockResolvedValue(dets);
    const svc = new ReportesRentabilidadService(prisma);
    jest.spyOn(svc as any, 'computeOverlayPorFactura').mockResolvedValue(new Map());
    const r: any = await svc.getRentabilidadDashboard('emp', { moneda_id }, 'usr');
    return { r, prisma };
  }

  // F12: el costo se guarda en la base; los ingresos se convierten con la cotización de cada factura.
  it('convertido: ingresos con su dticam, costo tal cual (base); margen sobre los convertidos', async () => {
    const { r } = await rentabilidad([det('PYG', 1000000, 600000, null, 'f1'), det('USD', 100, 500000, 7300, 'f2')]);
    expect(r.resumen.ingresos_total).toBe(1000100); // campo viejo, sin cambios
    expect(r.en_moneda.resumen.ingresos_total).toBe(1730000);
    expect(r.en_moneda.resumen.costo_total).toBe(1100000);
    expect(r.en_moneda.resumen.utilidad_total).toBe(630000);
    expect(r.en_moneda.resumen.margen_pct).toBe(36.42);
    expect(r.en_moneda.top_productos.map((p: any) => p.ingresos).sort()).toEqual([1000000, 730000]);
    expect(r.moneda).toEqual({ codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', ingresos: '1000000.00', costo: '600000.00', utilidad: '400000.00', ingresos_sin_costo: '0.00' },
      { codigo: 'USD', ingresos: '100.00', costo: '68.49', utilidad: '31.51', ingresos_sin_costo: '0.00' },
    ]);
  });

  it('con moneda_id USD: el costo pasa a USD con la dticam de su factura', async () => {
    const { r, prisma } = await rentabilidad([det('USD', 100, 500000, 7300, 'f2')], USD);
    expect(r.en_moneda.resumen.ingresos_total).toBe(100);
    expect(r.en_moneda.resumen.costo_total).toBe(68.49);
    expect(r.en_moneda.resumen.utilidad_total).toBe(31.51);
    expect(r.en_moneda.resumen.margen_pct).toBe(31.51);
    expect(r.moneda).toEqual({ codigo: 'USD' });
    expect(whereJson(prisma.factura_det.findMany)).toContain(`{"moneda_id":"${USD}"}`);
  });

  it('USD sin cotización: fuera del convertido; en por_moneda sus ingresos van rotulados sin costo; en sin_cotizacion', async () => {
    const { r } = await rentabilidad([det('PYG', 1000000, 600000, null, 'f1'), det('USD', 100, 500000, null, 'f2')]);
    expect(r.en_moneda.resumen.ingresos_total).toBe(1000000);
    expect(r.en_moneda.resumen.costo_total).toBe(600000);
    expect(r.en_moneda.top_productos).toHaveLength(1);
    expect(r.sin_cotizacion).toBe(1);
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', ingresos: '1000000.00', costo: '600000.00', utilidad: '400000.00', ingresos_sin_costo: '0.00' },
      // ingresos − ingresos_sin_costo − costo = utilidad: la fila cierra y dice qué quedó sin costo.
      { codigo: 'USD', ingresos: '100.00', costo: '0.00', utilidad: '0.00', ingresos_sin_costo: '100.00' },
    ]);
  });
});

// ─────────────────────────── movimientos de caja ───────────────────────────

describe('GET /tesoreria/movimientos', () => {
  const crearTesoreria = (prisma: any) => {
    const svc = new TesoreriaService(prisma, undefined as any, undefined as any, undefined as any, undefined as any);
    const s: any = svc;
    jest.spyOn(s, 'enriquecerMovimientosConMedio').mockImplementation(async (_e: unknown, items: unknown) => items);
    jest.spyOn(s, 'referenciasLegibles').mockResolvedValue(new Map());
    jest.spyOn(s, 'totalesMovimientos').mockResolvedValue({});
    jest.spyOn(s, 'totalesPorMedio').mockResolvedValue([]);
    return svc;
  };

  it('cada ítem trae moneda.codigo; sin moneda_id, la base (F2)', async () => {
    const prisma = crearPrisma();
    prisma.movimiento_cajas.findMany.mockResolvedValue([
      { id: 'a', monto: 10, fecha_mov: new Date(), referencia: null, moneda_id: USD, moneda: { codigo: 'USD' } },
      { id: 'b', monto: 5000, fecha_mov: new Date(), referencia: null, moneda_id: null, moneda: null },
    ]);
    const r: any = await crearTesoreria(prisma).getMovimientos('emp', { usuarioId: 'usr' });
    expect(r.items.map((i: any) => i.moneda)).toEqual([{ codigo: 'USD' }, { codigo: 'PYG' }]);
    expect(prisma.movimiento_cajas.findMany.mock.calls[0][0].include.moneda).toEqual({ select: { codigo: true } });
  });

  it('sin moneda_id la respuesta trae la moneda base (los montos de caja están en la base, Reportes C-T1)', async () => {
    const prisma = crearPrisma();
    prisma.movimiento_cajas.findMany.mockResolvedValue([{ id: 'a', monto: 10, fecha_mov: new Date(), referencia: null, moneda_id: USD, moneda: { codigo: 'USD' } }]);
    const r: any = await crearTesoreria(prisma).getMovimientos('emp', { usuarioId: 'usr' });
    expect(r.moneda).toEqual({ id: PYG, codigo: 'PYG' });
  });

  it('sin moneda base cargada el listado no falla: la fila sin moneda sale con moneda null', async () => {
    const prisma = crearPrisma();
    prisma.empresa_monedas.findFirst.mockResolvedValue(null);
    prisma.moneda.findFirst.mockResolvedValue(null);
    prisma.movimiento_cajas.findMany.mockResolvedValue([{ id: 'b', monto: 5, fecha_mov: new Date(), referencia: null, moneda_id: null, moneda: null }]);
    const r: any = await crearTesoreria(prisma).getMovimientos('emp', { usuarioId: 'usr' });
    expect(r.items[0].moneda).toBeNull();
  });

  it('moneda_id distinto de la base → 400 MONEDA_INVALIDA; con la base incluye los sin moneda', async () => {
    const prisma = crearPrisma();
    await expect(crearTesoreria(prisma).getMovimientos('emp', { usuarioId: 'usr', moneda_id: USD })).rejects.toMatchObject({
      status: 400,
      response: { codigo: 'MONEDA_INVALIDA' },
    });
    expect(prisma.movimiento_cajas.findMany).not.toHaveBeenCalled();
    const prisma2 = crearPrisma();
    await crearTesoreria(prisma2).getMovimientos('emp', { usuarioId: 'usr', moneda_id: PYG });
    expect(whereJson(prisma2.movimiento_cajas.findMany)).toContain(`{"OR":[{"moneda_id":"${PYG}"},{"moneda_id":null}]}`);
    expect(whereJson(prisma2.movimiento_cajas.count)).toContain(`{"OR":[{"moneda_id":"${PYG}"},{"moneda_id":null}]}`);
  });
});
