/**
 * D-T4: Reportes de rendiciones por moneda.
 *  - Los 4 endpoints aceptan `moneda_id` (como el Tablero: ajena → 400; con la base entra la rendición/recibo de moneda
 *    nula). Con una moneda elegida TODO el reporte es de esa moneda (también los campos de siempre).
 *  - `rendiciones_cobranza` no tiene `cotizacion` (ruling del preflight): se agrupa por moneda (`por_moneda`), SIN total
 *    convertido. Sin `moneda_id` los campos de siempre siguen mezclando como hoy.
 *  - Sin recorte por sucursal: el modelo de rendiciones no tiene sucursal (ruling; queda anotado en el resultado).
 */
import { BadRequestException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { RendicionesService } from './rendiciones.service';

const PYG = { id: '11111111-1111-4111-8111-111111111111', codigo: 'PYG' };
const USD = { id: '22222222-2222-4222-8222-222222222222', codigo: 'USD' };
const D = (v: string) => new Prisma.Decimal(v);

const rendicion = (o: Record<string, unknown>) => ({
  empresa_id: 'emp',
  cobrador_id: 'cob1',
  cobrador: { id: 'cob1', nombre: 'Ana', apellido: null },
  cantidad_recibos: 1,
  monto_cobrado: null,
  monto_efectivo: null,
  monto_cheque: null,
  monto_transferencia: null,
  monto_tarjeta: null,
  total_declarado: null,
  total_verificado: null,
  diferencia: null,
  moneda_id: PYG.id,
  ...o,
});

function prismaCon(opts: { rendiciones?: any[]; vista?: any[]; recibos?: any[]; holding?: boolean; bases?: Record<string, string> } = {}) {
  const bases = opts.bases ?? { emp: PYG.id };
  return {
    empresas: {
      findUnique: jest.fn().mockResolvedValue({ type: opts.holding ? 'holding' : 'empresa' }),
      findMany: jest.fn().mockResolvedValue(opts.holding ? [{ id: 'sub' }] : []),
    },
    empresa_monedas: { findFirst: jest.fn(({ where }: any) => Promise.resolve(bases[where.empresa_id] ? { moneda_id: bases[where.empresa_id] } : null)) },
    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)))),
    },
    rendiciones_cobranza: {
      findMany: jest.fn((a: any) =>
        Promise.resolve(
          a?.select
            ? (opts.rendiciones ?? []).filter((r) => a.where.id.in.includes(r.id)).map((r) => ({ id: r.id, empresa_id: r.empresa_id, moneda_id: r.moneda_id }))
            : (opts.rendiciones ?? []),
        ),
      ),
    },
    recibos_cobro: {
      findMany: jest.fn((a: any) => Promise.resolve((opts.recibos ?? []).filter((r) => a.where.id.in.includes(r.id)))),
    },
    $queryRawUnsafe: jest.fn().mockResolvedValue(opts.vista ?? []),
  };
}
const servicio = (prisma: any) => new RendicionesService(prisma);

