import { BadRequestException } from '@nestjs/common';
import { SupervisoresService } from './supervisores.service';

// Comisiones de supervisor por moneda (spec 2026-10-17-comercial-finanzas, Backend 4): una comisión
// por moneda con movimiento, en transacción, con la fecha y la moneda del documento (Task 3).

const PYG = { id: 'm-pyg', codigo: 'PYG', simbolo: '₲' };
const USD = { id: 'm-usd', codigo: 'USD', simbolo: 'US$' };

const supervisor = {
  id: 'sup-1',
  empresa_id: 'emp-1',
  nombre: 'Sara',
  apellido: 'López',
  codigo: 'S1',
  porcentaje_comision_ventas: '2',
  porcentaje_comision_cobros: '1',
  equipo: [
    { vendedor_cobrador_id: 'vc-1', vendedor_cobrador: { id: 'vc-1', nombre: 'Ana', apellido: 'Gómez', tipo: 'vendedor', codigo: 'V1' } },
    { vendedor_cobrador_id: 'vc-2', vendedor_cobrador: { id: 'vc-2', nombre: 'Beto', apellido: 'Ruiz', tipo: 'cobrador', codigo: 'C1' } },
  ],
};

const venta = (monto: string, moneda = PYG, vc = 'vc-1') => ({
  vendedor_cobrador_id: vc,
  monto_base: monto,
  factura_id: 'f-' + monto,
  recibo_id: null,
  observaciones: null,
  created_at: new Date('2026-12-01T10:00:00Z'),
  factura_cab: { moneda_id: moneda.id, moneda, dfeemide: new Date('2026-10-10T09:00:00Z') },
  recibos_cobro: null,
});

const cobro = (monto: string, moneda = PYG, vc = 'vc-2') => ({
  vendedor_cobrador_id: vc,
  monto_base: monto,
  factura_id: null,
  recibo_id: 'r-' + monto,
  observaciones: null,
  created_at: new Date('2026-12-01T10:00:00Z'),
  factura_cab: null,
  recibos_cobro: { moneda_id: moneda.id, moneda, fecha_emision: new Date('2026-10-15T15:00:00Z') },
});

const comisionSup = (over: Record<string, any> = {}) => ({
  id: 'cs-1',
  supervisor_id: 'sup-1',
  empresa_id: 'emp-1',
  periodo_desde: new Date('2026-10-01T00:00:00Z'),
  periodo_hasta: new Date('2026-10-31T00:00:00Z'),
  total_ventas: '0',
  total_cobros: '0',
  comision_ventas: '0',
  comision_cobros: '0',
  total_comision: '0',
  moneda_id: PYG.id,
  moneda: PYG,
  porcentaje_ventas_aplicado: '1.5',
  porcentaje_cobros_aplicado: '0.5',
  estado: 'pendiente',
  observaciones: 'obs',
  created_at: new Date('2026-11-01T10:00:00Z'),
  updated_at: new Date('2026-11-01T10:00:00Z'),
  ...over,
});

/**
 * Prisma falso. Lo escrito dentro de `$transaction` se confirma solo si el callback termina bien.
 */
