/**
 * Listados de rentabilidad (productos, clientes, sucursales) con moneda como el Tablero. Los campos de siempre
 * (`resumen`, `total`, `items`) suman los montos tal cual, sin filtrar por moneda: los fija la caracterización.
 */
import { ReportesRentabilidadService } from './reportes-rentabilidad.service';
import { ReportesRentabilidadController } from './reportes-rentabilidad.controller';
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 PYG = '00000000-0000-4000-8000-000000000001';
const USD = '00000000-0000-4000-8000-000000000002';
const MONEDAS: Record<string, { id: string; codigo: string }> = {
  [PYG]: { id: PYG, codigo: 'PYG' },
  [USD]: { id: USD, codigo: 'USD' },
};

const linea = (o: {
  factura: string;
  cliente: string;
  moneda: string | null;
  dticam: number | null;
  cantidad: number;
  ingresos: number;
  costoBase: number;
}) => ({
  producto_id: 'prod-1',
  factura_cab_id: o.factura,
  dcantproser: o.cantidad,
  dtotopeitem: o.ingresos,
  costo_unitario_venta: null,
  costo_total_venta: o.costoBase,
  productos: { id: 'prod-1', descripcion: 'SALSA', cod_producto: 'P1', precio_costo: null, categoria: null },
  factura_cab: {
    cliente_id: o.cliente,
    dest: '001',
    dticam: o.dticam,
    moneda_id: o.moneda,
    moneda: o.moneda ? { codigo: MONEDAS[o.moneda].codigo } : null,
    clientes: { id: o.cliente, personas: { razon_social: o.cliente.toUpperCase(), ruc: '800', dv: '1' } },
  },
  deposito: null,
});

/**
 * F1 PYG (vendedor al 5 %), F2 USD a 7.500 con comisión real de 11 USD, F3 USD sin cotización.
 * Costo siempre en la base (Gs.).
 */
const LINEAS = [
  linea({ factura: 'F1', cliente: 'cli-1', moneda: PYG, dticam: null, cantidad: 2, ingresos: 1_100_000, costoBase: 600_000 }),
  linea({ factura: 'F2', cliente: 'cli-1', moneda: USD, dticam: 7500, cantidad: 1, ingresos: 110, costoBase: 450_000 }),
  linea({ factura: 'F3', cliente: 'cli-2', moneda: USD, dticam: null, cantidad: 1, ingresos: 50, costoBase: 300_000 }),
];

function crear(lineas = LINEAS, baseId = PYG) {
  const prisma: any = {
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: baseId }) },
    moneda: {
      findFirst: jest.fn().mockResolvedValue(MONEDAS[PYG]),
      // Como Postgres con un uuid: sin distinguir mayúsculas, devuelve el id canónico.
      findUnique: jest.fn(({ where }: any) => Promise.resolve(MONEDAS[String(where.id).toLowerCase()] ?? null)),
      findMany: jest.fn().mockResolvedValue([]),
    },
    empresas_sucursales: {
      findMany: jest.fn().mockResolvedValue([{ id: 'suc-1', descripcion: 'MATRIZ', punto_establecimiento: '001' }]),
      findFirst: jest.fn().mockResolvedValue({ id: 'suc-1' }),
    },
    factura_det: { findMany: jest.fn().mockResolvedValue(lineas) },
    costos_operacion_credito: { findUnique: jest.fn().mockResolvedValue(null) },
    factura_cab: {
      findMany: jest.fn().mockResolvedValue([
        { id: 'F1', dfeemide: new Date('2026-10-05'), vendedor_id: 'ven-1', vendedor: { comision_venta: 5, comision_porcentaje: null } },
        { id: 'F2', dfeemide: new Date('2026-10-06'), vendedor_id: null, vendedor: null },
        { id: 'F3', dfeemide: new Date('2026-10-07'), vendedor_id: null, vendedor: null },
      ]),
    },
    factura_cuotas: { groupBy: jest.fn().mockResolvedValue([]) },
    comisiones: { groupBy: jest.fn().mockResolvedValue([{ factura_id: 'F2', _sum: { monto_comision: 11 } }]) },
  };
  return { prisma, svc: new ReportesRentabilidadService(prisma) };
}

