import * as XLSX from 'xlsx';
import { tieneAlgunPrivilegio } from '../../auth/guards/algun-privilegio.guard';
import { TesReportesService } from './tes-reportes.service';

jest.mock('../../auth/guards/algun-privilegio.guard', () => ({ ...jest.requireActual('../../auth/guards/algun-privilegio.guard'), tieneAlgunPrivilegio: jest.fn() }));
const privilegio = tieneAlgunPrivilegio as jest.Mock;
const USER = 'u-1';
beforeEach(() => privilegio.mockReset().mockResolvedValue(true));

/**
 * Flujo de caja y Posición por moneda (C-T3). Prisma falso que respeta los filtros del where que usa el servicio
 * (fecha, cuenta_id, cuenta.moneda), así los casos se prueban por resultado y no por la forma del where.
 */

const EMP = '0e000000-0000-4000-8000-000000000001';
const ID_PYG = 'm0000000-0000-4000-8000-0000000000a1';
const ID_USD = 'm0000000-0000-4000-8000-0000000000b2';
const ID_ARS = 'm0000000-0000-4000-8000-0000000000c3';
const MONEDAS = [
  { id: ID_PYG, codigo: 'PYG' },
  { id: ID_USD, codigo: 'USD' },
  { id: ID_ARS, codigo: 'ARS' },
];

const CTA_GS = 'c0000000-0000-4000-8000-000000000001';
const CTA_USD = 'c0000000-0000-4000-8000-000000000002';
const CTA_ARS = 'c0000000-0000-4000-8000-000000000003';
const CUENTAS: Record<string, { nombre: string; moneda: string }> = {
  [CTA_GS]: { nombre: 'Banco Gs', moneda: 'PYG' },
  [CTA_USD]: { nombre: 'Banco USD', moneda: 'USD' },
  [CTA_ARS]: { nombre: 'Caja ARS', moneda: 'ARS' },
};

const fecha = (s: string) => new Date(`${s}T00:00:00.000Z`);
const PERIODO = { fecha_desde: '2026-06-01', fecha_hasta: '2026-06-30' };

type Det = { categoria: { nombre: string; tipo: string } | null };
const mov = (id: string, cuenta_id: string, tipo: 'INGRESO' | 'EGRESO', monto: number | string, dia = '2026-06-10', detalles: Det[] = []) => ({
  id,
  cuenta_id,
  fecha: fecha(dia),
  tipo,
  monto,
  descripcion: `desc ${id}`,
  cuenta: CUENTAS[cuenta_id],
  detalles,
  origen_tipo: null as string | null,
  transferencia_id: null as string | null,
});
const CTA_GS2 = 'c0000000-0000-4000-8000-000000000004';
CUENTAS[CTA_GS2] = { nombre: 'Caja Gs', moneda: 'PYG' };
/** Las dos puntas de una transferencia (tipo TRANSFERENCIA; el sentido sale de origen_tipo). */
const transf = (id: string, de: string, montoDe: number, a: string, montoA: number, dia = '2026-06-12') => [
  { ...mov(`${id}-o`, de, 'EGRESO', montoDe, dia), tipo: 'TRANSFERENCIA' as never, origen_tipo: 'TRANSFERENCIA_ORIGEN', transferencia_id: id },
  { ...mov(`${id}-d`, a, 'EGRESO', montoA, dia), tipo: 'TRANSFERENCIA' as never, origen_tipo: 'TRANSFERENCIA_DESTINO', transferencia_id: id },
];
const cat = (nombre: string, tipo: string): Det => ({ categoria: { nombre, tipo } });

type Opts = {
  movs?: ReturnType<typeof mov>[];
  cxc?: Array<{ cliente_id: string; saldo_pendiente: number | string | null; moneda_iso: string | null; fecha_vencimiento: Date }>;
  ops?: Array<{ proveedor_id: string; monto_total: number | string | null; moneda_id: string | null; fecha_pago: Date }>;
  base?: string | null; // id de la moneda principal; null = sin principal (cae en PYG del sistema)
  cuentas?: unknown[];
};

