/**
 * Tablero «lo mío» en Cuentas a cobrar. Cuotas: vendedor → sus facturas; cobrador → su cartera (`carteraCobradorWhere`);
 * ambos → cualquiera. Cobrado = plata recibida, como el total de la empresa (`monto_total` del recibo): cobrador → sus
 * recibos; vendedor → la parte de cada recibo que corresponde a sus facturas (MULTI: `monto_pagado + monto_interes −
 * monto_nc − monto_retencion`; por cuota: `monto_pagado`), nunca el `monto_total` entero; ambos → la unión sin contar
 * dos veces (lo de sus facturas se suma solo de recibos que no son del cobrador).
 */
import { CobrosService } from './cobros.service';
import { carteraCobradorWhere } from 'src/cobranzas/cartera-cobrador';
import { resolverAlcancePropio, UUID_NULO } from 'src/utils/alcance-propio';
import { ESTADOS_FACTURA_NO_COBRABLE_PRISMA } from 'src/utils/estados-factura';

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

const PYG = 'm-pyg';
const USD = 'm-usd';
const CODIGOS: Record<string, string> = { [PYG]: 'PYG', [USD]: 'USD' };

function crearPrisma() {
  return {
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: PYG }) },
    moneda: {
      findFirst: jest.fn().mockResolvedValue({ id: PYG, codigo: 'PYG' }),
      findUnique: jest.fn().mockResolvedValue({ id: PYG, codigo: 'PYG' }),
      findMany: jest.fn(({ where }) =>
        Promise.resolve((where.id.in as string[]).map((id) => ({ id, codigo: CODIGOS[id] })).filter((m) => m.codigo)),
      ),
    },
    empresas_sucursales: { findMany: jest.fn().mockResolvedValue([]), findFirst: jest.fn().mockResolvedValue(null) },
    factura_cuotas: { findMany: jest.fn().mockResolvedValue([]) },
    config_mora: { findFirst: jest.fn().mockResolvedValue(null) },
    cob_config_intereses: { findFirst: jest.fn().mockResolvedValue(null) },
    recibos_cobro: {
      aggregate: jest.fn().mockResolvedValue({ _sum: { monto_total: null } }),
      groupBy: jest.fn().mockResolvedValue([]),
    },
    recibo_cobro_facturas: { findMany: jest.fn().mockResolvedValue([]) },
    recibo_cobro_detalle: { findMany: jest.fn().mockResolvedValue([]) },
  } as any;
}

const propio = (vendedorId: string | null, cobradorId: string | null) => ({ tipo: 'PROPIO', vendedorId, cobradorId, nombre: 'Ana', sinVinculo: false });

async function correr(alcance: unknown, preparar?: (p: any) => void, vista: 'tablero' | null = 'tablero') {
  alcanceMock.mockReset().mockResolvedValue(alcance);
  const prisma = crearPrisma();
  preparar?.(prisma);
  const r = await new (CobrosService as any)(prisma).getCuentasCobrarDashboard('emp', {}, 'usr', vista ?? undefined);
  return {
    r,
    prisma,
    cuotas: prisma.factura_cuotas.findMany.mock.calls[0][0].where.factura_cab,
    recibosAgg: prisma.recibos_cobro.aggregate.mock.calls[0][0].where,
    recibosGroup: prisma.recibos_cobro.groupBy.mock.calls[0][0].where,
  };
}

const RECIBO_BASE = { empresa_id: 'emp', estado: { not: 'anulado' } };
const ajenoA = (cobradorId: string) => ({ ...RECIBO_BASE, OR: [{ cobrador_id: null }, { cobrador_id: { not: cobradorId } }] });