const crearService = (
  opts: {
    ventas?: any[];
    cobros?: any[];
    recibos?: any[];
    solapada?: any;
    comision?: any;
    liquidadas?: number;
  } = {},
) => {
  const confirmadas = { comisiones_supervisores: [] as any[], liquidaciones: [] as any[], updates: [] as any[] };
  let recalculada: any = null;
  const hacerTx = (destino: typeof confirmadas) => ({
    $queryRaw: jest.fn().mockResolvedValue([{ id: 'sup-1' }]),
    comisiones_supervisores: {
      findFirst: jest.fn().mockResolvedValue(opts.solapada ?? null),
      create: jest.fn().mockImplementation(({ data }: any) => {
        const fila = { id: `cs-n${destino.comisiones_supervisores.length + 1}`, estado: 'pendiente', ...data };
        fila.moneda = [PYG, USD].find((m) => m.id === data.moneda_id) ?? null;
        destino.comisiones_supervisores.push(fila);
        return Promise.resolve(fila);
      }),
      updateMany: jest.fn().mockImplementation(({ data }: any) => {
        destino.updates.push(data);
        return Promise.resolve({ count: opts.liquidadas ?? 1 });
      }),
      findUnique: jest.fn().mockImplementation(() => Promise.resolve({ ...(opts.comision ?? comisionSup()), estado: 'liquidada' })),
    },
    liquidaciones_comisiones: {
      create: jest.fn().mockImplementation(({ data }: any) => {
        destino.liquidaciones.push(data);
        return Promise.resolve({ id: 'l-1', ...data });
      }),
    },
  });
  const tx = hacerTx({ comisiones_supervisores: [], liquidaciones: [], updates: [] });
  const prisma: any = {
    supervisores: { findFirst: jest.fn().mockResolvedValue(supervisor) },
    supervisor_vendedores_cobradores: { findMany: jest.fn().mockResolvedValue(supervisor.equipo) },
    comisiones: {
      findMany: jest.fn().mockImplementation(({ where }: any) =>
        Promise.resolve(where.tipo === 'venta' ? (opts.ventas ?? []) : (opts.cobros ?? [])),
      ),
    },
    recibos_cobro: { findMany: jest.fn().mockResolvedValue(opts.recibos ?? []) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda: PYG }) },
    moneda: { findFirst: jest.fn().mockResolvedValue(PYG) },
    comisiones_supervisores: {
      findFirst: jest.fn().mockResolvedValue(opts.comision ?? null),
      update: jest.fn().mockImplementation(({ data }: any) => Promise.resolve({ ...(opts.comision ?? {}), ...data })),
      // Recalcular escribe condicionado (I5) y relee la fila.
      updateMany: jest.fn().mockImplementation(({ data }: any) => {
        recalculada = { ...(opts.comision ?? {}), ...data };
        return Promise.resolve({ count: 1 });
      }),
      findUnique: jest.fn().mockImplementation(() => Promise.resolve(recalculada)),
      findMany: jest.fn().mockResolvedValue([]),
      create: jest.fn(),
    },
    liquidaciones_comisiones: { create: jest.fn() },
  };
  prisma.$transaction = jest.fn().mockImplementation(async (cb: any) => {
    const pendientes = { comisiones_supervisores: [] as any[], liquidaciones: [] as any[], updates: [] as any[] };
    const t = hacerTx(pendientes);
    Object.assign(tx, t);
    const r = await cb(t);
    confirmadas.comisiones_supervisores.push(...pendientes.comisiones_supervisores);
    confirmadas.liquidaciones.push(...pendientes.liquidaciones);
    confirmadas.updates.push(...pendientes.updates);
    return r;
  });
  const contabilidad: any = { integrarComisionSupervisor: jest.fn().mockResolvedValue(undefined) };
  const audit: any = { log: jest.fn() };
  return { service: new SupervisoresService(prisma, contabilidad, audit), prisma, tx, confirmadas, contabilidad };
};

const DTO = { periodo_desde: '2026-10-01', periodo_hasta: '2026-10-31' };