function armar(opts: Opts = {}) {
  const movs = opts.movs ?? [];
  const prisma = {
    tes_movimientos: {
      findMany: jest.fn(({ where }: { where: any }) =>
        Promise.resolve(movs.filter((m) => {
          if (where.transferencia_id?.in) return Boolean(m.transferencia_id && where.transferencia_id.in.includes(m.transferencia_id));
          const esPunta = m.origen_tipo === 'TRANSFERENCIA_ORIGEN' || m.origen_tipo === 'TRANSFERENCIA_DESTINO';
          if (where.OR && esPunta) return false; // el where de siempre excluye las puntas
          if (where.origen_tipo?.in && !where.origen_tipo.in.includes(m.origen_tipo)) return false;
          const f = where.fecha ?? {};
          if (f.gte && m.fecha < f.gte) return false;
          if (f.lt && m.fecha >= f.lt) return false;
          if (where.cuenta_id && m.cuenta_id !== where.cuenta_id) return false;
          if (where.cuenta?.moneda && m.cuenta.moneda !== where.cuenta.moneda) return false;
          return true;
        })),
      ),
    },
    tes_cuentas: { findMany: jest.fn().mockResolvedValue(opts.cuentas ?? []) },
    bancos: { findMany: jest.fn().mockResolvedValue([]) },
    cuentas_cobrar: { findMany: jest.fn().mockResolvedValue(opts.cxc ?? []) },
    orden_pago_proveedor_cab: { findMany: jest.fn().mockResolvedValue(opts.ops ?? []) },
    clientes: { findMany: jest.fn(({ where }: any) => Promise.resolve(where.id.in.map((id: string) => ({ id, persona_id: `p-${id}` })))) },
    proveedores: { findMany: jest.fn(({ where }: any) => Promise.resolve(where.id.in.map((id: string) => ({ id, persona_id: `p-${id}` })))) },
    personas: { findMany: jest.fn(({ where }: any) => Promise.resolve(where.id.in.map((id: string) => ({ id, razon_social: `RS ${id.slice(2)}` })))) },
    empresa_monedas: {
      findFirst: jest.fn().mockResolvedValue(opts.base === null ? null : { moneda_id: opts.base ?? ID_PYG }),
    },
    moneda: {
      findUnique: jest.fn(({ where }: any) => Promise.resolve(MONEDAS.find((m) => m.id === where.id) ?? null)),
      findFirst: jest.fn(({ where }: any) => Promise.resolve(MONEDAS.find((m) => m.codigo === where.codigo) ?? null)),
      findMany: jest.fn(({ where }: any) => Promise.resolve(MONEDAS.filter((m) => where.id.in.includes(m.id)))),
    },
  };
  const tesConfig = { get: jest.fn().mockResolvedValue(null) };
  return { prisma, service: new TesReportesService(prisma as never, tesConfig as never) };
}

const hojaComoFilas = (buf: Buffer, nombre: string): Record<string, unknown>[] => {
  const wb = XLSX.read(buf, { type: 'buffer' });
  const ws = wb.Sheets[nombre];
  if (!ws) throw new Error(`falta la hoja ${nombre}`);
  return XLSX.utils.sheet_to_json<Record<string, unknown>>(ws);
};

// ── Sin campos sumados: lo único que viaja son los bloques por moneda ────────────

const SUMADOS = ['totalIngresos', 'totalEgresos', 'resultado', 'porCategoria', 'movimientos', 'cobrosProyectados', 'pagosProyectados', 'resultadoProyectado', 'detalleCobros', 'detallePagos'];

describe('sin campos que sumen monedas en el nivel superior', () => {
  it('cashFlowReal solo trae período, moneda base y por_moneda', async () => {
    const { service } = armar({
      movs: [
        mov('a', CTA_GS, 'INGRESO', 1000000, '2026-06-02', [cat('Ventas', 'INGRESO')]),
        mov('b', CTA_USD, 'INGRESO', 500, '2026-06-03', [cat('Ventas', 'INGRESO')]),
      ],
    });
    const r = await service.cashFlowReal(EMP, PERIODO);
    expect(r).toMatchObject({ fecha_desde: '2026-06-01', fecha_hasta: '2026-06-30' });
    for (const campo of SUMADOS) expect(r).not.toHaveProperty(campo);
    expect(r.por_moneda.map((b) => [b.moneda, b.totalIngresos])).toEqual([['PYG', 1000000], ['USD', 500]]);
  });

  it('cashFlowProyectado tampoco: cobros y pagos esperados solo dentro de cada bloque', async () => {
    const { service } = armar({
      movs: [mov('a', CTA_GS, 'INGRESO', 1000)],
      cxc: [
        { cliente_id: 'k1', saldo_pendiente: 200, moneda_iso: null, fecha_vencimiento: fecha('2026-06-15') },
        { cliente_id: 'k2', saldo_pendiente: 50, moneda_iso: 'USD', fecha_vencimiento: fecha('2026-06-16') },
      ],
      ops: [{ proveedor_id: 'v1', monto_total: 30, moneda_id: ID_USD, fecha_pago: fecha('2026-06-20') }],
    });
    const r = await service.cashFlowProyectado(EMP, PERIODO);
    for (const campo of SUMADOS) expect(r).not.toHaveProperty(campo);
    expect(Object.keys(r).sort()).toEqual(['fecha_desde', 'fecha_hasta', 'moneda_base', 'por_moneda']);
    expect(r.por_moneda.find((b) => b.moneda === 'PYG')).toMatchObject({ cobrosProyectados: 200, pagosProyectados: 0 });
    expect(r.por_moneda.find((b) => b.moneda === 'USD')).toMatchObject({ cobrosProyectados: 50, pagosProyectados: 30 });
  });

  it('posicionCaja agrupa por moneda con su total y cuenta las cuentas', async () => {
    const { service } = armar({
      cuentas: [
        { id: '1', nombre: 'A', tipo: 'BANCO', moneda: 'PYG', banco_id: null, saldo_actual: 100 },
        { id: '2', nombre: 'B', tipo: 'CAJA', moneda: 'PYG', banco_id: null, saldo_actual: 50 },
        { id: '3', nombre: 'C', tipo: 'BANCO', moneda: 'USD', banco_id: null, saldo_actual: 7 },
      ],
    });
    const r = await service.posicionCaja(EMP);
    expect(r.totalCuentas).toBe(3);
    expect(r.resumen.map((g) => [g.moneda, g.total, g.cuentas.length])).toEqual([
      ['PYG', 150, 2],
      ['USD', 7, 1],
    ]);
  });

  it('cashFlowRealExcel: hoja Movimientos con Fecha, Cuenta, Moneda, Tipo, Descripción, Categorías y Monto', async () => {
    const { service } = armar({ movs: [mov('b', CTA_USD, 'INGRESO', 500, '2026-06-03', [cat('Ventas', 'INGRESO')])] });
    const filas = hojaComoFilas(await service.cashFlowRealExcel(EMP, USER, PERIODO), 'Movimientos');
    expect(filas).toHaveLength(1);
    expect(filas[0]).toMatchObject({ Cuenta: 'Banco USD', Moneda: 'USD', Tipo: 'INGRESO', Descripción: 'desc b', Categorías: 'Ventas', Monto: 500 });
  });
});

