/**
 * B0 Reportes: reporte del cobrador, intereses cobrados y remisiones recortan por la sucursal del usuario (los recibos
 * por `sucursal_id`, las facturas y remisiones por `dest`) y cortan con 403 una sucursal pedida fuera del alcance o de
 * otra empresa.
 */
import { ReporteCobradorController } from './reporte-cobrador.controller';
import { ReporteInteresesCobradosController } from './reporte-intereses-cobrados.controller';
import { ReportesRemisionService } from 'src/reportes-remision/reportes-remision.service';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';

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

const RESTRINGIDO = { sucursalIds: ['suc-a', 'suc-c'], puntosEstablecimiento: ['001', '003'], depositoIds: [] };
const USER = { id: 'usr', empresa_id: 'emp' } as any;
const ESTABLECIMIENTO: Record<string, string> = { 'suc-a': '001', 'suc-c': '003' };

function prismaMock(sucursalDeLaEmpresa = false) {
  return {
    empresas_sucursales: {
      findFirst: jest.fn().mockResolvedValue(sucursalDeLaEmpresa ? { id: 'suc-a' } : null),
      findMany: jest.fn(async (a: any) => (a.where.id.in as string[]).map((id) => ({ punto_establecimiento: ESTABLECIMIENTO[id], config: null }))),
    },
    vendedores_cobradores: { findMany: jest.fn().mockResolvedValue([{ id: 'cob1', nombre: 'Ana', apellido: null }]) },
    recibos_cobro: { findMany: jest.fn().mockResolvedValue([]), count: jest.fn().mockResolvedValue(0) },
    // D-T2: las cuotas pendientes van por `groupBy` (moneda de la factura) y el reporte resuelve la moneda base.
    cuotas_calculadas_detalle: { groupBy: jest.fn().mockResolvedValue([]) },
    cuotas_calculadas: { findMany: jest.fn().mockResolvedValue([]) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: 'm-pyg' }) },
    moneda: {
      findFirst: jest.fn().mockResolvedValue(null),
      findUnique: jest.fn().mockResolvedValue({ id: 'm-pyg', codigo: 'PYG' }),
      findMany: jest.fn().mockResolvedValue([{ id: 'm-pyg', codigo: 'PYG' }]),
    },
    cob_interes_cobrado: { findMany: jest.fn().mockResolvedValue([]) },
    factura_cuotas: { findMany: jest.fn().mockResolvedValue([]) },
    nota_remision_cab: { findMany: jest.fn().mockResolvedValue([]) },
  } as any;
}

type Caso = { nombre: string; correr: (prisma: any, sucursalId?: string) => Promise<unknown>; whereSucursal: (prisma: any) => unknown };

const reciboWhere = (prisma: any) => prisma.recibos_cobro.findMany.mock.calls[0][0].where.sucursal_id;
const remisionWhere = (prisma: any) => prisma.nota_remision_cab.findMany.mock.calls[0][0].where.dest;

const CASOS: Caso[] = [
  {
    nombre: 'cobrador por-cobrador',
    correr: (p, s) => new ReporteCobradorController(p).getPorCobrador(USER, '2026-11-01', '2026-11-07', s),
    whereSucursal: reciboWhere,
  },
  {
    nombre: 'cobrador productividad',
    correr: (p, s) => new ReporteCobradorController(p).getProductividad(USER, '2026-11-01', '2026-11-07', undefined, s),
    whereSucursal: reciboWhere,
  },
  {
    nombre: 'cobrador detalle',
    correr: (p, s) => new ReporteCobradorController(p).getDetalle(USER, 'cob1', '2026-11-01', '2026-11-07', '1', '20', s),
    whereSucursal: reciboWhere,
  },
  {
    nombre: 'intereses resumen',
    correr: (p, s) => new ReporteInteresesCobradosController(p).getResumen(USER, '2026-11-01', '2026-11-07', undefined, undefined, s),
    whereSucursal: reciboWhere,
  },
  {
    nombre: 'intereses detalle',
    correr: (p, s) => new ReporteInteresesCobradosController(p).getDetalle(USER, '2026-11-01', '2026-11-07', undefined, undefined, '1', '20', s),
    whereSucursal: reciboWhere,
  },
  {
    nombre: 'remisiones resumen',
    correr: (p, s) => new ReportesRemisionService(p).getResumen('emp', 'chofer', { sucursal_id: s }, 'usr'),
    whereSucursal: remisionWhere,
  },
  {
    nombre: 'remisiones detalle',
    correr: (p, s) => new ReportesRemisionService(p).getDetalle('emp', { sucursal_id: s }, 1, 20, 'usr'),
    whereSucursal: remisionWhere,
  },
  {
    nombre: 'remisiones pendientes de facturar',
    correr: (p, s) => new ReportesRemisionService(p).getPendientesFacturar('emp', { sucursal_id: s }, 'usr'),
    whereSucursal: remisionWhere,
  },
];

