import { BadRequestException, NotFoundException } from '@nestjs/common';
import { AsignacionFacturasService } from './asignacion-facturas.service';

// Asignación (spec 2026-10-17-comercial-finanzas, Backend 5): vendedor a N facturas en una sola
// transacción, y el resumen por cobrador separado por moneda.

const PYG = { id: 'm-pyg', codigo: 'PYG', simbolo: '₲' };
const USD = { id: 'm-usd', codigo: 'USD', simbolo: 'US$' };
// Ids con forma de uuid: el service rechaza los que no lo son (I2 de la revisión final).
const VC1 = '0a0a0a0a-0000-4000-8000-000000000001';
const VCX = '0a0a0a0a-0000-4000-8000-0000000000ff';
const F1 = 'f0f0f0f0-0000-4000-8000-000000000001';
const F2 = 'f0f0f0f0-0000-4000-8000-000000000002';
const F3 = 'f0f0f0f0-0000-4000-8000-000000000003';
const FX = 'f0f0f0f0-0000-4000-8000-0000000000ff';

const vendedor = {
  id: VC1,
  empresa_id: 'emp-1',
  nombre: 'Ana',
  apellido: 'Gómez',
  tipo: 'vendedor',
  active: true,
  comision_venta: '5',
  comision_porcentaje: null,
  comision_fija: null,
};

const factura = (id: string, dtotope: string) => ({ id, empresa_id: 'emp-1', factura_subtotales: [{ dtotope }] });

/** Prisma falso: lo escrito en `$transaction` se confirma solo si el callback termina bien. */
const crearService = (opts: { facturas?: any[]; vendedor?: any; existentes?: any[]; moduloComisiones?: boolean; fallarEn?: string } = {}) => {
  const confirmado = { asignaciones: [] as any[], facturas: [] as any[], comisiones: [] as any[] };
  const hacerDb = (destino: typeof confirmado) => ({
    asignacion_facturas: {
      findFirst: jest.fn().mockImplementation(({ where }: any) =>
        Promise.resolve((opts.existentes ?? []).find((e) => e.factura_id === where.factura_id) ?? null),
      ),
      update: jest.fn().mockImplementation(({ where, data }: any) => {
        destino.asignaciones.push({ id: where.id, ...data });
        return Promise.resolve({ id: where.id, ...data, vendedor });
      }),
      create: jest.fn().mockImplementation(({ data }: any) => {
        destino.asignaciones.push(data);
        return Promise.resolve({ id: 'a-' + data.factura_id, ...data, vendedor });
      }),
    },
    factura_cab: {
      update: jest.fn().mockImplementation(({ where, data }: any) => {
        destino.facturas.push({ id: where.id, ...data });
        return Promise.resolve({});
      }),
    },
    comisiones: {
      findFirst: jest.fn().mockResolvedValue(null),
      create: jest.fn().mockImplementation(({ data }: any) => {
        if (opts.fallarEn === data.factura_id) return Promise.reject(new Error('falla de base'));
        destino.comisiones.push(data);
        return Promise.resolve(data);
      }),
    },
  });
  const directo = hacerDb(confirmado);
  const prisma: any = {
    ...directo,
    factura_cab: {
      ...directo.factura_cab,
      findFirst: jest.fn().mockImplementation(({ where }: any) =>
        Promise.resolve((opts.facturas ?? []).find((f) => f.id === where.id) ?? null),
      ),
      findMany: jest.fn().mockImplementation(({ where }: any) =>
        Promise.resolve((opts.facturas ?? []).filter((f) => where.id.in.includes(f.id))),
      ),
    },
    vendedores_cobradores: { findFirst: jest.fn().mockResolvedValue(opts.vendedor === undefined ? vendedor : opts.vendedor) },
    suscripcion_submodulos: { findFirst: jest.fn().mockResolvedValue(opts.moduloComisiones === false ? null : { id: 's' }) },
    suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue(null) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda: PYG }) },
    moneda: { findFirst: jest.fn().mockResolvedValue(PYG) },
  };
  prisma.$transaction = jest.fn().mockImplementation(async (cb: any) => {
    const pendiente = { asignaciones: [] as any[], facturas: [] as any[], comisiones: [] as any[] };
    const r = await cb(hacerDb(pendiente));
    confirmado.asignaciones.push(...pendiente.asignaciones);
    confirmado.facturas.push(...pendiente.facturas);
    confirmado.comisiones.push(...pendiente.comisiones);
    return r;
  });
  return { service: new AsignacionFacturasService(prisma, {} as any), prisma, confirmado };
};