// ── C-T3: bloques por moneda ─────────────────────────────────────────────────────────────────────────────────────

const monedas = (r: { por_moneda: Array<{ moneda: string }> }) => r.por_moneda.map((b) => b.moneda);

describe('cashFlowReal · por_moneda', () => {
  const dos = () =>
    armar({
      movs: [
        mov('g1', CTA_GS, 'INGRESO', 1000000, '2026-06-02', [cat('Ventas', 'INGRESO')]),
        mov('u1', CTA_USD, 'INGRESO', 500, '2026-06-03', [cat('Ventas', 'INGRESO')]),
        mov('g2', CTA_GS, 'EGRESO', 300000, '2026-06-04', [cat('Sueldos', 'EGRESO')]),
        mov('u2', CTA_USD, 'EGRESO', 120.5, '2026-06-05'),
      ],
    });

  it('dos monedas → dos bloques, cada uno con lo suyo; ningún bloque con 1.000.500', async () => {
    const r = await dos().service.cashFlowReal(EMP, PERIODO);
    expect(r.por_moneda).toHaveLength(2);
    expect(r.por_moneda[0]).toMatchObject({ moneda: 'PYG', totalIngresos: 1000000, totalEgresos: 300000, resultado: 700000 });
    expect(r.por_moneda[1]).toMatchObject({ moneda: 'USD', totalIngresos: 500, totalEgresos: 120.5, resultado: 379.5 });
    for (const b of r.por_moneda) expect(b.totalIngresos).not.toBe(1000500);
  });

  it('porCategoria y movimientos de cada bloque son solo de su moneda', async () => {
    const r = await dos().service.cashFlowReal(EMP, PERIODO);
    const [gs, usd] = r.por_moneda;
    expect(gs.porCategoria).toEqual([
      { nombre: 'Ventas', tipo: 'INGRESO', total: 1000000, cantidad: 1 },
      { nombre: 'Sueldos', tipo: 'EGRESO', total: 300000, cantidad: 1 },
    ]);
    expect(usd.porCategoria).toEqual([
      { nombre: 'Ventas', tipo: 'INGRESO', total: 500, cantidad: 1 },
      { nombre: 'Sin categoría', tipo: 'EGRESO', total: 120.5, cantidad: 1 },
    ]);
    expect(gs.movimientos.map((m) => m.id)).toEqual(['g1', 'g2']);
    expect(usd.movimientos.map((m) => m.id)).toEqual(['u1', 'u2']);
    expect(usd.movimientos[0]).toEqual({ id: 'u1', fecha: fecha('2026-06-03'), cuenta: 'Banco USD', moneda: 'USD', tipo: 'INGRESO', monto: 500, descripcion: 'desc u1', categorias: ['Ventas'] });
  });

  it('el real no trae los campos del proyectado en sus bloques', async () => {
    const r = await dos().service.cashFlowReal(EMP, PERIODO);
    expect(r.por_moneda[0]).not.toHaveProperty('cobrosProyectados');
  });

  it('decimales sin error de coma flotante: 0,1 + 0,2 = 0,3', async () => {
    const { service } = armar({ movs: [mov('a', CTA_USD, 'INGRESO', '0.10'), mov('b', CTA_USD, 'INGRESO', '0.20')] });
    const r = await service.cashFlowReal(EMP, PERIODO);
    expect(r.por_moneda[0].totalIngresos).toBe(0.3);
  });

  it('la base va primero aunque su código sea alfabéticamente posterior; las demás por código', async () => {
    const { service } = armar({
      base: ID_USD,
      movs: [mov('g', CTA_GS, 'INGRESO', 10), mov('a', CTA_ARS, 'INGRESO', 20), mov('u', CTA_USD, 'INGRESO', 30)],
    });
    expect(monedas(await service.cashFlowReal(EMP, PERIODO))).toEqual(['USD', 'ARS', 'PYG']);
  });

  it('sin moneda principal cargada la base es PYG del sistema y va primera', async () => {
    const { service } = armar({ base: null, movs: [mov('a', CTA_ARS, 'INGRESO', 20), mov('g', CTA_GS, 'INGRESO', 10)] });
    expect(monedas(await service.cashFlowReal(EMP, PERIODO))).toEqual(['PYG', 'ARS']);
  });

  it('sin movimientos → por_moneda = []', async () => {
    const r = await armar().service.cashFlowReal(EMP, PERIODO);
    expect(r.por_moneda).toEqual([]);
  });

  it('moneda=USD deja solo ese bloque', async () => {
    const r = await dos().service.cashFlowReal(EMP, { ...PERIODO, moneda: 'USD' });
    expect(monedas(r)).toEqual(['USD']);
    expect(r.por_moneda[0].totalIngresos).toBe(500);
  });

  it('cuenta_id de una cuenta USD → solo USD', async () => {
    const r = await dos().service.cashFlowReal(EMP, { ...PERIODO, cuenta_id: CTA_USD });
    expect(monedas(r)).toEqual(['USD']);
  });

  it('fecha_desde > fecha_hasta → 400 PERIODO_INVALIDO, sin leer movimientos', async () => {
    const { service, prisma } = armar();
    await expect(service.cashFlowReal(EMP, { fecha_desde: '2026-07-01', fecha_hasta: '2026-06-01' })).rejects.toMatchObject({
      status: 400,
      response: expect.objectContaining({ codigo: 'PERIODO_INVALIDO' }),
    });
    expect(prisma.tes_movimientos.findMany).not.toHaveBeenCalled();
  });

  it.each([
    ['falta desde', { fecha_hasta: '2026-06-30' }],
    ['falta hasta', { fecha_desde: '2026-06-01' }],
    ['fecha que no es AAAA-MM-DD', { fecha_desde: '01/06/2026', fecha_hasta: '2026-06-30' }],
    ['día que no existe', { fecha_desde: '2026-02-30', fecha_hasta: '2026-06-30' }],
  ])('%s → 400 PERIODO_INVALIDO (antes: Invalid Date)', async (_n, filtro) => {
    const { service, prisma } = armar();
    await expect(service.cashFlowReal(EMP, filtro as never)).rejects.toMatchObject({ status: 400, response: expect.objectContaining({ codigo: 'PERIODO_INVALIDO' }) });
    expect(prisma.tes_movimientos.findMany).not.toHaveBeenCalled();
  });
});

