/**
 * D-T5: Reportes de promesas (cumplimiento y cashflow) por moneda y por alcance de sucursal.
 *  - La moneda de una promesa es la de su `factura_cab` (nula = base) y su cotización, la `dticam` de esa factura.
 *  - El recorte por sucursal va por el `dest` de la factura (`filtroFiscalPorSucursal`); pedida fuera de alcance → 403,
 *    antes del 400 de moneda.
 *  - Los campos de siempre no cambian; al lado: `moneda`, `convertido`, `sin_cotizacion`, `sin_moneda`, `en_moneda`,
 *    `por_moneda`.
 */
import { BadRequestException, ForbiddenException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { PromesasService } from './promesas.service';
import { PromesasController } from './promesas.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 D = (v: string) => new Prisma.Decimal(v);
const T = (iso: string) => new Date(iso);
const restringido = (sucursalIds: string[]) => ({ sucursalIds, puntosEstablecimiento: [], depositoIds: [] });
const ANA = { id: 'cob1', nombre: 'Ana', apellido: null };

function prismaCon(promesas: any[]) {
  const monedas = [PYG, USD, RARA];
  return {
    promesas_pago: { findMany: jest.fn().mockResolvedValue(promesas) },
    empresas_sucursales: {
      findFirst: jest.fn().mockResolvedValue({ id: 'x' }),
      findMany: jest.fn().mockResolvedValue([{ punto_establecimiento: '001', config: null }]),
    },
    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)))),
    },
  };
}
const servicio = (prisma: any) => new PromesasService(prisma, {} as any);
const factura = (moneda_id: string | null, dticam: string | null = null) => ({ moneda_id, dticam: dticam === null ? null : D(dticam) });

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

