/**
 * D-T4: Cierre de cobros por alcance de sucursal y por moneda.
 *  - `sucursalId` pasa por `exigirSucursalEnAlcance` (403) y, sin pedirla, el SQL recorta a las sucursales del usuario.
 *  - `monedaId` se resuelve como el Tablero (`resolverMonedaTablero`: ajena → 400) DESPUÉS del alcance (403 antes que
 *    400). Con la base entra el recibo de moneda nula (`whereMonedaTablero`).
 *  - Lo nuevo va al lado de lo de siempre: `moneda`, `convertido`, `sin_cotizacion`, `sin_moneda` y
 *    `en_moneda { totalGeneral, porDia, porCondicion, porMedio }` (cada recibo con su cotización a la base).
 */
import { BadRequestException, ForbiddenException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { CobrosService } from './cobros.service';
import { CobrosController } from './cobros.controller';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';

jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn(),
}));

const PYG = { id: '11111111-1111-4111-8111-111111111111', codigo: 'PYG' };
const USD = { id: '22222222-2222-4222-8222-222222222222', codigo: 'USD' };
const SUC_A = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
const SUC_B = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
const SUC_C = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc';
const T = (iso: string) => new Date(iso);
const sqlDe = (call: any[]) => Prisma.sql(call[0], ...call.slice(1));
const restringido = (sucursalIds: string[]) => ({ sucursalIds, puntosEstablecimiento: [], depositoIds: [] });

type Rec = { id: string; monto: string; moneda: typeof PYG | null; cotizacion: string | null; fecha?: string };

/** Prisma falso: recibos del SQL + su cabecera (moneda/cotización) para `monedasDeRecibos`. */
function prismaCon(recs: Rec[], extra: { lineas?: any[]; multi?: any[]; legacy?: any[]; anulados?: any[]; sucursalDeLaEmpresa?: boolean } = {}) {
  const filasSql = recs.map((r) => ({
    recibo_id: r.id,
    numero_recibo: r.id.toUpperCase(),
    fecha: T(`${r.fecha ?? '2026-11-02'}T00:00:00Z`),
    cliente_razon: 'Alfa',
    cobrador_nombre: 'Ana',
    usuario_nombre: 'Caja',
    modo: 'MULTI',
    monto_total: r.monto,
    moneda_codigo: r.moneda?.codigo ?? null,
  }));
  const lineas = extra.lineas ?? recs.map((r) => ({ recibo_id: r.id, factura_cab_id: `f-${r.id}`, monto_pagado: r.monto, condicion_codigo: 1, dcuotas: null, cuotas_count: 1, avg_dias_intervalo: null }));
  const multi = extra.multi ?? recs.map((r) => ({ recibo_id: r.id, medio: 'EFECTIVO', monto: r.monto }));
  // Después de los emitidos va la consulta de anulados (el detalle por recibo los lista).
  const q = jest.fn().mockResolvedValueOnce(filasSql).mockResolvedValueOnce(extra.anulados ?? []);
  if (recs.length) q.mockResolvedValueOnce(lineas).mockResolvedValueOnce(multi).mockResolvedValueOnce(extra.legacy ?? []);
  return {
    $queryRaw: q,
    empresas_sucursales: { findFirst: jest.fn().mockResolvedValue(extra.sucursalDeLaEmpresa === false ? null : { id: 'x' }) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: PYG.id }) },
    moneda: {
      findFirst: jest.fn().mockResolvedValue(null),
      findUnique: jest.fn(({ where }: any) => Promise.resolve([PYG, USD].find((m) => m.id === where.id) ?? null)),
      findMany: jest.fn(({ where }: any) => Promise.resolve([PYG, USD].filter((m) => where.id.in.includes(m.id)))),
    },
    recibos_cobro: {
      findMany: jest.fn((a: any) =>
        Promise.resolve(
          recs
            .filter((r) => a.where.id.in.includes(r.id))
            .map((r) => ({ id: r.id, empresa_id: 'emp', moneda_id: r.moneda?.id ?? null, cotizacion: r.cotizacion === null ? null : new Prisma.Decimal(r.cotizacion) })),
        ),
      ),
    },
    empresas: { findUnique: jest.fn().mockResolvedValue({ razon_social: 'Emp' }) },
  };
}
const servicio = (prisma: any) => new (CobrosService as any)(prisma) as CobrosService;