describe('cashFlowProyectado · por_moneda', () => {
  const armarProy = () =>
    armar({
      movs: [mov('g1', CTA_GS, 'INGRESO', 1000000), mov('g2', CTA_GS, 'EGRESO', 400000), mov('u1', CTA_USD, 'INGRESO', 500)],
      cxc: [
        { cliente_id: 'k1', saldo_pendiente: 200000, moneda_iso: null, fecha_vencimiento: fecha('2026-06-15') },
        { cliente_id: 'k2', saldo_pendiente: '75.25', moneda_iso: 'USD', fecha_vencimiento: fecha('2026-06-16') },
        { cliente_id: 'k3', saldo_pendiente: 100000, moneda_iso: 'PYG', fecha_vencimiento: fecha('2026-06-17') },
      ],
      ops: [
        { proveedor_id: 'v1', monto_total: 30, moneda_id: ID_USD, fecha_pago: fecha('2026-06-20') },
        { proveedor_id: 'v2', monto_total: 50000, moneda_id: null, fecha_pago: fecha('2026-06-21') },
      ],
    });

  it('si la lectura de órdenes de pago o de proveedores falla, el error sube (no sale un resultado sin pagos)', async () => {
    const a = armarProy();
    a.prisma.orden_pago_proveedor_cab.findMany.mockRejectedValue(new Error('OP caída'));
    await expect(a.service.cashFlowProyectado(EMP, PERIODO)).rejects.toThrow('OP caída');
    const b = armarProy();
    b.prisma.proveedores.findMany.mockRejectedValue(new Error('proveedores caída'));
    await expect(b.service.cashFlowProyectado(EMP, PERIODO)).rejects.toThrow('proveedores caída');
  });

  it('CxC sin moneda_iso cuenta en la base; OP en USD cae en el bloque USD; nada se mezcla', async () => {
    const r = await armarProy().service.cashFlowProyectado(EMP, PERIODO);
    expect(monedas(r)).toEqual(['PYG', 'USD']);
    const [gs, usd] = r.por_moneda;
    expect(gs).toMatchObject({ cobrosProyectados: 300000, pagosProyectados: 50000 });
    expect(usd).toMatchObject({ cobrosProyectados: 75.25, pagosProyectados: 30 });
    expect(gs.detalleCobros).toEqual([
      { cliente: 'RS k1', monto: 200000, vencimiento: fecha('2026-06-15') },
      { cliente: 'RS k3', monto: 100000, vencimiento: fecha('2026-06-17') },
    ]);
    expect(usd.detalleCobros).toEqual([{ cliente: 'RS k2', monto: 75.25, vencimiento: fecha('2026-06-16') }]);
    expect(usd.detallePagos).toEqual([{ proveedor: 'RS v1', monto: 30, fecha: fecha('2026-06-20') }]);
    expect(gs.detallePagos).toEqual([{ proveedor: 'RS v2', monto: 50000, fecha: fecha('2026-06-21') }]);
  });

  it('resultadoProyectado de cada bloque = su resultado + cobros − pagos', async () => {
    const r = await armarProy().service.cashFlowProyectado(EMP, PERIODO);
    const [gs, usd] = r.por_moneda;
    expect(gs).toMatchObject({ resultado: 600000, resultadoProyectado: 600000 + 300000 - 50000 });
    expect(usd).toMatchObject({ resultado: 500, resultadoProyectado: 545.25 });
    for (const b of r.por_moneda) expect(b.resultadoProyectado).toBeCloseTo(b.resultado + b.cobrosProyectados - b.pagosProyectados, 2);
  });

  it('una moneda que solo tiene proyectado (CxC en ARS sin movimientos) arma su bloque con el real en 0', async () => {
    const { service } = armar({ cxc: [{ cliente_id: 'k1', saldo_pendiente: 9, moneda_iso: 'ARS', fecha_vencimiento: fecha('2026-06-15') }] });
    const r = await service.cashFlowProyectado(EMP, PERIODO);
    expect(r.por_moneda).toEqual([
      expect.objectContaining({ moneda: 'ARS', totalIngresos: 0, totalEgresos: 0, resultado: 0, porCategoria: [], movimientos: [], cobrosProyectados: 9, pagosProyectados: 0, resultadoProyectado: 9, detallePagos: [] }),
    ]);
  });

  it('sin datos → []', async () => {
    expect((await armar().service.cashFlowProyectado(EMP, PERIODO)).por_moneda).toEqual([]);
  });

  it('periodo incompleto → 400 PERIODO_INVALIDO', async () => {
    const { service } = armar();
    await expect(service.cashFlowProyectado(EMP, { fecha_desde: '2026-06-01' } as never)).rejects.toMatchObject({ status: 400, response: expect.objectContaining({ codigo: 'PERIODO_INVALIDO' }) });
  });

  it('el proyectado no gana filtros: cuenta_id y moneda no llegan al real ni a CxC/OP (ruling)', async () => {
    const { service } = armarProy();
    const r = await service.cashFlowProyectado(EMP, { ...PERIODO, cuenta_id: CTA_USD, moneda: 'USD' } as never);
    expect(monedas(r)).toEqual(['PYG', 'USD']);
  });
});