describe('getCuentasCobrarDashboard en alcance propio', () => {
  it('TODO: los where de cuotas y recibos son los de siempre y no se mira lo aplicado', async () => {
    const { cuotas, recibosAgg, recibosGroup, prisma } = await correr({ tipo: 'TODO' });
    expect(cuotas).toEqual({ empresa_id: 'emp', estado: { notIn: ESTADOS_FACTURA_NO_COBRABLE_PRISMA } });
    expect(recibosAgg).toEqual(RECIBO_BASE);
    expect(recibosGroup).toEqual(RECIBO_BASE);
    expect(prisma.recibo_cobro_facturas.findMany).not.toHaveBeenCalled();
    expect(prisma.recibo_cobro_detalle.findMany).not.toHaveBeenCalled();
  });

  it('cobrador: su cartera y sus recibos (monto_total); no mira lo aplicado por vendedor', async () => {
    const { cuotas, recibosAgg, recibosGroup, prisma, r } = await correr(propio(null, 'c1'), (p) => {
      p.recibos_cobro.aggregate.mockResolvedValue({ _sum: { monto_total: 1000 } });
      p.recibos_cobro.groupBy.mockResolvedValue([{ moneda_id: PYG, cotizacion: null, _sum: { monto_total: 1000 }, _count: { _all: 2 } }]);
    });
    expect(alcanceMock).toHaveBeenCalledWith(expect.anything(), 'usr', 'emp');
    expect(cuotas.AND).toEqual([carteraCobradorWhere('c1')]);
    expect(recibosAgg).toEqual({ ...RECIBO_BASE, cobrador_id: 'c1' });
    expect(recibosGroup).toEqual({ ...RECIBO_BASE, cobrador_id: 'c1' });
    expect(prisma.recibo_cobro_facturas.findMany).not.toHaveBeenCalled();
    expect(r.total_cobrado).toBe(1000);
    expect(r.en_moneda.total_cobrado).toBe(1000);
  });

  it('vendedor: sus facturas; cobrado = lo de sus facturas (MULTI y por cuota), no el monto_total del recibo', async () => {
    const { cuotas, recibosAgg, prisma, r } = await correr(propio('v1', null), (p) => {
      // Recibo A (MULTI, 900 en total) aplica 300 a la factura del vendedor; recibo B (cuotas) 100 + 50.
      p.recibo_cobro_facturas.findMany.mockResolvedValue([
        { recibo_cobro_id: 'A', monto_pagado: 300, monto_nc: 0, monto_retencion: 0, monto_interes: 0, recibo: { moneda_id: PYG, cotizacion: null } },
      ]);
      p.recibo_cobro_detalle.findMany.mockResolvedValue([
        { recibo_cobro_id: 'B', monto_pagado: 100, recibos_cobro: { moneda_id: PYG, cotizacion: null } },
        { recibo_cobro_id: 'B', monto_pagado: 50, recibos_cobro: { moneda_id: PYG, cotizacion: null } },
      ]);
    });
    expect(cuotas.AND).toEqual([{ vendedor_id: 'v1' }]);
    // Sin cobrador: los recibos «del cobrador» son de UUID_NULO (vacío).
    expect(recibosAgg).toEqual({ ...RECIBO_BASE, cobrador_id: UUID_NULO });
    expect(prisma.recibo_cobro_facturas.findMany.mock.calls[0][0].where).toEqual({
      factura: { vendedor_id: 'v1' },
      recibo: { ...ajenoA(UUID_NULO), modo: 'MULTI' },
    });
    expect(prisma.recibo_cobro_detalle.findMany.mock.calls[0][0].where).toEqual({
      factura_cuotas: { factura_cab: { vendedor_id: 'v1' } },
      recibos_cobro: { ...ajenoA(UUID_NULO), modo: { not: 'MULTI' } },
    });
    expect(r.total_cobrado).toBe(450);
    expect(r.en_moneda.total_cobrado).toBe(450);
    expect(r.por_moneda).toEqual([expect.objectContaining({ codigo: 'PYG', cobrado: '450.00' })]);
  });

  it('ambos: cartera OR facturas propias; cobrado = sus recibos + lo aplicado a sus facturas en recibos de otros', async () => {
    const { cuotas, recibosAgg, prisma, r } = await correr(propio('v1', 'c1'), (p) => {
      p.recibos_cobro.aggregate.mockResolvedValue({ _sum: { monto_total: 1000 } });
      p.recibos_cobro.groupBy.mockResolvedValue([{ moneda_id: PYG, cotizacion: null, _sum: { monto_total: 1000 }, _count: { _all: 1 } }]);
      p.recibo_cobro_facturas.findMany.mockResolvedValue([
        { recibo_cobro_id: 'A', monto_pagado: 300, monto_nc: 0, monto_retencion: 0, monto_interes: 0, recibo: { moneda_id: PYG, cotizacion: null } },
      ]);
    });
    expect(cuotas.AND).toEqual([{ OR: [{ vendedor_id: 'v1' }, carteraCobradorWhere('c1')] }]);
    expect(recibosAgg).toEqual({ ...RECIBO_BASE, cobrador_id: 'c1' });
    expect(prisma.recibo_cobro_facturas.findMany.mock.calls[0][0].where.recibo).toEqual({ ...ajenoA('c1'), modo: 'MULTI' });
    expect(r.total_cobrado).toBe(1300);
  });

  it('vendedor MULTI: neto de NC y retención, más el interés (lo que entró en plata, como el monto_total)', async () => {
    const { r } = await correr(propio('v1', null), (p) => {
      // Factura de 1000 saldada con 100 de NC y 30 de retención, más 20 de interés: entraron 890.
      p.recibo_cobro_facturas.findMany.mockResolvedValue([
        { recibo_cobro_id: 'A', monto_pagado: 1000, monto_nc: 100, monto_retencion: 30, monto_interes: 20, recibo: { moneda_id: PYG, cotizacion: null } },
      ]);
    });
    expect(r.total_cobrado).toBe(890);
    expect(r.en_moneda.total_cobrado).toBe(890);
  });

  it('sin vista=tablero (Antigüedad de CxC): ni consulta el alcance propio; cuotas y recibos de siempre', async () => {
    const { cuotas, recibosAgg, prisma } = await correr(propio('v1', 'c1'), undefined, null);
    expect(alcanceMock).not.toHaveBeenCalled();
    expect(JSON.stringify(cuotas ?? {})).not.toContain('vendedor_id');
    expect(recibosAgg).toEqual(RECIBO_BASE);
    expect(prisma.recibo_cobro_facturas.findMany).not.toHaveBeenCalled();
  });

  it('vista=tablero sin vínculo: UUID_NULO en cuotas y recibos (todo vacío)', async () => {
    const { cuotas, recibosAgg, prisma } = await correr({ ...propio(null, null), nombre: '', sinVinculo: true });
    expect(cuotas.AND).toEqual([{ vendedor_id: UUID_NULO }]);
    expect(recibosAgg).toEqual({ ...RECIBO_BASE, cobrador_id: UUID_NULO });
    expect(prisma.recibo_cobro_facturas.findMany).not.toHaveBeenCalled();
    expect(prisma.recibo_cobro_detalle.findMany).not.toHaveBeenCalled();
  });

  it('PROPIO sin vendedor ni cobrador: UUID_NULO en cuotas y recibos', async () => {
    const { cuotas, recibosAgg, prisma } = await correr(propio(null, null));
    expect(cuotas.AND).toEqual([{ vendedor_id: UUID_NULO }]);
    expect(recibosAgg).toEqual({ ...RECIBO_BASE, cobrador_id: UUID_NULO });
    expect(prisma.recibo_cobro_facturas.findMany).not.toHaveBeenCalled();
  });

  it('convertido: lo aplicado en USD se convierte con la cotización del recibo; sin cotización cuenta el recibo una vez', async () => {
    const { r } = await correr(propio('v1', null), (p) => {
      p.recibo_cobro_facturas.findMany.mockResolvedValue([
        { recibo_cobro_id: 'A', monto_pagado: 10, monto_nc: 0, monto_retencion: 0, monto_interes: 0, recibo: { moneda_id: USD, cotizacion: 7000 } },
        { recibo_cobro_id: 'C', monto_pagado: 5, monto_nc: 0, monto_retencion: 0, monto_interes: 0, recibo: { moneda_id: USD, cotizacion: null } },
        { recibo_cobro_id: 'C', monto_pagado: 5, monto_nc: 0, monto_retencion: 0, monto_interes: 0, recibo: { moneda_id: USD, cotizacion: null } },
      ]);
    });
    expect(r.en_moneda.total_cobrado).toBe(70000);
    expect(r.sin_cotizacion).toBe(1);
  });
});