const esRemision = (c: Caso) => c.nombre.startsWith('remisiones');
const esperadoPropia = (c: Caso) => (esRemision(c) ? { in: ['001'] } : 'suc-a');
const esperadoAlcance = (c: Caso) => (esRemision(c) ? { in: ['001', '003'] } : { in: ['suc-a', 'suc-c'] });

describe.each(CASOS.map((c) => [c.nombre, c] as const))('%s: sucursal', (_n, caso) => {
  it('sucursal de otra empresa (alcance total) → 403 SUCURSAL_FUERA_DE_ALCANCE', async () => {
    alcanceMock.mockResolvedValue(null);
    const prisma = prismaMock(false);
    await expect(caso.correr(prisma, 'suc-otra')).rejects.toMatchObject({ status: 403, response: { codigo: 'SUCURSAL_FUERA_DE_ALCANCE' } });
    expect(prisma.recibos_cobro.findMany).not.toHaveBeenCalled();
    expect(prisma.nota_remision_cab.findMany).not.toHaveBeenCalled();
  });

  it('restringido pide una que no tiene → 403', async () => {
    alcanceMock.mockResolvedValue(RESTRINGIDO);
    await expect(caso.correr(prismaMock(), 'suc-b')).rejects.toMatchObject({ status: 403 });
  });

  it('restringido pide la suya → solo esa', async () => {
    alcanceMock.mockResolvedValue(RESTRINGIDO);
    const prisma = prismaMock();
    await caso.correr(prisma, 'suc-a');
    expect(caso.whereSucursal(prisma)).toEqual(esperadoPropia(caso));
  });

  it('admin pide una propia → ok', async () => {
    alcanceMock.mockResolvedValue(null);
    const prisma = prismaMock(true);
    await caso.correr(prisma, 'suc-a');
    expect(caso.whereSucursal(prisma)).toEqual(esperadoPropia(caso));
  });

  it('sin sucursal: restringido ve solo las de su alcance (antes, toda la empresa)', async () => {
    alcanceMock.mockResolvedValue(RESTRINGIDO);
    const prisma = prismaMock();
    await caso.correr(prisma);
    expect(caso.whereSucursal(prisma)).toEqual(esperadoAlcance(caso));
  });

  it('sin sucursal y alcance total → como hoy, sin recorte', async () => {
    alcanceMock.mockResolvedValue(null);
    const prisma = prismaMock();
    await caso.correr(prisma);
    expect(caso.whereSucursal(prisma)).toBeUndefined();
  });
});

describe('cobrador por-cobrador: las cuotas pendientes también se recortan (por el establecimiento de la factura)', () => {
  it('restringido sin sucursal → factura_cab con dest de su alcance', async () => {
    alcanceMock.mockResolvedValue(RESTRINGIDO);
    const prisma = prismaMock();
    await new ReporteCobradorController(prisma).getPorCobrador(USER, '2026-11-01', '2026-11-07');
    const fc = prisma.cuotas_calculadas_detalle.groupBy.mock.calls[0][0].where.cuotas_calculadas.factura_cab;
    expect(fc.AND).toEqual([{ dest: { in: ['001', '003'] } }]);
  });
});