const Q = { fecha_desde: '2026-10-01', fecha_hasta: '2026-10-31' };

/** Lo de hoy: todo sumado tal cual (1.100.000 Gs + 110 USD + 50 USD = 1.100.160). */
const RESUMEN_DE_SIEMPRE = {
  ingresos_total: 1_100_160,
  costo_total: 1_350_000,
  utilidad_total: -249_840,
  margen_pct: -22.71,
  utilidad_neta_total: -304_851,
  margen_neto_pct: -27.71,
  desglose_costos_credito: { comision_venta: 55_011, costo_cobranza: 0, costo_financiero: 0, mora_esperada: 0 },
  cantidad_total: 4,
  lineas: 3,
};

beforeEach(() => alcanceMock.mockResolvedValue(null));

describe('Rentabilidad: caracterización de los campos de siempre', () => {
  it('productos: una fila con todo sumado tal cual', async () => {
    const { svc } = crear();
    const r = await svc.getRentabilidadProductos('emp', Q, 'usr');
    expect(r.resumen).toEqual(RESUMEN_DE_SIEMPRE);
    expect(r.total).toBe(1);
    expect(r.items).toEqual([
      {
        producto_id: 'prod-1',
        codigo: 'P1',
        descripcion: 'SALSA',
        categoria_id: null,
        categoria: 'Sin categoría',
        cantidad_vendida: 4,
        ingresos: 1_100_160,
        costo: 1_350_000,
        utilidad: -249_840,
        margen_pct: -22.71,
        utilidad_neta: -304_851,
        margen_neto_pct: -27.71,
        facturas: 3,
      },
    ]);
    expect(r.filtros).toEqual({
      fecha_desde: '2026-10-01',
      fecha_hasta: '2026-10-31',
      sucursal_id: null,
      deposito_id: null,
      producto_id: null,
      cliente_id: null,
    });
  });

  it('clientes: por cliente, montos tal cual', async () => {
    const { svc } = crear();
    const r = await svc.getRentabilidadClientes('emp', Q, 'usr');
    expect(r.resumen).toEqual(RESUMEN_DE_SIEMPRE);
    expect(r.total).toBe(2);
    expect(r.items.map((i: any) => [i.cliente_id, i.ingresos, i.costo, i.utilidad, i.margen_pct, i.utilidad_neta, i.facturas])).toEqual([
      ['cli-1', 1_100_110, 1_050_000, 50_110, 4.55, -4_901, 2],
      ['cli-2', 50, 300_000, -299_950, -599_900, -299_950, 1],
    ]);
  });

  it('sucursales: por establecimiento, montos tal cual', async () => {
    const { svc } = crear();
    const r = await svc.getRentabilidadSucursales('emp', Q, 'usr');
    expect(r.resumen).toEqual(RESUMEN_DE_SIEMPRE);
    expect(r.items).toEqual([
      {
        sucursal_id: 'suc-1',
        sucursal: 'MATRIZ',
        cantidad_vendida: 4,
        ingresos: 1_100_160,
        costo: 1_350_000,
        utilidad: -249_840,
        margen_pct: -22.71,
        utilidad_neta: -304_851,
        margen_neto_pct: -27.71,
        facturas: 3,
      },
    ]);
  });
});