describe('SupervisoresService · comisiones por moneda', () => {
  it('generar con ventas PYG y USD crea dos comisiones con su moneda y sus % aplicados', async () => {
    const { service, prisma, confirmadas } = crearService({
      ventas: [venta('1000000'), venta('500000'), venta('200', USD)],
      cobros: [cobro('300000'), cobro('100', USD)],
    });

    const r: any[] = await service.generarComision('emp-1', 'sup-1', DTO);

    // Criterio de Task 3: la fecha del documento, no created_at.
    const whereVentas = prisma.comisiones.findMany.mock.calls.find((c: any) => c[0].where.tipo === 'venta')[0].where;
    expect(JSON.stringify(whereVentas)).toContain('dfeemide');
    expect(JSON.stringify(whereVentas)).not.toContain('created_at');

    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(confirmadas.comisiones_supervisores).toHaveLength(2);
    expect(r).toHaveLength(2);
    const porCodigo = Object.fromEntries(r.map((c) => [c.moneda.codigo, c]));
    expect(porCodigo.PYG).toMatchObject({
      moneda_id: PYG.id,
      total_ventas: 1500000,
      total_cobros: 300000,
      comision_ventas: 30000,
      comision_cobros: 3000,
      total_comision: 33000,
      porcentaje_ventas_aplicado: 2,
      porcentaje_cobros_aplicado: 1,
      periodo_desde: new Date('2026-10-01T00:00:00.000Z'),
      periodo_hasta: new Date('2026-10-31T00:00:00.000Z'),
    });
    expect(porCodigo.USD).toMatchObject({
      moneda_id: USD.id,
      total_ventas: 200,
      total_cobros: 100,
      comision_ventas: 4,
      comision_cobros: 1,
      total_comision: 5,
      porcentaje_ventas_aplicado: 2,
      porcentaje_cobros_aplicado: 1,
    });
  });

  it('generar suma las cobranzas RECIBO_MULTI con la fecha y la moneda de su recibo', async () => {
    const multi = {
      ...cobro('40'),
      recibo_id: null,
      recibos_cobro: undefined,
      observaciones: 'RECIBO_MULTI:11111111-2222-3333-4444-555555555555',
    };
    const { service } = crearService({
      cobros: [multi],
      recibos: [
        { id: '11111111-2222-3333-4444-555555555555', estado: 'emitido', moneda_id: USD.id, moneda: USD, fecha_emision: new Date('2026-10-20T15:00:00Z') },
      ],
    });
    const r: any[] = await service.generarComision('emp-1', 'sup-1', DTO);
    expect(r).toHaveLength(1);
    expect(r[0]).toMatchObject({ moneda_id: USD.id, total_cobros: 40, comision_cobros: 0.4 });
  });

  it('generar que se superpone con una comisión de otra moneda → 400 y no crea nada', async () => {
    const { service, tx, confirmadas } = crearService({
      ventas: [venta('1000')],
      solapada: { id: 'cs-vieja', moneda_id: USD.id },
    });
    await expect(service.generarComision('emp-1', 'sup-1', DTO)).rejects.toThrow(
      new BadRequestException('Ya hay una comisión del supervisor que se superpone con ese período'),
    );
    // Se busca por solapamiento, sin filtrar por moneda.
    const where = tx.comisiones_supervisores.findFirst.mock.calls[0][0].where;
    expect(where).toMatchObject({
      empresa_id: 'emp-1',
      supervisor_id: 'sup-1',
      periodo_desde: { lte: new Date('2026-10-31T00:00:00.000Z') },
      periodo_hasta: { gte: new Date('2026-10-01T00:00:00.000Z') },
    });
    expect(where.moneda_id).toBeUndefined();
    expect(confirmadas.comisiones_supervisores).toHaveLength(0);
  });

  it('generar sin movimiento → 400 y no crea una en 0', async () => {
    const { service, confirmadas } = crearService({ ventas: [], cobros: [] });
    await expect(service.generarComision('emp-1', 'sup-1', DTO)).rejects.toThrow(
      new BadRequestException('El equipo no tuvo ventas ni cobros en el período'),
    );
    expect(confirmadas.comisiones_supervisores).toHaveLength(0);
  });

  it('generar con desde posterior a hasta → 400', async () => {
    const { service } = crearService({ ventas: [venta('1000')] });
    await expect(
      service.generarComision('emp-1', 'sup-1', { periodo_desde: '2026-11-01', periodo_hasta: '2026-10-01' }),
    ).rejects.toThrow(BadRequestException);
  });

  it('preview desglosa por moneda con equipo y totales', async () => {
    const { service } = crearService({
      ventas: [venta('1000'), venta('200', USD)],
      cobros: [cobro('300')],
    });
    const r: any = await service.previewComision('emp-1', 'sup-1', DTO);
    expect(r.supervisor).toMatchObject({ id: 'sup-1', porcentaje_comision_ventas: 2, porcentaje_comision_cobros: 1 });
    expect(r.monedas.map((m: any) => m.moneda.codigo)).toEqual(['PYG', 'USD']);
    const pyg = r.monedas[0];
    expect(pyg.totales).toEqual({ ventas: 1000, cobros: 300, comision_ventas: 20, comision_cobros: 3, total_comision: 23 });
    expect(pyg.equipo).toEqual([
      { vendedor_cobrador: supervisor.equipo[0].vendedor_cobrador, ventas: 1000, cobros: 0 },
      { vendedor_cobrador: supervisor.equipo[1].vendedor_cobrador, ventas: 0, cobros: 300 },
    ]);
    expect(r.monedas[1].totales).toEqual({ ventas: 200, cobros: 0, comision_ventas: 4, comision_cobros: 0, total_comision: 4 });
    expect(r.equipo).toBeUndefined();
  });

  it('recalcular usa el % actual y solo su moneda', async () => {
    const { service, prisma } = crearService({
      comision: comisionSup({ moneda_id: USD.id, moneda: USD }),
      ventas: [venta('1000'), venta('200', USD)],
      cobros: [cobro('300'), cobro('100', USD)],
    });
    const r: any = await service.recalcularComision('emp-1', 'cs-1');
    const data = prisma.comisiones_supervisores.updateMany.mock.calls[0][0].data;
    expect(data).toMatchObject({
      total_ventas: 200,
      total_cobros: 100,
      comision_ventas: 4,
      comision_cobros: 1,
      total_comision: 5,
      porcentaje_ventas_aplicado: 2,
      porcentaje_cobros_aplicado: 1,
    });
    expect(r.advertencias).toEqual([]);
  });

  // I5 de la revisión final: si se liquidó mientras se recalculaba, no se tocan sus totales.
  it('recalcular escribe solo si sigue sin liquidar; si otro pedido la liquidó, 400', async () => {
    const { service, prisma } = crearService({ comision: comisionSup(), ventas: [venta('1000')] });
    prisma.comisiones_supervisores.updateMany.mockResolvedValueOnce({ count: 0 });

    await expect(service.recalcularComision('emp-1', 'cs-1')).rejects.toThrow(
      new BadRequestException('No se puede recalcular una comisión liquidada'),
    );
    expect(prisma.comisiones_supervisores.updateMany.mock.calls[0][0].where).toEqual({
      id: 'cs-1',
      empresa_id: 'emp-1',
      estado: { not: 'liquidada' },
    });
    expect(prisma.comisiones_supervisores.update).not.toHaveBeenCalled();
  });

  // M4: /supervisores/activos no lleva permiso; no expone los porcentajes.
  it('activos no devuelve los porcentajes de comisión', async () => {
    const { service, prisma } = crearService();
    prisma.supervisores.findMany = jest.fn().mockResolvedValue([]);
    await service.findActivos('emp-1');
    expect(prisma.supervisores.findMany.mock.calls[0][0].select).toEqual({ id: true, nombre: true, apellido: true, codigo: true });
  });

  it('recalcular una vieja (sin % aplicados) avisa que deja de sumar las otras monedas', async () => {
    const { service } = crearService({
      comision: comisionSup({ porcentaje_ventas_aplicado: null, porcentaje_cobros_aplicado: null }),
      ventas: [venta('1000'), venta('200', USD)],
    });
    const r: any = await service.recalcularComision('emp-1', 'cs-1');
    expect(r.total_comision).toBe(20);
    expect(r.advertencias).toEqual([
      'Se recalculó solo en PYG: el período también tuvo ventas o cobros en USD, que esta comisión ya no suma',
    ]);
  });

  it('liquidar crea la liquidación con la moneda de la comisión, en transacción', async () => {
    const c = comisionSup({ moneda_id: USD.id, moneda: USD, total_comision: '5' });
    const { service, prisma, confirmadas, contabilidad } = crearService({ comision: c });
    const r: any = await service.liquidarComision('emp-1', 'cs-1');

    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(prisma.liquidaciones_comisiones.create).not.toHaveBeenCalled();
    expect(confirmadas.liquidaciones).toHaveLength(1);
    expect(confirmadas.liquidaciones[0]).toMatchObject({
      tipo: 'supervisor',
      supervisor_id: 'sup-1',
      comision_supervisor_id: 'cs-1',
      moneda_id: USD.id,
      total_comisiones: '5',
      estado: 'pagada',
    });
    expect(confirmadas.updates[0]).toMatchObject({ estado: 'liquidada' });
    expect(contabilidad.integrarComisionSupervisor).toHaveBeenCalledWith('cs-1', 'emp-1');
    expect(r).toMatchObject({ id: 'cs-1', estado: 'liquidada', moneda: USD, advertencias: [] });
  });

  it('liquidar: la falta de cotización vuelve en advertencias y queda liquidada', async () => {
    const c = comisionSup({ moneda_id: USD.id, moneda: USD, total_comision: '5' });
    const { service, confirmadas, contabilidad } = crearService({ comision: c });
    contabilidad.integrarComisionSupervisor.mockResolvedValue({ advertencia: 'Sin asiento: falta la cotización USD del 17/10/2026' });
    const r: any = await service.liquidarComision('emp-1', 'cs-1');
    expect(confirmadas.liquidaciones).toHaveLength(1);
    expect(r).toMatchObject({ estado: 'liquidada', advertencias: ['Sin asiento: falta la cotización USD del 17/10/2026'] });
  });

  it('liquidar dos veces a la vez: la segunda → 400 y no crea otra liquidación', async () => {
    const { service, confirmadas } = crearService({ comision: comisionSup(), liquidadas: 0 });
    await expect(service.liquidarComision('emp-1', 'cs-1')).rejects.toThrow(
      new BadRequestException('La comisión ya está liquidada'),
    );
    expect(confirmadas.liquidaciones).toHaveLength(0);
  });

  it('reporte y detalle traen la moneda y los % aplicados; el equipo es de esa moneda', async () => {
    const { service, prisma } = crearService({
      comision: comisionSup({ moneda_id: null, moneda: null, supervisor }),
      ventas: [venta('1000'), venta('200', USD)],
    });
    prisma.comisiones_supervisores.findMany.mockResolvedValue([comisionSup({ moneda_id: null, moneda: null })]);
    const rep: any[] = await service.getReporteComisiones('emp-1', {});
    expect(rep[0]).toMatchObject({ moneda: PYG, porcentaje_ventas_aplicado: '1.5', porcentaje_cobros_aplicado: '0.5' });

    const det: any = await service.getDetalleComision('emp-1', 'cs-1');
    expect(det.comision).toMatchObject({ moneda: PYG, porcentaje_ventas_aplicado: '1.5' });
    expect(det.equipo[0]).toMatchObject({ ventas: 1000 });
  });
});