beforeEach(() => {
  (alcanceSucursalUsuario as jest.Mock).mockReset().mockResolvedValue(null);
});

describe('Cierre de cobros: alcance de sucursal', () => {
  it('restringido a A que pide B → 403 sin consultar recibos', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    const prisma = prismaCon([]);
    await expect(servicio(prisma).getCierreCobros('emp', { sucursalId: SUC_B }, 'usr')).rejects.toBeInstanceOf(ForbiddenException);
    expect(prisma.$queryRaw).not.toHaveBeenCalled();
    expect(alcanceSucursalUsuario).toHaveBeenCalledWith(prisma, 'usr', 'emp');
  });

  it('el 403 sale antes que el 400 de moneda', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    const prisma = prismaCon([]);
    await expect(servicio(prisma).getCierreCobros('emp', { sucursalId: SUC_B, monedaId: 'no-es-uuid' }, 'usr')).rejects.toBeInstanceOf(
      ForbiddenException,
    );
  });

  it('sucursal de otra empresa (admin sin recorte) → 403', async () => {
    const prisma = prismaCon([], { sucursalDeLaEmpresa: false });
    await expect(servicio(prisma).getCierreCobros('emp', { sucursalId: SUC_B }, 'usr')).rejects.toBeInstanceOf(ForbiddenException);
    expect(prisma.empresas_sucursales.findFirst).toHaveBeenCalledWith({
      where: { id: SUC_B, empresa_id: 'emp', active: { not: false } },
      select: { id: true },
    });
  });

  it('restringido a A sin pedir sucursal: el SQL recorta a A', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    const prisma = prismaCon([]);
    await servicio(prisma).getCierreCobros('emp', {}, 'usr');
    const q = sqlDe(prisma.$queryRaw.mock.calls[0]);
    expect(q.text).toMatch(/AND r\.sucursal_id = \$3::uuid/);
    expect(q.values).toEqual(['emp', 'emitido', SUC_A]);
  });

  it('restringido a A y C sin pedir: IN (A, C)', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A, SUC_C]));
    const prisma = prismaCon([]);
    await servicio(prisma).getCierreCobros('emp', {}, 'usr');
    const q = sqlDe(prisma.$queryRaw.mock.calls[0]);
    expect(q.text.replace(/\s+/g, ' ')).toContain('AND r.sucursal_id IN ($3::uuid,$4::uuid)');
    expect(q.values).toEqual(['emp', 'emitido', SUC_A, SUC_C]);
  });

  it('alcance vacío (todas sus sucursales desactivadas): no ve nada', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([]));
    const prisma = prismaCon([]);
    await servicio(prisma).getCierreCobros('emp', {}, 'usr');
    const q = sqlDe(prisma.$queryRaw.mock.calls[0]);
    expect(q.text).toMatch(/AND FALSE/);
    expect(q.values).toEqual(['emp', 'emitido']);
  });

  it('restringido a A que pide A: igualdad con A', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A, SUC_C]));
    const prisma = prismaCon([]);
    await servicio(prisma).getCierreCobros('emp', { sucursalId: SUC_A }, 'usr');
    const q = sqlDe(prisma.$queryRaw.mock.calls[0]);
    expect(q.text).toMatch(/AND r\.sucursal_id = \$3::uuid/);
    expect(q.values).toEqual(['emp', 'emitido', SUC_A]);
  });

  it('el PDF pasa el usuario y corta con el mismo 403', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    const prisma = prismaCon([]);
    await expect(servicio(prisma).exportarCierreCobrosPDF('emp', { sucursalId: SUC_B }, 'usr')).rejects.toBeInstanceOf(ForbiddenException);
    expect(prisma.$queryRaw).not.toHaveBeenCalled();
  });

  it('el controller pasa user.id al servicio (JSON y PDF)', async () => {
    const svc = { getCierreCobros: jest.fn().mockResolvedValue({}), exportarCierreCobrosPDF: jest.fn().mockResolvedValue(Buffer.from('x')) };
    const ctrl = new CobrosController(svc as any);
    const user = { id: 'usr', empresa_id: 'emp' } as any;
    await ctrl.getCierreCobros(user, '2026-11-01', '2026-11-07', undefined, SUC_A, USD.id);
    expect(svc.getCierreCobros).toHaveBeenCalledWith(
      'emp',
      { fechaDesde: '2026-11-01', fechaHasta: '2026-11-07', cobradorId: undefined, sucursalId: SUC_A, monedaId: USD.id },
      'usr',
    );
    const res = { setHeader: jest.fn(), send: jest.fn() } as any;
    await ctrl.getCierreCobrosPdf(user, res, '2026-11-01', '2026-11-07', undefined, SUC_A, USD.id);
    expect(svc.exportarCierreCobrosPDF).toHaveBeenCalledWith(
      'emp',
      { fechaDesde: '2026-11-01', fechaHasta: '2026-11-07', cobradorId: undefined, sucursalId: SUC_A, monedaId: USD.id },
      'usr',
    );
  });
});