describe('cobranzas-dia por moneda', () => {
  const filas = [
    rendicion({ estado: 'APROBADO', cantidad_recibos: 2, monto_cobrado: D('100000'), monto_efectivo: D('100000'), total_declarado: D('100000'), total_verificado: D('99000'), diferencia: D('0') }),
    rendicion({
      estado: 'APROBADO',
      moneda_id: USD.id,
      monto_cobrado: D('50.25'),
      monto_transferencia: D('50.25'),
      total_declarado: D('50.25'),
      diferencia: D('0'),
    }),
    rendicion({ estado: 'RECHAZADO', moneda_id: USD.id, cantidad_recibos: 5, monto_cobrado: D('999'), monto_efectivo: D('999'), total_declarado: D('999') }),
    rendicion({ estado: 'ANULADO', monto_cobrado: D('777'), total_declarado: D('777') }),
    rendicion({
      cobrador_id: 'cob2',
      cobrador: { id: 'cob2', nombre: 'Beto', apellido: 'Paz' },
      estado: 'PENDIENTE',
      moneda_id: null,
      monto_cobrado: D('700'),
      monto_cheque: D('700'),
      total_declarado: D('690'),
      diferencia: D('-10'),
    }),
  ];

  it('USD y PYG del mismo cobrador no se suman en por_moneda; RECHAZADO cuenta sin monto; ANULADO no entra; nula = base', async () => {
    const prisma = prismaCon({ rendiciones: filas });
    const r: any = await servicio(prisma).reporteCobranzasDia('emp', '2026-11-01', '2026-11-07');

    // De siempre: mezcla, como hoy (el where ya excluye ANULADO; si llegara, no suma monto).
    const ana = r.por_cobrador.find((c: any) => c.cobrador_id === 'cob1');
    expect(ana.total_cobrado).toBe(100050.25);
    expect(ana.rechazadas).toBe(1);

    expect(ana.por_moneda).toEqual([
      {
        codigo: 'PYG',
        rendiciones: 1, // la ANULADO no entra (el where ya la excluye; acá, por las dudas, tampoco)
        recibos: 2,
        aprobadas: 1,
        pendientes: 0,
        observadas: 0,
        rechazadas: 0,
        cobrado: '100000.00',
        efectivo: '100000.00',
        cheque: '0.00',
        transferencia: '0.00',
        tarjeta: '0.00',
        declarado: '100000.00',
        verificado: '99000.00',
        diferencia: '0.00',
      },
      {
        codigo: 'USD',
        rendiciones: 2,
        recibos: 1,
        aprobadas: 1,
        pendientes: 0,
        observadas: 0,
        rechazadas: 1,
        cobrado: '50.25',
        efectivo: '0.00',
        cheque: '0.00',
        transferencia: '50.25',
        tarjeta: '0.00',
        declarado: '50.25',
        verificado: '50.25',
        diferencia: '0.00',
      },
    ]);
    const beto = r.por_cobrador.find((c: any) => c.cobrador_id === 'cob2');
    expect(beto.por_moneda).toEqual([
      expect.objectContaining({ codigo: 'PYG', rendiciones: 1, pendientes: 1, cobrado: '700.00', cheque: '700.00', declarado: '690.00', verificado: '690.00', diferencia: '-10.00' }),
    ]);
    // Total por moneda (sin convertir: rendiciones no tiene cotización).
    expect(r.por_moneda).toEqual([
      expect.objectContaining({ codigo: 'PYG', rendiciones: 2, recibos: 3, cobrado: '100700.00', verificado: '99690.00' }),
      expect.objectContaining({ codigo: 'USD', rendiciones: 2, recibos: 1, rechazadas: 1, cobrado: '50.25' }),
    ]);
    expect(r.moneda).toBeNull();
    expect(r.sin_moneda).toBe(0);
    expect(r).not.toHaveProperty('en_moneda');
  });

  it('moneda_id = base: where con la nula; moneda_id = USD: igualdad; moneda en la respuesta', async () => {
    const prisma = prismaCon({ rendiciones: [] });
    const r1: any = await servicio(prisma).reporteCobranzasDia('emp', '2026-11-01', '2026-11-07', PYG.id);
    expect(prisma.rendiciones_cobranza.findMany.mock.calls[0][0].where.AND).toEqual([{ OR: [{ moneda_id: PYG.id }, { moneda_id: null }] }]);
    expect(r1.moneda).toEqual({ id: PYG.id, codigo: 'PYG' });
    const r2: any = await servicio(prisma).reporteCobranzasDia('emp', '2026-11-01', '2026-11-07', USD.id);
    expect(prisma.rendiciones_cobranza.findMany.mock.calls[1][0].where.AND).toEqual([{ moneda_id: USD.id }]);
    expect(r2.moneda).toEqual({ id: USD.id, codigo: 'USD' });
    expect(r2.por_moneda).toEqual([]);
  });

  it('sin moneda_id el where es el de siempre (sin AND)', async () => {
    const prisma = prismaCon({ rendiciones: [] });
    await servicio(prisma).reporteCobranzasDia('emp', '2026-11-01', '2026-11-07');
    expect(prisma.rendiciones_cobranza.findMany.mock.calls[0][0].where).not.toHaveProperty('AND');
  });

  it('moneda_id ajena o que no es UUID → 400 antes de consultar', async () => {
    const prisma = prismaCon({ rendiciones: filas });
    await expect(servicio(prisma).reporteCobranzasDia('emp', '2026-11-01', '2026-11-07', '33333333-3333-4333-8333-333333333333')).rejects.toBeInstanceOf(
      BadRequestException,
    );
    await expect(servicio(prisma).reporteCobranzasDia('emp', '2026-11-01', '2026-11-07', 'x')).rejects.toMatchObject({ response: { codigo: 'MONEDA_INVALIDA' } });
    expect(prisma.rendiciones_cobranza.findMany).not.toHaveBeenCalled();
  });

  it('moneda sin código: sin_moneda y fuera de por_moneda (sigue en los campos de siempre)', async () => {
    const prisma = prismaCon({ rendiciones: [rendicion({ estado: 'APROBADO', moneda_id: '44444444-4444-4444-8444-444444444444', monto_cobrado: D('5') })] });
    const r: any = await servicio(prisma).reporteCobranzasDia('emp', '2026-11-01', '2026-11-07');
    expect(r.sin_moneda).toBe(1);
    expect(r.por_moneda).toEqual([]);
    expect(r.totales.total_cobrado).toBe(5);
  });

  it('holding: la rendición de moneda nula de una subsidiaria toma la base de SU empresa', async () => {
    const prisma = prismaCon({
      holding: true,
      bases: { emp: PYG.id, sub: USD.id },
      rendiciones: [rendicion({ empresa_id: 'sub', estado: 'APROBADO', moneda_id: null, monto_cobrado: D('3') })],
    });
    const r: any = await servicio(prisma).reporteCobranzasDia('emp', '2026-11-01', '2026-11-07');
    expect(r.por_moneda).toEqual([expect.objectContaining({ codigo: 'USD', cobrado: '3.00' })]);
  });
});