describe('posicionCaja · fecha', () => {
  afterEach(() => jest.useRealTimers());
  it('reloj 2026-11-08T01:30:00Z → fecha 2026-11-07 (día de Paraguay)', async () => {
    jest.useFakeTimers({ now: new Date('2026-11-08T01:30:00Z') });
    const r = await armar().service.posicionCaja(EMP);
    expect(r.fecha).toBe('2026-11-07');
  });
});

describe('flujoCajaOpciones', () => {
  it('devuelve las cuentas con cerradas (activo: false) y la moneda base', async () => {
    const { service, prisma } = armar({
      base: ID_USD,
      cuentas: [
        { id: CTA_GS, nombre: 'Banco Gs', moneda: 'PYG', activo: true },
        { id: CTA_USD, nombre: 'Banco USD', moneda: 'USD', activo: false },
      ],
    });
    const r = await service.flujoCajaOpciones(EMP);
    expect(r).toEqual({
      cuentas: [
        { id: CTA_GS, nombre: 'Banco Gs', moneda: 'PYG', activo: true },
        { id: CTA_USD, nombre: 'Banco USD', moneda: 'USD', activo: false },
      ],
      moneda_base: 'USD',
    });
    const args = prisma.tes_cuentas.findMany.mock.calls[0][0];
    expect(args.where).toEqual({ empresa_id: EMP });
    expect(args.select).toEqual({ id: true, nombre: true, moneda: true, activo: true });
  });

  it('sin moneda que resolver → moneda_base null', async () => {
    const { service, prisma } = armar({ base: null });
    prisma.moneda.findFirst.mockResolvedValue(null);
    expect((await service.flujoCajaOpciones(EMP)).moneda_base).toBeNull();
  });
});

