/**
 * D-T5: Libro de retenciones con moneda y alcance.
 *  - Sigue siendo un arreglo plano; cada fila suma `moneda_codigo` y `moneda_cotizacion` = la moneda del recibo
 *    (`monedasDeRecibos`, nula = base como el Tablero). `moneda_codigo` null solo si la moneda del recibo no tiene código.
 *  - `sucursal_id` recorta `rm.sucursal_id` (fuera de alcance → 403); sin pedirla, el alcance del usuario.
 *  - `moneda_id` como el Tablero (ajena → 400). `periodo` que no es `YYYY-MM` → 400 `PERIODO_INVALIDO`.
 */
import { BadRequestException, ForbiddenException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { RecibosService } from './recibos.service';
import { RetencionesController } from './retenciones.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 RARA = { id: '33333333-3333-4333-8333-333333333333', codigo: null };
const SUC_A = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
const SUC_B = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
const sqlDe = (call: any[]) => Prisma.sql(call[0], ...call.slice(1));
const restringido = (sucursalIds: string[]) => ({ sucursalIds, puntosEstablecimiento: [], depositoIds: [] });

type Rec = { id: string; moneda_id: string | null; cotizacion: string | null };
function prismaCon(filas: any[], recibos: Rec[] = []) {
  const monedas = [PYG, USD, RARA];
  return {
    $queryRaw: jest.fn().mockResolvedValue(filas),
    empresas_sucursales: { findFirst: jest.fn().mockResolvedValue({ 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(monedas.find((m) => m.id === where.id) ?? null)),
      findMany: jest.fn(({ where }: any) => Promise.resolve(monedas.filter((m) => where.id.in.includes(m.id)))),
    },
    recibos_cobro: {
      findMany: jest.fn((a: any) =>
        Promise.resolve(
          recibos
            .filter((r) => a.where.id.in.includes(r.id))
            .map((r) => ({ id: r.id, empresa_id: 'emp', moneda_id: r.moneda_id, cotizacion: r.cotizacion === null ? null : new Prisma.Decimal(r.cotizacion) })),
        ),
      ),
    },
  };
}
const servicio = (prisma: any) => new RecibosService(prisma, {} as any, {} as any);

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

describe('Libro de retenciones: moneda del recibo', () => {
  it('retención de un recibo USD trae moneda_codigo USD y su cotización; nula = base', async () => {
    const filas = [
      { retencion_id: 'ret1', recibo_id: 'r1', monto: new Prisma.Decimal('15.5') },
      { retencion_id: 'ret2', recibo_id: 'r2', monto: new Prisma.Decimal('30000') },
      { retencion_id: 'ret3', recibo_id: 'r1', monto: new Prisma.Decimal('1') },
    ];
    const prisma = prismaCon(filas, [
      { id: 'r1', moneda_id: USD.id, cotizacion: '7300' },
      { id: 'r2', moneda_id: null, cotizacion: null },
    ]);
    const r = await servicio(prisma).libroRetenciones('emp', '2026-11', {}, 'usr');
    expect(r).toEqual([
      { ...filas[0], moneda_codigo: 'USD', moneda_cotizacion: '7300' },
      { ...filas[1], moneda_codigo: 'PYG', moneda_cotizacion: null },
      { ...filas[2], moneda_codigo: 'USD', moneda_cotizacion: '7300' },
    ]);
  });

  it('recibo con moneda sin código: la fila sigue, con moneda_codigo null (nunca otra moneda)', async () => {
    const prisma = prismaCon([{ retencion_id: 'ret1', recibo_id: 'r1' }], [{ id: 'r1', moneda_id: RARA.id, cotizacion: null }]);
    const r = await servicio(prisma).libroRetenciones('emp', '2026-11', {}, 'usr');
    expect(r).toEqual([{ retencion_id: 'ret1', recibo_id: 'r1', moneda_codigo: null, moneda_cotizacion: null }]);
  });

  it('USD elegida: igualdad en el SQL; base: entra la nula; ajena → 400', async () => {
    const prisma = prismaCon([]);
    await servicio(prisma).libroRetenciones('emp', '2026-11', { moneda_id: USD.id }, 'usr');
    expect(sqlDe(prisma.$queryRaw.mock.calls[0]).text).toMatch(/AND rm\.moneda_id = \$\d+::uuid/);
    await servicio(prisma).libroRetenciones('emp', '2026-11', { moneda_id: PYG.id }, 'usr');
    expect(sqlDe(prisma.$queryRaw.mock.calls[1]).text).toMatch(/AND \(rm\.moneda_id = \$\d+::uuid OR rm\.moneda_id IS NULL\)/);
    await expect(servicio(prisma).libroRetenciones('emp', '2026-11', { moneda_id: 'x' }, 'usr')).rejects.toBeInstanceOf(BadRequestException);
  });
});

describe('Libro de retenciones: período', () => {
  it.each(['2026-13', '2026-00', '2026-1', '', 'abc', '2026-11-01'])('periodo %p → 400 PERIODO_INVALIDO sin consultar', async (periodo) => {
    const prisma = prismaCon([]);
    const err = await servicio(prisma).libroRetenciones('emp', periodo, {}, 'usr').catch((e) => e);
    expect(err).toBeInstanceOf(BadRequestException);
    expect(err.getResponse()).toMatchObject({ codigo: 'PERIODO_INVALIDO', campo: 'periodo' });
    expect(prisma.$queryRaw).not.toHaveBeenCalled();
  });

  it('periodo undefined → 400', async () => {
    await expect(servicio(prismaCon([])).libroRetenciones('emp', undefined as any, {}, 'usr')).rejects.toBeInstanceOf(BadRequestException);
  });
});

describe('Libro de retenciones: alcance', () => {
  it('restringido a A que pide B → 403, antes del 400 de período', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    const prisma = prismaCon([]);
    await expect(servicio(prisma).libroRetenciones('emp', '2026-13', { sucursal_id: SUC_B }, 'usr')).rejects.toBeInstanceOf(ForbiddenException);
    expect(prisma.$queryRaw).not.toHaveBeenCalled();
    expect(alcanceSucursalUsuario).toHaveBeenCalledWith(prisma, 'usr', 'emp');
  });

  it('restringido a A sin pedir: solo recibos de A (la fila de otra sucursal no entra)', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    const prisma = prismaCon([]);
    await servicio(prisma).libroRetenciones('emp', '2026-11', {}, 'usr');
    const q = sqlDe(prisma.$queryRaw.mock.calls[0]);
    expect(q.text).toMatch(/AND rm\.sucursal_id = \$\d+::uuid/);
    expect(q.values).toContain(SUC_A);
  });

  it('restringido a A y C: IN; alcance vacío: FALSE', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A, SUC_B]));
    const prisma = prismaCon([]);
    await servicio(prisma).libroRetenciones('emp', '2026-11', {}, 'usr');
    expect(sqlDe(prisma.$queryRaw.mock.calls[0]).text).toMatch(/AND rm\.sucursal_id IN \(\$\d+::uuid,\$\d+::uuid\)/);
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([]));
    await servicio(prisma).libroRetenciones('emp', '2026-11', {}, 'usr');
    expect(sqlDe(prisma.$queryRaw.mock.calls[1]).text).toContain('AND FALSE');
  });

  it('admin sin pedir: el SQL de siempre (mismos valores)', async () => {
    const prisma = prismaCon([]);
    await servicio(prisma).libroRetenciones('emp', '2026-11', {}, 'usr');
    const q = sqlDe(prisma.$queryRaw.mock.calls[0]);
    expect(q.values).toEqual(['emp', 2026, 11]);
    expect(q.text).not.toContain('sucursal_id');
  });

  it('controller: pasa periodo, filtros y user.id', async () => {
    const svc = { libroRetenciones: jest.fn().mockResolvedValue([]) };
    const ctrl = new RetencionesController(svc as any);
    await ctrl.libro({ id: 'usr', empresa_id: 'emp' } as any, '2026-11', SUC_A, USD.id);
    expect(svc.libroRetenciones).toHaveBeenCalledWith('emp', '2026-11', { sucursal_id: SUC_A, moneda_id: USD.id }, 'usr');
  });
});