describe('Cierre de cobros: moneda', () => {
  it('monedaId ajena o que no es UUID → 400 MONEDA_INVALIDA sin consultar recibos', async () => {
    const prisma = prismaCon([]);
    await expect(servicio(prisma).getCierreCobros('emp', { monedaId: '33333333-3333-4333-8333-333333333333' }, 'usr')).rejects.toBeInstanceOf(
      BadRequestException,
    );
    await expect(servicio(prisma).getCierreCobros('emp', { monedaId: 'x' }, 'usr')).rejects.toMatchObject({
      response: { codigo: 'MONEDA_INVALIDA' },
    });
    expect(prisma.$queryRaw).not.toHaveBeenCalled();
  });

  it('sin monedaId: PYG 100.000 + USD 50,25 a 7.300 → en_moneda convertido; porMonedaTotales y campos de siempre crudos', async () => {
    const prisma = prismaCon(
      [
        { id: 'r1', monto: '100000', moneda: PYG, cotizacion: null },
        { id: 'r2', monto: '50.25', moneda: USD, cotizacion: '7300', fecha: '2026-11-03' },
      ],
      {
        lineas: [
          { recibo_id: 'r1', factura_cab_id: 'f1', monto_pagado: '100000', condicion_codigo: 1, dcuotas: null, cuotas_count: 1, avg_dias_intervalo: null },
          { recibo_id: 'r2', factura_cab_id: 'f2', monto_pagado: '50.25', condicion_codigo: 2, dcuotas: 3, cuotas_count: 3, avg_dias_intervalo: 30 },
        ],
        multi: [
          { recibo_id: 'r1', medio: 'EFECTIVO', monto: '100000' },
          { recibo_id: 'r2', medio: 'Transferencia', monto: '50.25' },
        ],
      },
    );
    const r: any = await servicio(prisma).getCierreCobros('emp', {}, 'usr');

    // De siempre: mezclan monedas, como hoy.
    expect(r.totalGeneral).toBe(100050.25);
    expect(r.porMonedaTotales).toEqual([
      { codigo: 'PYG', monto: 100000 },
      { codigo: 'USD', monto: 50.25 },
    ]);
    // Nuevo.
    expect(r.moneda).toEqual({ id: PYG.id, codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.sin_cotizacion).toBe(0);
    expect(r.sin_moneda).toBe(0);
    const ceros = { Efectivo: 0, Cheque: 0, Transferencia: 0, Tarjeta: 0, 'NC / Saldo a favor': 0, Retención: 0, Otros: 0 };
    expect(r.en_moneda).toEqual({
      totalGeneral: 466825,
      totalRetenciones: 0,
      totalFacturas: 466825,
      recibos: 2,
      porDia: [
        { fecha: '2026-11-02', recibos: 1, total_cobrado: 100000, total_facturas: 100000, por_medio: { ...ceros, Efectivo: 100000 } },
        { fecha: '2026-11-03', recibos: 1, total_cobrado: 366825, total_facturas: 366825, por_medio: { ...ceros, Transferencia: 366825 } },
      ],
      porCondicion: [
        { condicion: 'Mensual', cantidad_recibos: 1, cantidad_lineas: 1, monto: 366825 },
        { condicion: 'Contado', cantidad_recibos: 1, cantidad_lineas: 1, monto: 100000 },
      ],
      porMedio: [
        { medio: 'Transferencia', monto: 366825 },
        { medio: 'Efectivo', monto: 100000 },
      ],
    });
    expect(r.recibos.map((x: any) => x.monto_en_moneda)).toEqual([100000, 366825]);
  });

  it('cada recibo se convierte con SU cotización y el total es la suma de los días', async () => {
    const prisma = prismaCon([
      { id: 'r1', monto: '0.33', moneda: USD, cotizacion: '7312.5' },
      { id: 'r2', monto: '0.33', moneda: USD, cotizacion: '7312.5' },
      { id: 'r3', monto: '10', moneda: USD, cotizacion: '7000', fecha: '2026-11-03' },
    ]);
    const r: any = await servicio(prisma).getCierreCobros('emp', {}, 'usr');
    // Una conversión por grupo (día, moneda, cotización): 0,66 × 7.312,5 = 4.826,25 → 4.826 (no 2 × 2.413).
    expect(r.en_moneda.porDia.map((d: any) => d.total_cobrado)).toEqual([4826, 70000]);
    expect(r.en_moneda.totalGeneral).toBe(74826);
  });

  it('USD sin cotización (nula o 1): sin_cotizacion y fuera de en_moneda; sigue en porMonedaTotales', async () => {
    const prisma = prismaCon([
      { id: 'r1', monto: '100000', moneda: PYG, cotizacion: null },
      { id: 'r2', monto: '50.25', moneda: USD, cotizacion: null },
      { id: 'r3', monto: '7', moneda: USD, cotizacion: '1' },
    ]);
    const r: any = await servicio(prisma).getCierreCobros('emp', {}, 'usr');
    expect(r.sin_cotizacion).toBe(2);
    expect(r.en_moneda.totalGeneral).toBe(100000);
    expect(r.en_moneda.recibos).toBe(1);
    expect(r.en_moneda.porDia[0].recibos).toBe(1);
    expect(r.en_moneda.porMedio).toEqual([{ medio: 'Efectivo', monto: 100000 }]);
    expect(r.porMonedaTotales).toEqual([
      { codigo: 'PYG', monto: 100000 },
      { codigo: 'USD', monto: 57.25 },
    ]);
    expect(r.recibos.map((x: any) => x.monto_en_moneda)).toEqual([100000, null, null]);
  });

  it('recibo de moneda nula = base (como el Tablero)', async () => {
    const prisma = prismaCon([{ id: 'r1', monto: '700', moneda: null, cotizacion: null }]);
    const r: any = await servicio(prisma).getCierreCobros('emp', {}, 'usr');
    expect(r.en_moneda.totalGeneral).toBe(700);
    expect(r.sin_cotizacion).toBe(0);
  });

  it('monedaId = base: el SQL incluye la moneda nula; sin convertir', async () => {
    const prisma = prismaCon([
      { id: 'r1', monto: '100000.5', moneda: PYG, cotizacion: null },
      { id: 'r2', monto: '700', moneda: null, cotizacion: null },
    ]);
    const r: any = await servicio(prisma).getCierreCobros('emp', { monedaId: PYG.id }, 'usr');
    const q = sqlDe(prisma.$queryRaw.mock.calls[0]);
    expect(q.text.replace(/\s+/g, ' ')).toContain('AND (r.moneda_id = $3::uuid OR r.moneda_id IS NULL)');
    expect(q.values).toEqual(['emp', 'emitido', PYG.id]);
    expect(r.moneda).toEqual({ id: PYG.id, codigo: 'PYG' });
    expect(r.convertido).toBe(false);
    expect(r.en_moneda.totalGeneral).toBe(100700.5);
  });

  it('monedaId = USD: igualdad, montos en USD con sus decimales', async () => {
    const prisma = prismaCon([
      { id: 'r1', monto: '50.25', moneda: USD, cotizacion: '7300' },
      { id: 'r2', monto: '0.1', moneda: USD, cotizacion: null },
    ]);
    const r: any = await servicio(prisma).getCierreCobros('emp', { monedaId: USD.id }, 'usr');
    const q = sqlDe(prisma.$queryRaw.mock.calls[0]);
    expect(q.text).toMatch(/AND r\.moneda_id = \$3::uuid/);
    expect(q.text).not.toMatch(/IS NULL/);
    expect(r.convertido).toBe(false);
    expect(r.moneda).toEqual({ id: USD.id, codigo: 'USD' });
    // Con una moneda elegida no hay conversión: el recibo sin cotización también suma.
    expect(r.sin_cotizacion).toBe(0);
    expect(r.en_moneda.totalGeneral).toBe(50.35);
    expect(r.recibos.map((x: any) => x.monto_en_moneda)).toEqual([50.25, 0.1]);
  });

  it('moneda sin código: sin_moneda, fuera de en_moneda', async () => {
    const RARA = { id: '44444444-4444-4444-8444-444444444444', codigo: 'ZZZ' };
    const prisma = prismaCon([
      { id: 'r1', monto: '100', moneda: PYG, cotizacion: null },
      { id: 'r2', monto: '5', moneda: RARA, cotizacion: '7000' },
    ]);
    const r: any = await servicio(prisma).getCierreCobros('emp', {}, 'usr');
    expect(r.sin_moneda).toBe(1);
    expect(r.en_moneda.totalGeneral).toBe(100);
    expect(r.recibos.map((x: any) => x.monto_en_moneda)).toEqual([100, null]);
  });

  it('sin recibos: forma vacía con los bloques nuevos en cero', async () => {
    const prisma = prismaCon([]);
    const r: any = await servicio(prisma).getCierreCobros('emp', { monedaId: USD.id }, 'usr');
    expect(r).toMatchObject({
      moneda: { id: USD.id, codigo: 'USD' },
      convertido: false,
      sin_cotizacion: 0,
      sin_moneda: 0,
      en_moneda: { totalGeneral: 0, recibos: 0, porDia: [], porCondicion: [], porMedio: [] },
      totalGeneral: 0,
    });
  });
});

describe('PDF del cierre: nunca suma monedas sin convertir (Ronda 1)', () => {
  const ok = { ok: true, arrayBuffer: () => Promise.resolve(new ArrayBuffer(1)) };
  let fetchOriginal: typeof fetch;
  beforeEach(() => {
    fetchOriginal = global.fetch;
    global.fetch = jest.fn().mockResolvedValue(ok) as any;
  });
  afterEach(() => {
    global.fetch = fetchOriginal;
  });
  const payload = () => JSON.parse((global.fetch as jest.Mock).mock.calls[0][1].body);

  it('Gs + USD sin moneda elegida: total convertido a la base, rotulado con la base y aviso de sin cotización', async () => {
    const prisma = prismaCon(
      [
        { id: 'r1', monto: '100000', moneda: PYG, cotizacion: null },
        { id: 'r2', monto: '50.25', moneda: USD, cotizacion: '7300' },
        { id: 'r3', monto: '9', moneda: USD, cotizacion: null },
      ],
      {
        multi: [
          { recibo_id: 'r1', medio: 'EFECTIVO', monto: '100000' },
          { recibo_id: 'r2', medio: 'EFECTIVO', monto: '50.25' },
          { recibo_id: 'r3', medio: 'Cheque', monto: '9' },
        ],
      },
    );
    await servicio(prisma).exportarCierreCobrosPDF('emp', {}, 'usr');
    const p = payload();
    expect(p.moneda).toBe('PYG');
    expect(p.totales).toEqual([
      { label: 'Total cobrado', value: 466825, type: 'currency' },
      { label: 'Recibos', value: 2, type: 'number' },
      { label: 'Sin cotización (fuera del total)', value: '1 recibo(s)', type: 'text' },
    ]);
    // Ni la suma cruda (100.059,25) ni el medio del recibo sin cotización (Cheque 9) aparecen.
    expect(p.rows).toEqual([
      // La fecha va como texto dd/mm/aaaa (columna sin type 'date'): ningún huso la corre.
      { fecha: '02/11/2026', recibos: 2, total_cobrado: 466825, total_facturas: 466825, medio_Efectivo: 466825 },
      { fecha: 'TOTAL', recibos: 2, total_cobrado: 466825, total_facturas: 466825, medio_Efectivo: 466825 },
    ]);
    expect(p.columns.map((c: any) => c.key)).not.toContain('medio_Cheque');
    expect(p.secciones[0].rows).toEqual([{ condicion: 'Contado', cantidad_recibos: 2, cantidad_lineas: 2, monto: 466825 }]);
  });

  it('las fechas van al mediodía UTC: el generador no las corre un día según su zona horaria', async () => {
    jest.useFakeTimers({ now: new Date('2026-11-08T01:30:00Z'), doNotFake: ['nextTick', 'setImmediate', 'setTimeout', 'setInterval', 'queueMicrotask'] });
    try {
      const prisma = prismaCon([{ id: 'r1', monto: '100000', moneda: PYG, cotizacion: null }]);
      await servicio(prisma).exportarCierreCobrosPDF('emp', { fechaDesde: '2026-11-01', fechaHasta: '2026-11-05' }, 'usr');
      const p = payload();
      expect(p.desde).toBe('2026-11-01T12:00:00.000Z');
      expect(p.hasta).toBe('2026-11-05T12:00:00.000Z');
      // 01:30 UTC del 8/11 es todavía el 7/11 en Asunción (UTC-3).
      expect(p.generado_en).toBe('2026-11-07T12:00:00.000Z');
      expect(p.rows[0].fecha).toBe('02/11/2026');
      expect(p.rows[p.rows.length - 1].fecha).toBe('TOTAL');
      // Con un proceso en UTC-3 o en UTC el día que lee el generador es el mismo.
      for (const iso of [p.desde, p.hasta, p.generado_en]) expect(new Date(iso).toISOString().slice(8, 10)).toBe(iso.slice(8, 10));
    } finally {
      jest.useRealTimers();
    }
  });

  it('con monedaId: igual que hoy (montos de esa moneda, sin aviso)', async () => {
    const prisma = prismaCon([{ id: 'r1', monto: '50.25', moneda: USD, cotizacion: null }]);
    await servicio(prisma).exportarCierreCobrosPDF('emp', { monedaId: USD.id }, 'usr');
    const p = payload();
    expect(p.moneda).toBe('USD');
    expect(p.totales).toEqual([
      { label: 'Total cobrado', value: 50.25, type: 'currency' },
      { label: 'Recibos', value: 1, type: 'number' },
    ]);
  });
});