describe('Excel del flujo y la posición', () => {
  const dos = () =>
    armar({
      movs: [
        mov('g1', CTA_GS, 'INGRESO', 1000000, '2026-06-02', [cat('Ventas', 'INGRESO')]),
        mov('u1', CTA_USD, 'INGRESO', 500, '2026-06-03', [cat('Ventas', 'INGRESO')]),
        mov('g2', CTA_GS, 'EGRESO', 300000, '2026-06-04'),
      ],
      cxc: [{ cliente_id: 'k2', saldo_pendiente: 75, moneda_iso: 'USD', fecha_vencimiento: fecha('2026-06-16') }],
      ops: [{ proveedor_id: 'v2', monto_total: 50000, moneda_id: null, fecha_pago: fecha('2026-06-21') }],
    });
  const valores = (filas: Record<string, unknown>[]) => filas.flatMap((f) => Object.values(f));

  it('cashFlowRealExcel · Resumen: columna Moneda, una fila por concepto y moneda; ningún total mezcla', async () => {
    const filas = hojaComoFilas(await dos().service.cashFlowRealExcel(EMP, USER, PERIODO), 'Resumen');
    expect(filas).toEqual([
      { Concepto: 'Período', Valor: '2026-06-01 → 2026-06-30' },
      { Concepto: 'Ingresos', Moneda: 'PYG', Valor: 1000000 },
      { Concepto: 'Egresos', Moneda: 'PYG', Valor: 300000 },
      { Concepto: 'Resultado', Moneda: 'PYG', Valor: 700000 },
      { Concepto: 'Ingresos', Moneda: 'USD', Valor: 500 },
      { Concepto: 'Egresos', Moneda: 'USD', Valor: 0 },
      { Concepto: 'Resultado', Moneda: 'USD', Valor: 500 },
    ]);
    expect(valores(filas)).not.toContain(1000500);
  });

  it('cashFlowRealExcel · Por Categoría con Moneda, una fila por categoría y moneda', async () => {
    const filas = hojaComoFilas(await dos().service.cashFlowRealExcel(EMP, USER, PERIODO), 'Por Categoría');
    expect(filas).toEqual([
      { Moneda: 'PYG', Categoría: 'Ventas', Tipo: 'INGRESO', Total: 1000000, Cantidad: 1 },
      { Moneda: 'PYG', Categoría: 'Sin categoría', Tipo: 'EGRESO', Total: 300000, Cantidad: 1 },
      { Moneda: 'USD', Categoría: 'Ventas', Tipo: 'INGRESO', Total: 500, Cantidad: 1 },
    ]);
  });

  it('cashFlowRealExcel · Movimientos trae Moneda en cada fila, agrupado por moneda', async () => {
    const filas = hojaComoFilas(await dos().service.cashFlowRealExcel(EMP, USER, PERIODO), 'Movimientos');
    expect(filas.map((f) => [f.Moneda, f.Monto])).toEqual([
      ['PYG', 1000000],
      ['PYG', 300000],
      ['USD', 500],
    ]);
  });

  it('cashFlowRealExcel sin filas: el Resumen solo trae el período', async () => {
    const filas = hojaComoFilas(await armar().service.cashFlowRealExcel(EMP, USER, PERIODO), 'Resumen');
    expect(filas).toEqual([{ Concepto: 'Período', Valor: '2026-06-01 → 2026-06-30' }]);
  });

  it('cashFlowProyectadoExcel · Resumen Proyectado por moneda y CxC/CxP con Moneda; nada mezcla', async () => {
    const buf = await dos().service.cashFlowProyectadoExcel(EMP, USER, PERIODO);
    const resumen = hojaComoFilas(buf, 'Resumen Proyectado');
    expect(resumen).toEqual([
      { Concepto: 'Período', Valor: '2026-06-01 → 2026-06-30' },
      { Concepto: 'Ingresos reales', Moneda: 'PYG', Valor: 1000000 },
      { Concepto: 'Egresos reales', Moneda: 'PYG', Valor: 300000 },
      { Concepto: 'Resultado real', Moneda: 'PYG', Valor: 700000 },
      { Concepto: 'Cobros proyectados (CxC)', Moneda: 'PYG', Valor: 0 },
      { Concepto: 'Pagos proyectados (CxP)', Moneda: 'PYG', Valor: 50000 },
      { Concepto: 'Resultado proyectado', Moneda: 'PYG', Valor: 650000 },
      { Concepto: 'Ingresos reales', Moneda: 'USD', Valor: 500 },
      { Concepto: 'Egresos reales', Moneda: 'USD', Valor: 0 },
      { Concepto: 'Resultado real', Moneda: 'USD', Valor: 500 },
      { Concepto: 'Cobros proyectados (CxC)', Moneda: 'USD', Valor: 75 },
      { Concepto: 'Pagos proyectados (CxP)', Moneda: 'USD', Valor: 0 },
      { Concepto: 'Resultado proyectado', Moneda: 'USD', Valor: 575 },
    ]);
    expect(hojaComoFilas(buf, 'CxC Proyectados').map((f) => [f.Moneda, f.Cliente, f.Monto])).toEqual([['USD', 'RS k2', 75]]);
    expect(hojaComoFilas(buf, 'CxP Proyectados').map((f) => [f.Moneda, f.Proveedor, f.Monto])).toEqual([['PYG', 'RS v2', 50000]]);
  });

  it('posicionCajaExcel: TOTAL por moneda con su columna Moneda (sin total general)', async () => {
    const { service } = armar({
      cuentas: [
        { id: '1', nombre: 'A', tipo: 'BANCO', moneda: 'PYG', banco_id: null, saldo_actual: 100 },
        { id: '3', nombre: 'C', tipo: 'BANCO', moneda: 'USD', banco_id: null, saldo_actual: 7 },
      ],
    });
    const filas = hojaComoFilas(await service.posicionCajaExcel(EMP, USER), 'Posición de Caja');
    expect(filas.filter((f) => typeof f.Cuenta === 'string' && f.Cuenta.startsWith('TOTAL'))).toEqual([
      { Cuenta: 'TOTAL PYG', Moneda: 'PYG', 'Saldo Actual': 100 },
      { Cuenta: 'TOTAL USD', Moneda: 'USD', 'Saldo Actual': 7 },
    ]);
  });

  it.each([
    ['cashFlowRealExcel', 'TES_REP_FLUJO_CAJA_VER'],
    ['cashFlowProyectadoExcel', 'TES_REP_FLUJO_CAJA_VER'],
    ['posicionCajaExcel', 'TES_REP_LIBRO_CAJA_VER'],
  ] as const)('%s exige también %s: sin él 403 SIN_PERMISO_VER_REPORTE y no lee datos', async (metodo, ver) => {
    privilegio.mockResolvedValue(false);
    const { service, prisma } = dos();
    const llamar = metodo === 'posicionCajaExcel' ? service.posicionCajaExcel(EMP, USER) : service[metodo](EMP, USER, PERIODO);
    await expect(llamar).rejects.toMatchObject({ status: 403, response: expect.objectContaining({ codigo: 'SIN_PERMISO_VER_REPORTE' }) });
    expect(privilegio).toHaveBeenCalledWith(prisma, USER, [ver]);
    expect(prisma.tes_movimientos.findMany).not.toHaveBeenCalled();
    expect(prisma.tes_cuentas.findMany).not.toHaveBeenCalled();
  });
});