describe('Promesas: cumplimiento por moneda', () => {
  const PROMESAS = [
    { id: 'p1', estado: 'cumplida', cobrador_id: 'cob1', monto_prometido: D('1000000'), monto_cumplido: D('1000000'), cobrador: ANA, factura: factura(PYG.id) },
    { id: 'p2', estado: 'cumplida_parcial', cobrador_id: 'cob1', monto_prometido: D('100'), monto_cumplido: D('40.5'), cobrador: ANA, factura: factura(USD.id, '7300') },
    { id: 'p3', estado: 'pendiente', cobrador_id: null, monto_prometido: D('50'), monto_cumplido: null, cobrador: null, factura: factura(USD.id) },
  ];

  it('campos de siempre iguales (mezclan monedas) y lo nuevo separado por moneda', async () => {
    const prisma = prismaCon(PROMESAS);
    const r: any = await servicio(prisma).getReporteCumplimiento('emp', '2026-11-01', '2026-11-30', {}, 'usr');
    expect(r.total_promesas).toBe(3);
    expect(r.por_cobrador[0]).toMatchObject({ cobrador_id: 'cob1', total: 2, cumplidas: 1, cumplidas_parciales: 1, monto_prometido: 1000100, monto_cumplido: 1000040.5, tasa_cumplimiento: 100 });
    expect(r.por_cobrador[1]).toMatchObject({ cobrador_id: null, pendientes: 1, monto_prometido: 50, monto_cumplido: 0 });
    expect(r.moneda).toEqual(PYG);
    expect(r.convertido).toBe(true);
    expect(r.sin_cotizacion).toBe(1); // p3: USD sin cotización
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', monto_prometido: '1000000.00', monto_cumplido: '1000000.00' },
      { codigo: 'USD', monto_prometido: '150.00', monto_cumplido: '40.50' },
    ]);
    expect(r.en_moneda.por_cobrador).toEqual([
      { cobrador_id: 'cob1', cobrador_nombre: 'Ana', monto_prometido: 1730000, monto_cumplido: 1295650 },
      { cobrador_id: null, cobrador_nombre: '— Sin cobrador', monto_prometido: 0, monto_cumplido: 0 },
    ]);
    // la factura (moneda y dticam) se trae en el mismo findMany
    expect(prisma.promesas_pago.findMany.mock.calls[0][0].select.factura).toEqual({ select: { moneda_id: true, dticam: true } });
  });

  it('sin filtros, el where es el de siempre', async () => {
    const prisma = prismaCon([]);
    const r: any = await servicio(prisma).getReporteCumplimiento('emp', undefined, undefined, {}, 'usr');
    expect(prisma.promesas_pago.findMany.mock.calls[0][0].where).toEqual({ empresa_id: 'emp' });
    expect(r).toMatchObject({ total_promesas: 0, por_cobrador: [], sin_cotizacion: 0, sin_moneda: 0, por_moneda: [], en_moneda: { por_cobrador: [] } });
  });

  it('USD elegida: filtra por la moneda de la factura y no convierte', async () => {
    const prisma = prismaCon(PROMESAS.slice(1));
    const r: any = await servicio(prisma).getReporteCumplimiento('emp', undefined, undefined, { moneda_id: USD.id }, 'usr');
    expect(prisma.promesas_pago.findMany.mock.calls[0][0].where).toEqual({ empresa_id: 'emp', factura: { AND: [{ moneda_id: USD.id }] } });
    expect(r.convertido).toBe(false);
    expect(r.sin_cotizacion).toBe(0);
    expect(r.en_moneda.por_cobrador[0]).toEqual({ cobrador_id: 'cob1', cobrador_nombre: 'Ana', monto_prometido: 100, monto_cumplido: 40.5 });
  });

  it('base elegida: entra la factura de moneda nula', async () => {
    const prisma = prismaCon([]);
    await servicio(prisma).getReporteCumplimiento('emp', undefined, undefined, { moneda_id: PYG.id }, 'usr');
    expect(prisma.promesas_pago.findMany.mock.calls[0][0].where.factura).toEqual({ AND: [{ OR: [{ moneda_id: PYG.id }, { moneda_id: null }] }] });
  });

  it('factura de moneda nula = base; moneda sin código → sin_moneda', async () => {
    const prisma = prismaCon([
      { id: 'p1', estado: 'pendiente', cobrador_id: 'cob1', monto_prometido: D('10'), monto_cumplido: null, cobrador: ANA, factura: factura(null) },
      { id: 'p2', estado: 'pendiente', cobrador_id: 'cob1', monto_prometido: D('99'), monto_cumplido: null, cobrador: ANA, factura: factura(RARA.id) },
    ]);
    const r: any = await servicio(prisma).getReporteCumplimiento('emp', undefined, undefined, {}, 'usr');
    expect(r.sin_moneda).toBe(1);
    expect(r.por_moneda).toEqual([{ codigo: 'PYG', monto_prometido: '10.00', monto_cumplido: '0.00' }]);
    expect(r.en_moneda.por_cobrador[0].monto_prometido).toBe(10);
  });

  it('moneda ajena → 400', async () => {
    await expect(servicio(prismaCon([])).getReporteCumplimiento('emp', undefined, undefined, { moneda_id: 'x' }, 'usr')).rejects.toBeInstanceOf(
      BadRequestException,
    );
  });
});

describe('Promesas: alcance', () => {
  it('restringido a A que pide B → 403 (antes del 400 de moneda), sin consultar', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    const prisma = prismaCon([]);
    await expect(
      servicio(prisma).getReporteCumplimiento('emp', undefined, undefined, { sucursal_id: SUC_B, moneda_id: 'x' }, 'usr'),
    ).rejects.toBeInstanceOf(ForbiddenException);
    await expect(servicio(prisma).getDashboardCashflow('emp', { sucursal_id: SUC_B }, 'usr')).rejects.toBeInstanceOf(ForbiddenException);
    expect(prisma.promesas_pago.findMany).not.toHaveBeenCalled();
    expect(alcanceSucursalUsuario).toHaveBeenCalledWith(prisma, 'usr', 'emp');
  });

  it('restringido a A sin pedir: solo promesas de facturas del establecimiento de A', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    const prisma = prismaCon([]);
    await servicio(prisma).getReporteCumplimiento('emp', undefined, undefined, {}, 'usr');
    await servicio(prisma).getDashboardCashflow('emp', {}, 'usr');
    expect(prisma.promesas_pago.findMany.mock.calls[0][0].where).toEqual({ empresa_id: 'emp', factura: { dest: { in: ['001'] } } });
    expect(prisma.promesas_pago.findMany.mock.calls[1][0].where.factura).toEqual({ dest: { in: ['001'] } });
  });

  it('alcance vacío → dest in [] (nada)', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([]));
    const prisma = prismaCon([]);
    await servicio(prisma).getReporteCumplimiento('emp', undefined, undefined, {}, 'usr');
    expect(prisma.promesas_pago.findMany.mock.calls[0][0].where.factura).toEqual({ dest: { in: [] } });
  });
});