describe('AsignacionFacturasService · vendedor-masivo', () => {
  it('asigna N facturas y crea sus comisiones, en una transacción', async () => {
    const { service, prisma, confirmado } = crearService({
      facturas: [factura(F1, '1000'), factura(F2, '2000'), factura(F3, '0')],
      existentes: [{ id: 'a-viejo', factura_id: F2 }],
    });

    const r = await service.asignarVendedorMasivo('emp-1', [F1, F2, F3, F1], VC1, 'u-1');

    expect(r).toEqual({ asignadas: 3, vendedor: { id: VC1, nombre: 'Ana' } });
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(confirmado.asignaciones).toEqual([
      { empresa_id: 'emp-1', factura_id: F1, vendedor_id: VC1, asignado_por: 'u-1', estado: 'pendiente' },
      { id: 'a-viejo', vendedor_id: VC1 },
      { empresa_id: 'emp-1', factura_id: F3, vendedor_id: VC1, asignado_por: 'u-1', estado: 'pendiente' },
    ]);
    expect(confirmado.facturas.map((f) => f.id)).toEqual([F1, F2, F3]);
    expect(confirmado.facturas.every((f) => f.vendedor_id === VC1)).toBe(true);
    // Igual que el individual: comisión de venta pendiente, salvo la de monto 0.
    expect(confirmado.comisiones.map((c) => [c.factura_id, Number(c.monto_comision), c.estado, c.tipo])).toEqual([
      [F1, 50, 'pendiente', 'venta'],
      [F2, 100, 'pendiente', 'venta'],
    ]);
  });

  it('una factura inexistente → 400 y no asigna ninguna', async () => {
    const { service, prisma, confirmado } = crearService({ facturas: [factura(F1, '1000')] });
    await expect(service.asignarVendedorMasivo('emp-1', [F1, FX], VC1, 'u-1')).rejects.toThrow(
      new BadRequestException('Algunas facturas no fueron encontradas'),
    );
    expect(prisma.$transaction).not.toHaveBeenCalled();
    expect(confirmado.asignaciones).toHaveLength(0);
    expect(confirmado.facturas).toHaveLength(0);
  });

  it('si falla una factura a mitad, no queda ninguna asignada', async () => {
    const { service, confirmado } = crearService({
      facturas: [factura(F1, '1000'), factura(F2, '2000')],
      fallarEn: F2,
    });
    await expect(service.asignarVendedorMasivo('emp-1', [F1, F2], VC1, 'u-1')).rejects.toThrow('falla de base');
    expect(confirmado.asignaciones).toHaveLength(0);
    expect(confirmado.comisiones).toHaveLength(0);
  });

  it('vendedor inexistente → 404', async () => {
    const { service } = crearService({ facturas: [factura(F1, '1000')], vendedor: null });
    await expect(service.asignarVendedorMasivo('emp-1', [F1], VCX, 'u-1')).rejects.toThrow(
      new NotFoundException('Vendedor no encontrado'),
    );
  });

  it('sin facturas → 400', async () => {
    const { service } = crearService();
    await expect(service.asignarVendedorMasivo('emp-1', [], VC1, 'u-1')).rejects.toThrow(BadRequestException);
  });

  it('el individual conserva sus efectos', async () => {
    const { service, confirmado } = crearService({ facturas: [factura(F1, '1000')] });
    const r: any = await service.asignarVendedor('emp-1', F1, VC1, 'u-1');
    expect(r).toMatchObject({ factura_id: F1, vendedor_id: VC1, vendedor });
    expect(confirmado.facturas).toEqual([{ id: F1, vendedor_id: VC1 }]);
    expect(confirmado.comisiones).toHaveLength(1);
  });

  // I2: sin el id (o con uno que no es uuid) se respondía con una persona o factura cualquiera, o un 500.
  it('sin vendedor o con un id que no es uuid → 400, sin buscar a nadie', async () => {
    const { service, prisma } = crearService({ facturas: [factura(F1, '1000')] });
    for (const id of [undefined, '', 'vc-1']) {
      await expect(service.asignarVendedorMasivo('emp-1', [F1], id as any, 'u-1')).rejects.toThrow(
        new BadRequestException('Seleccioná un vendedor'),
      );
      await expect(service.asignarVendedor('emp-1', F1, id as any, 'u-1')).rejects.toThrow(
        new BadRequestException('Seleccioná un vendedor'),
      );
    }
    expect(prisma.vendedores_cobradores.findFirst).not.toHaveBeenCalled();
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('una factura con id que no es uuid → 400 (antes 500), sin asignar ninguna', async () => {
    const { service, prisma } = crearService({ facturas: [factura(F1, '1000')] });
    await expect(service.asignarVendedorMasivo('emp-1', [F1, 'f-x'], VC1, 'u-1')).rejects.toThrow(
      new BadRequestException('Algunas facturas no fueron encontradas'),
    );
    await expect(service.asignarVendedor('emp-1', undefined as any, VC1, 'u-1')).rejects.toThrow(BadRequestException);
    expect(prisma.factura_cab.findFirst).not.toHaveBeenCalled();
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('cobrador: sin id o con ids que no son uuid → 400, sin buscar a nadie', async () => {
    const { service, prisma } = crearService({ facturas: [factura(F1, '1000')] });
    await expect(service.asignarCobradorMasivo('emp-1', [F1], undefined as any, 'u-1')).rejects.toThrow(
      new BadRequestException('Seleccioná un cobrador'),
    );
    await expect(service.asignarCobradorMasivo('emp-1', ['nada'], VC1, 'u-1')).rejects.toThrow(
      new BadRequestException('Algunas facturas no fueron encontradas'),
    );
    await expect(service.asignarCobradorMasivo('emp-1', [], VC1, 'u-1')).rejects.toThrow(
      new BadRequestException('Elegí al menos una factura'),
    );
    await expect(service.asignarCobrador('emp-1', F1, 'c-1', 'u-1')).rejects.toThrow(
      new BadRequestException('Seleccioná un cobrador'),
    );
    await expect(service.asignarCobrador('emp-1', undefined as any, VC1, 'u-1')).rejects.toThrow(
      new BadRequestException('Factura no encontrada'),
    );
    expect(prisma.vendedores_cobradores.findFirst).not.toHaveBeenCalled();
    expect(prisma.factura_cab.findFirst).not.toHaveBeenCalled();
  });
});

describe('AsignacionFacturasService · resumen-cobradores', () => {
  const asignacion = (cobrador: any, moneda: any, saldo: string | null, dtotope: string) => ({
    cobrador_id: cobrador.id,
    cobrador,
    factura_cab: {
      moneda,
      cuentas_cobrar: saldo === null ? [] : [{ saldo_pendiente: saldo }],
      factura_subtotales: [{ dtotope }],
    },
  });

  it('separa los montos por moneda', async () => {
    const c1 = { id: 'c-1', nombre: 'Beto', apellido: 'Ruiz', codigo: 'C1' };
    const c2 = { id: 'c-2', nombre: 'Caro', apellido: null, codigo: 'C2' };
    const { service, prisma } = crearService();
    prisma.asignacion_facturas.findMany = jest.fn().mockResolvedValue([
      asignacion(c1, PYG, '100000', '150000'),
      asignacion(c1, USD, '30', '40'),
      asignacion(c1, null, null, '5000'), // sin moneda en la factura → la base
      asignacion(c2, USD, '10', '10'),
    ]);

    const r = await service.getResumenCobradores('emp-1');

    expect(r).toEqual([
      {
        id: 'c-1',
        nombre: 'Beto',
        apellido: 'Ruiz',
        codigo: 'C1',
        facturas_asignadas: 3,
        montos: [
          { moneda: PYG, monto_total_pendiente: 105000 },
          { moneda: USD, monto_total_pendiente: 30 },
        ],
      },
      { id: 'c-2', nombre: 'Caro', apellido: null, codigo: 'C2', facturas_asignadas: 1, montos: [{ moneda: USD, monto_total_pendiente: 10 }] },
    ]);
    expect((r[0] as any).monto_total_pendiente).toBeUndefined();
  });
});