describe('TesController · los /excel pasan el usuario al servicio (para exigir el VER)', () => {
  // eslint-disable-next-line @typescript-eslint/no-require-imports
  const { TesController } = require('../tes.controller');
  const user = { id: USER, empresa_id: EMP };
  const res = () => ({ set: jest.fn(), send: jest.fn() });
  const tesReportes = {
    posicionCajaExcel: jest.fn().mockResolvedValue(Buffer.from('x')),
    cashFlowRealExcel: jest.fn().mockResolvedValue(Buffer.from('x')),
    cashFlowProyectadoExcel: jest.fn().mockResolvedValue(Buffer.from('x')),
  };
  const ctx = { tesReportes };

  it('posición, real y proyectado', async () => {
    await TesController.prototype.posicionCajaExcel.call(ctx, user, res());
    expect(tesReportes.posicionCajaExcel).toHaveBeenCalledWith(EMP, USER);
    await TesController.prototype.cashFlowRealExcel.call(ctx, user, res(), '2026-06-01', '2026-06-30', CTA_USD, 'USD');
    expect(tesReportes.cashFlowRealExcel).toHaveBeenCalledWith(EMP, USER, { fecha_desde: '2026-06-01', fecha_hasta: '2026-06-30', cuenta_id: CTA_USD, moneda: 'USD' });
    await TesController.prototype.cashFlowProyectadoExcel.call(ctx, user, res(), '2026-06-01', '2026-06-30');
    expect(tesReportes.cashFlowProyectadoExcel).toHaveBeenCalledWith(EMP, USER, { fecha_desde: '2026-06-01', fecha_hasta: '2026-06-30' });
  });
});