describe('pendientes por moneda', () => {
  it('cada fila suma moneda {codigo}; moneda_id filtra en el where', async () => {
    const prisma = prismaCon({
      rendiciones: [
        rendicion({ id: 'rd1', estado: 'PENDIENTE', fecha_rendicion: new Date(), fecha_envio_tesoreria: null, moneda_id: USD.id }),
        rendicion({ id: 'rd2', estado: 'OBSERVADO', fecha_rendicion: new Date(), fecha_envio_tesoreria: null, moneda_id: null }),
      ],
    });
    const r: any = await servicio(prisma).reportePendientes('emp');
    expect(r.map((x: any) => x.moneda)).toEqual([{ codigo: 'USD' }, { codigo: 'PYG' }]);
    expect(prisma.rendiciones_cobranza.findMany.mock.calls[0][0].where).not.toHaveProperty('AND');

    await servicio(prisma).reportePendientes('emp', USD.id);
    expect(prisma.rendiciones_cobranza.findMany.mock.calls[1][0].where.AND).toEqual([{ moneda_id: USD.id }]);
  });
});

describe('diferencias por moneda', () => {
  const vista = [
    { rendicion_id: 'rd1', empresa_id: 'emp', cobrador_id: 'cob1', total_declarado: D('1000'), total_verificado: D('990'), diferencia: D('-10'), nivel: 'MENOR' },
    { rendicion_id: 'rd2', empresa_id: 'emp', cobrador_id: 'cob1', total_declarado: D('50.25'), total_verificado: null, diferencia: D('-50.25'), nivel: 'SIN_VERIFICAR' },
  ];
  const rends = [rendicion({ id: 'rd1', moneda_id: null }), rendicion({ id: 'rd2', moneda_id: USD.id })];

  it('filas de la vista con su moneda + por_moneda (sin convertir)', async () => {
    const prisma = prismaCon({ vista, rendiciones: rends });
    const r: any = await servicio(prisma).reporteDiferencias('emp', {});
    expect(r.filas.map((f: any) => [f.rendicion_id, f.moneda])).toEqual([
      ['rd1', { codigo: 'PYG' }],
      ['rd2', { codigo: 'USD' }],
    ]);
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', rendiciones: 1, declarado: '1000.00', verificado: '990.00', diferencia: '-10.00' },
      { codigo: 'USD', rendiciones: 1, declarado: '50.25', verificado: '0.00', diferencia: '-50.25' },
    ]);
    expect(r.moneda).toBeNull();
    expect(r.sin_moneda).toBe(0);
    // La moneda de cada rendición se lee de SUS empresas.
    expect(prisma.rendiciones_cobranza.findMany.mock.calls[0][0].where).toEqual({ id: { in: ['rd1', 'rd2'] }, empresa_id: 'emp' });
    expect(prisma.$queryRawUnsafe.mock.calls[0][0]).not.toMatch(/moneda_id/);
  });

  it('moneda_id filtra en el SQL (antes del LIMIT): base con la nula, otra por igualdad', async () => {
    const prisma = prismaCon({ vista: [], rendiciones: [] });
    await servicio(prisma).reporteDiferencias('emp', { nivel: 'mayor', moneda_id: PYG.id });
    expect(prisma.$queryRawUnsafe.mock.calls[0]).toEqual([
      'SELECT * FROM vw_rendiciones_diferencias WHERE empresa_id::text = ANY($1::text[]) AND nivel = $2 AND rendicion_id IN (SELECT id FROM rendiciones_cobranza WHERE moneda_id = $3::uuid OR moneda_id IS NULL) ORDER BY diferencia_abs DESC LIMIT 500',
      ['emp'],
      'mayor',
      PYG.id,
    ]);
    await servicio(prisma).reporteDiferencias('emp', { moneda_id: USD.id });
    expect(prisma.$queryRawUnsafe.mock.calls[1]).toEqual([
      'SELECT * FROM vw_rendiciones_diferencias WHERE empresa_id::text = ANY($1::text[]) AND rendicion_id IN (SELECT id FROM rendiciones_cobranza WHERE moneda_id = $2::uuid) ORDER BY diferencia_abs DESC LIMIT 500',
      ['emp'],
      USD.id,
    ]);
  });

  it('moneda_id inválida → 400 sin consultar la vista', async () => {
    const prisma = prismaCon({});
    await expect(servicio(prisma).reporteDiferencias('emp', { moneda_id: 'x' })).rejects.toBeInstanceOf(BadRequestException);
    expect(prisma.$queryRawUnsafe).not.toHaveBeenCalled();
  });
});