describe('getCuentasCobrarDashboard: mora proyectada (el mismo cálculo del cobro)', () => {
  const cuotaVencida = (dias: number) => ({
    id: 'c1', factura_cab_id: 'f1', dmoncuota: 250000, saldo_pendiente: 250000, estado: 'pendiente',
    dvenccuo: new Date(Date.now() - dias * 86400000),
    factura_cab: { id: 'f1', total_notas_credito: 0, dticam: 1, moneda: { codigo: 'PYG' }, clientes: { id: 'cl', personas: { razon_social: 'X' } } },
  });
  const correrMora = async (config: unknown) => {
    alcanceMock.mockReset().mockResolvedValue({ tipo: 'TODO' });
    const prisma = crearPrisma();
    prisma.factura_cuotas.findMany.mockResolvedValue([cuotaVencida(12)]);
    prisma.config_mora.findFirst.mockResolvedValue(config);
    return new (CobrosService as any)(prisma).getCuentasCobrarDashboard('emp', {}, 'usr');
  };

  it('mora activa: envía mora_activa y total_mora_proyectada (1 % diario, gracia 2)', async () => {
    const r = await correrMora({ activo: true, tipo_calculo: 'diario', tasa: 1, periodo_gracia: 2, base_calculo: 'saldo_pendiente', monto_minimo_mora: 0, monto_maximo_mora: null });
    expect(r.mora_activa).toBe(true);
    expect(r.total_mora_proyectada).toBe(25000);
  });
  it('mora desactivada: mora_activa falso y 0', async () => {
    const r = await correrMora({ activo: false });
    expect(r.mora_activa).toBe(false);
    expect(r.total_mora_proyectada).toBe(0);
  });
});