// ── Ronda 1 ─────────────────────────────────────────────────────────────────────────────────────────────────────

describe('Ronda 1 · fechas fuera de rango', () => {
  it.each(['2026-13-01', '2026-06-32', '2026-00-10'])('%s → 400 PERIODO_INVALIDO (no 500)', async (dia) => {
    const { service, prisma } = armar();
    await expect(service.cashFlowReal(EMP, { fecha_desde: dia, fecha_hasta: '2026-12-31' })).rejects.toMatchObject({ status: 400, response: expect.objectContaining({ codigo: 'PERIODO_INVALIDO' }) });
    await expect(service.cashFlowProyectado(EMP, { fecha_desde: '2026-01-01', fecha_hasta: dia })).rejects.toMatchObject({ status: 400, response: expect.objectContaining({ codigo: 'PERIODO_INVALIDO' }) });
    expect(prisma.tes_movimientos.findMany).not.toHaveBeenCalled();
  });
});

describe('Ronda 1 · transferencias en el flujo por moneda', () => {
  const compraUsd = () =>
    armar({
      movs: [
        mov('g1', CTA_GS, 'INGRESO', 1000000, '2026-06-02'),
        ...transf('t1', CTA_GS, 7400000, CTA_USD, 1000), // compra de dólares
        ...transf('t2', CTA_GS, 50000, CTA_GS2, 50000), // entre cuentas en Gs: se anula, no cuenta
      ],
    });

  it('entre monedas distintas: salida en el bloque de origen, entrada en el de destino, cada una con su monto', async () => {
    const r = await compraUsd().service.cashFlowReal(EMP, PERIODO);
    const [gs, usd] = r.por_moneda;
    expect(gs).toMatchObject({ moneda: 'PYG', totalIngresos: 1000000, totalEgresos: 7400000, resultado: -6400000 });
    expect(usd).toMatchObject({ moneda: 'USD', totalIngresos: 1000, totalEgresos: 0, resultado: 1000 });
    expect(usd.movimientos).toEqual([
      { id: 't1-d', fecha: fecha('2026-06-12'), cuenta: 'Banco USD', moneda: 'USD', tipo: 'INGRESO', monto: 1000, descripcion: 'desc t1-d', categorias: ['Transferencia'] },
    ]);
    expect(gs.movimientos.map((m) => [m.id, m.tipo])).toEqual([['g1', 'INGRESO'], ['t1-o', 'EGRESO']]);
    expect(usd.porCategoria).toEqual([{ nombre: 'Transferencia', tipo: 'INGRESO', total: 1000, cantidad: 1 }]);
    expect(gs.porCategoria).toContainEqual({ nombre: 'Transferencia', tipo: 'EGRESO', total: 7400000, cantidad: 1 });
  });

  it('entre cuentas de la misma moneda sigue excluida', async () => {
    const r = await compraUsd().service.cashFlowReal(EMP, PERIODO);
    const ids = r.por_moneda.flatMap((b) => b.movimientos.map((m) => m.id));
    expect(ids).not.toContain('t2-o');
    expect(ids).not.toContain('t2-d');
  });

  it('moneda=USD trae la entrada aunque la otra punta (PYG) quede fuera del filtro', async () => {
    const r = await compraUsd().service.cashFlowReal(EMP, { ...PERIODO, moneda: 'USD' });
    expect(r.por_moneda).toEqual([expect.objectContaining({ moneda: 'USD', totalIngresos: 1000 })]);
  });

  it('cuenta_id de la cuenta en Gs trae su salida a USD y no la transferencia a la otra cuenta en Gs', async () => {
    const r = await compraUsd().service.cashFlowReal(EMP, { ...PERIODO, cuenta_id: CTA_GS });
    expect(r.por_moneda.map((b) => [b.moneda, b.totalEgresos])).toEqual([['PYG', 7400000]]);
  });

  it('el proyectado arma sus bloques con las transferencias entre monedas', async () => {
    const r = await compraUsd().service.cashFlowProyectado(EMP, PERIODO);
    expect(r.por_moneda.map((b) => [b.moneda, b.resultado, b.resultadoProyectado])).toEqual([['PYG', -6400000, -6400000], ['USD', 1000, 1000]]);
  });
});