describe('comisiones a liquidar por moneda', () => {
  const vista = [
    { comision_id: 'c1', recibo_id: 'r1', rendicion_id: 'rd1', monto_comision: D('5000') },
    { comision_id: 'c2', recibo_id: 'r2', rendicion_id: 'rd2', monto_comision: D('1.5') },
  ];
  const recibos = [
    { id: 'r1', empresa_id: 'emp', moneda_id: null, cotizacion: null },
    { id: 'r2', empresa_id: 'emp', moneda_id: USD.id, cotizacion: D('7300') },
  ];

  it('cada fila suma la moneda de su recibo (la del Tablero)', async () => {
    const prisma = prismaCon({ vista, recibos });
    const r: any = await servicio(prisma).reporteComisionesLiquidar('emp', 'cob1');
    expect(r.map((f: any) => f.moneda)).toEqual([{ codigo: 'PYG' }, { codigo: 'USD' }]);
    expect(r[1].monto_comision).toEqual(D('1.5'));
  });

  it('moneda_id filtra por la moneda del recibo en el SQL', async () => {
    const prisma = prismaCon({ vista: [], recibos: [] });
    await servicio(prisma).reporteComisionesLiquidar('emp', 'cob1', USD.id);
    expect(prisma.$queryRawUnsafe.mock.calls[0]).toEqual([
      'SELECT * FROM vw_comisiones_a_liquidar WHERE empresa_id::text = ANY($1::text[]) AND cobrador_id = $2::uuid AND recibo_id IN (SELECT id FROM recibos_cobro WHERE moneda_id = $3::uuid) ORDER BY fecha_aprobacion DESC NULLS LAST LIMIT 1000',
      ['emp'],
      'cob1',
      USD.id,
    ]);
    await servicio(prisma).reporteComisionesLiquidar('emp', undefined, PYG.id);
    expect(prisma.$queryRawUnsafe.mock.calls[1][0]).toContain('AND recibo_id IN (SELECT id FROM recibos_cobro WHERE moneda_id = $2::uuid OR moneda_id IS NULL)');
  });
});