describe('Rentabilidad: listados con moneda como el Tablero', () => {
  it('productos sin moneda: «Convertido» a la base, una sola fila, costo en base y comisión USD convertida', async () => {
    const { svc } = crear();
    const r: any = await svc.getRentabilidadProductos('emp', Q, 'usr');
    // F1: 1.100.000 Gs; F2: 110 USD × 7.500 = 825.000; F3 sin cotización, fuera entera.
    expect(r.moneda).toEqual({ codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.sin_cotizacion).toBe(1);
    expect(r.en_moneda.resumen).toEqual({
      ingresos_total: 1_925_000,
      costo_total: 1_050_000,
      utilidad_total: 875_000,
      margen_pct: 45.45,
      // Comisión: 5 % de F1 (55.000) + 11 USD × 7.500 (82.500).
      utilidad_neta_total: 737_500,
      margen_neto_pct: 38.31,
      desglose_costos_credito: { comision_venta: 137_500, costo_cobranza: 0, costo_financiero: 0, mora_esperada: 0 },
      cantidad_total: 3,
      lineas: 2,
    });
    expect(r.en_moneda.total).toBe(1);
    expect(r.en_moneda.items).toHaveLength(1);
    const fila = r.en_moneda.items[0];
    expect(fila).toMatchObject({ producto_id: 'prod-1', ingresos: 1_925_000, costo: 1_050_000, utilidad: 875_000, facturas: 2 });
    expect(fila.margen_pct).toBe(Math.round((fila.utilidad / fila.ingresos) * 100 * 100) / 100);
    // Sin convertir, por código; la fila USD cierra: 160 − 50 (sin costo) − 60 = 50.
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', ingresos: '1100000.00', costo: '600000.00', utilidad: '500000.00', ingresos_sin_costo: '0.00' },
      { codigo: 'USD', ingresos: '160.00', costo: '60.00', utilidad: '50.00', ingresos_sin_costo: '50.00' },
    ]);
    // Lo de siempre no cambia.
    expect(r.resumen).toEqual(RESUMEN_DE_SIEMPRE);
  });

  it('con moneda_id USD: solo las facturas en USD, costo pasado a USD con desdeMonedaBase y comisión tal cual', async () => {
    const { svc } = crear();
    const r: any = await svc.getRentabilidadProductos('emp', { ...Q, moneda_id: USD }, 'usr');
    expect(r.moneda).toEqual({ codigo: 'USD' });
    expect(r.convertido).toBe(false);
    expect(r.sin_cotizacion).toBe(1);
    // 450.000 Gs / 7.500 = 60 USD.
    expect(r.en_moneda.resumen).toMatchObject({
      ingresos_total: 110,
      costo_total: 60,
      utilidad_total: 50,
      margen_pct: 45.45,
      utilidad_neta_total: 39,
      margen_neto_pct: 35.45,
      desglose_costos_credito: { comision_venta: 11, costo_cobranza: 0, costo_financiero: 0, mora_esperada: 0 },
    });
    expect(r.por_moneda).toEqual([{ codigo: 'USD', ingresos: '160.00', costo: '60.00', utilidad: '50.00', ingresos_sin_costo: '50.00' }]);
    // Los campos de siempre siguen sin filtrar por moneda (como hoy).
    expect(r.resumen).toEqual(RESUMEN_DE_SIEMPRE);
    expect(r.items[0].ingresos).toBe(1_100_160);
  });

  it('con la base elegida entran las facturas sin moneda; el id se compara resuelto (mayúsculas)', async () => {
    const lineas = [
      LINEAS[0],
      linea({ factura: 'F4', cliente: 'cli-1', moneda: null, dticam: null, cantidad: 1, ingresos: 200_000, costoBase: 100_000 }),
      LINEAS[1],
    ];
    const { svc } = crear(lineas);
    const r: any = await svc.getRentabilidadProductos('emp', { ...Q, moneda_id: PYG.toUpperCase() }, 'usr');
    expect(r.en_moneda.resumen.ingresos_total).toBe(1_300_000);
    expect(r.en_moneda.resumen.costo_total).toBe(700_000);
    expect(r.por_moneda).toEqual([{ codigo: 'PYG', ingresos: '1300000.00', costo: '700000.00', utilidad: '600000.00', ingresos_sin_costo: '0.00' }]);
    expect(r.sin_cotizacion).toBe(0);
  });

  it('clientes y sucursales: mismas formas en en_moneda', async () => {
    const { svc } = crear();
    const c: any = await svc.getRentabilidadClientes('emp', Q, 'usr');
    expect(c.en_moneda.total).toBe(1);
    expect(c.en_moneda.items[0]).toMatchObject({ cliente_id: 'cli-1', ingresos: 1_925_000, costo: 1_050_000, utilidad: 875_000, utilidad_neta: 737_500 });
    expect(Object.keys(c.en_moneda.items[0]).sort()).toEqual(Object.keys(c.items[0]).sort());
    expect(c.por_moneda).toHaveLength(2);
    const s: any = await svc.getRentabilidadSucursales('emp', Q, 'usr');
    expect(s.en_moneda.items).toEqual([expect.objectContaining({ sucursal_id: 'suc-1', ingresos: 1_925_000, costo: 1_050_000, margen_pct: 45.45 })]);
    expect(s.sin_cotizacion).toBe(1);
  });

  it('limit corta los items de en_moneda igual que los de siempre', async () => {
    const { svc } = crear();
    const c: any = await svc.getRentabilidadClientes('emp', { ...Q, limit: '1', moneda_id: USD }, 'usr');
    expect(c.items).toHaveLength(1);
    expect(c.en_moneda.items).toHaveLength(1);
  });

  it.each(['getRentabilidadProductos', 'getRentabilidadClientes', 'getRentabilidadSucursales', 'getRentabilidadDashboard'] as const)(
    '%s: las dos pasadas comparten las consultas del agregado',
    async (metodo) => {
      const { svc, prisma } = crear();
      await (svc as any)[metodo]('emp', Q, 'usr');
      expect(prisma.costos_operacion_credito.findUnique).toHaveBeenCalledTimes(1);
      expect(prisma.factura_cab.findMany).toHaveBeenCalledTimes(1);
      expect(prisma.comisiones.groupBy).toHaveBeenCalledTimes(1);
      expect(prisma.empresas_sucursales.findMany).toHaveBeenCalledTimes(1);
    },
  );

  it('moneda inexistente → 400 MONEDA_INVALIDA', async () => {
    const { svc } = crear();
    await expect(
      svc.getRentabilidadProductos('emp', { ...Q, moneda_id: '00000000-0000-4000-8000-000000000099' }, 'usr'),
    ).rejects.toMatchObject({ status: 400, response: { codigo: 'MONEDA_INVALIDA' } });
  });

  it('dashboard: la comisión real USD entra a en_moneda convertida con la cotización de su factura', async () => {
    const lineas = LINEAS.slice(0, 2);
    const { svc, prisma } = crear(lineas);
    const r: any = await svc.getRentabilidadDashboard('emp', Q, 'usr');
    expect(r.en_moneda.resumen.desglose_costos_credito.comision_venta).toBe(137_500);
    expect(r.en_moneda.resumen.utilidad_neta_total).toBe(737_500);
    // Lo de siempre del dashboard: tal cual.
    expect(r.resumen.desglose_costos_credito.comision_venta).toBe(55_011);
    expect(prisma.factura_det.findMany).toHaveBeenCalledTimes(1);
  });
});

describe('ReportesRentabilidadController: moneda_id en los listados', () => {
  it.each(['getProductos', 'getClientes', 'getSucursales'] as const)('%s pasa moneda_id al servicio', (metodo) => {
    const service: any = {
      getRentabilidadProductos: jest.fn(),
      getRentabilidadClientes: jest.fn(),
      getRentabilidadSucursales: jest.fn(),
    };
    const ctrl = new ReportesRentabilidadController(service);
    (ctrl as any)[metodo]({ empresa_id: 'emp', id: 'usr' }, '2026-10-01', '2026-10-31', undefined, undefined, undefined, undefined, '50', USD);
    const llamado = Object.values(service).find((fn: any) => fn.mock.calls.length) as jest.Mock;
    expect(llamado.mock.calls[0]).toEqual(['emp', expect.objectContaining({ moneda_id: USD, limit: '50' }), 'usr']);
  });
});