describe('Promesas: cashflow por moneda', () => {
  it('proyección y total de siempre; en_moneda convertida por fecha; por_moneda separada', async () => {
    const prisma = prismaCon([
      { fecha_prometida: T('2026-11-10T00:00:00Z'), monto_prometido: D('1000000'), factura: factura(PYG.id) },
      { fecha_prometida: T('2026-11-10T00:00:00Z'), monto_prometido: D('100'), factura: factura(USD.id, '7300') },
      { fecha_prometida: T('2026-11-12T00:00:00Z'), monto_prometido: D('5'), factura: factura(USD.id) },
    ]);
    const r: any = await servicio(prisma).getDashboardCashflow('emp', {}, 'usr');
    expect(r.total_pendiente).toBe(1000105);
    expect(r.total_promesas).toBe(3);
    expect(r.proyeccion).toEqual([
      { fecha: '2026-11-10', monto: 1000100 },
      { fecha: '2026-11-12', monto: 5 },
    ]);
    expect(r.sin_cotizacion).toBe(1);
    expect(r.en_moneda).toEqual({
      total_pendiente: 1730000,
      proyeccion: [
        { fecha: '2026-11-10', monto: 1730000 },
        { fecha: '2026-11-12', monto: 0 },
      ],
    });
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', monto: '1000000.00' },
      { codigo: 'USD', monto: '105.00' },
    ]);
    expect(prisma.promesas_pago.findMany.mock.calls[0][0].select.factura).toEqual({ select: { moneda_id: true, dticam: true } });
  });

  it('USD elegida: filtra la factura y no convierte', async () => {
    const prisma = prismaCon([{ fecha_prometida: T('2026-11-10T00:00:00Z'), monto_prometido: D('100.25'), factura: factura(USD.id) }]);
    const r: any = await servicio(prisma).getDashboardCashflow('emp', { moneda_id: USD.id }, 'usr');
    expect(prisma.promesas_pago.findMany.mock.calls[0][0].where.factura).toEqual({ AND: [{ moneda_id: USD.id }] });
    expect(r.en_moneda.total_pendiente).toBe(100.25);
    expect(r.sin_cotizacion).toBe(0);
  });
});

describe('Promesas: controller', () => {
  it('pasa filtros y user.id a los dos reportes', async () => {
    const svc = { getReporteCumplimiento: jest.fn().mockResolvedValue({}), getDashboardCashflow: jest.fn().mockResolvedValue({}) };
    const ctrl = new PromesasController(svc as any);
    const user = { id: 'usr', empresa_id: 'emp' } as any;
    await ctrl.getReporteCumplimiento('2026-11-01', '2026-11-30', user, SUC_A, USD.id);
    expect(svc.getReporteCumplimiento).toHaveBeenCalledWith('emp', '2026-11-01', '2026-11-30', { sucursal_id: SUC_A, moneda_id: USD.id }, 'usr');
    await ctrl.getDashboardCashflow(user, SUC_A, USD.id);
    expect(svc.getDashboardCashflow).toHaveBeenCalledWith('emp', { sucursal_id: SUC_A, moneda_id: USD.id }, 'usr');
  });
});
