import { AsignacionFacturasService } from './asignacion-facturas.service';

// Comisiones de vendedores y cobradores: criterio de fecha del documento, estado real
// y moneda de la comisión (spec 2026-10-17-comercial-finanzas, B5 y B6).

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

const vendedor = {
  id: 'vc-1',
  nombre: 'Ana',
  apellido: 'Gómez',
  tipo: 'vendedor',
  comision_porcentaje: '5',
  comision_venta: '5',
  comision_cobranza: null,
  comision_fija: null,
};

/** Comisión con la forma que devuelve el include del service. */
const comision = (over: Record<string, any> = {}) => ({
  id: 'c-' + Math.random().toString(36).slice(2, 8),
  empresa_id: 'emp-1',
  vendedor_cobrador_id: 'vc-1',
  factura_id: 'f-1',
  recibo_id: null,
  tipo: 'venta',
  monto_base: '1000',
  monto_comision: '50',
  estado: 'pendiente',
  liquidacion_id: null,
  created_at: new Date('2026-12-15T10:00:00Z'),
  factura_cab: { moneda_id: PYG.id, moneda: PYG, dfeemide: new Date('2026-10-10T09:00:00Z') },
  recibos_cobro: null,
  vendedor_cobrador: vendedor,
  ...over,
});

const crearService = (comisiones: any[] = [], recibos: any[] = []) => {
  const prisma: any = {
    comisiones: { findMany: jest.fn().mockResolvedValue(comisiones) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda: PYG }) },
    moneda: {
      findUnique: jest
        .fn()
        .mockImplementation(({ where }: any) => Promise.resolve([PYG, USD].find((m) => m.id === where.id) ?? null)),
      findFirst: jest.fn().mockResolvedValue(PYG),
    },
    supervisor_vendedores_cobradores: { findMany: jest.fn().mockResolvedValue([]) },
    recibos_cobro: { findMany: jest.fn().mockResolvedValue(recibos) },
  };
  return { service: new AsignacionFacturasService(prisma, {} as any), prisma };
};

/** Busca en el where (a cualquier profundidad) el rango {gte,lte} de un campo. */
const rangosDe = (obj: any, campo: string, acc: any[] = []): any[] => {
  if (!obj || typeof obj !== 'object') return acc;
  for (const [k, v] of Object.entries(obj)) {
    if (k === campo) acc.push(v);
    else rangosDe(v, campo, acc);
  }
  return acc;
};
const contiene = (r: { gte?: Date; lte?: Date }, d: Date) =>
  (!r.gte || r.gte.getTime() <= d.getTime()) && (!r.lte || d.getTime() <= r.lte.getTime());

describe('AsignacionFacturasService - comisiones por fecha del documento y moneda', () => {
  it('resumen: una venta del 31/10 23:30 -03 cae en octubre', async () => {
    const { service, prisma } = crearService([]);
    await service.getResumenComisiones('emp-1', {
      fecha_desde: '2026-10-01',
      fecha_hasta: '2026-10-31',
      moneda_id: PYG.id,
    });

    const where = prisma.comisiones.findMany.mock.calls[0][0].where;
    expect(rangosDe(where, 'created_at')).toHaveLength(0);

    // factura_cab.dfeemide es `timestamp` sin zona con los dígitos de Asunción:
    // el 31/10 23:30 local se lee como 2026-10-31T23:30Z.
    const [rangoFactura] = rangosDe(where, 'dfeemide');
    expect(rangoFactura).toBeDefined();
    expect(contiene(rangoFactura, new Date('2026-10-31T23:30:00Z'))).toBe(true);
    expect(contiene(rangoFactura, new Date('2026-10-01T00:00:00Z'))).toBe(true);
    expect(contiene(rangoFactura, new Date('2026-11-01T00:30:00Z'))).toBe(false);
    expect(contiene(rangoFactura, new Date('2026-09-30T23:30:00Z'))).toBe(false);

    // recibos_cobro.fecha_emision es `timestamptz`: el 31/10 23:30 -03 es 2026-11-01T02:30Z.
    const [rangoRecibo] = rangosDe(where, 'fecha_emision');
    expect(rangoRecibo).toBeDefined();
    expect(contiene(rangoRecibo, new Date('2026-11-01T02:30:00Z'))).toBe(true);
    expect(contiene(rangoRecibo, new Date('2026-11-01T03:30:00Z'))).toBe(false);
    expect(contiene(rangoRecibo, new Date('2026-10-01T02:30:00Z'))).toBe(false);
  });

  it('resumen: estado parcial con una pendiente y una liquidada', async () => {
    const { service } = crearService([
      comision({ monto_comision: '100', estado: 'pendiente' }),
      comision({ monto_comision: '50', estado: 'liquidada', liquidacion_id: 'l-1' }),
    ]);
    const filas = await service.getResumenComisiones('emp-1', { fecha_desde: '2026-10-01', fecha_hasta: '2026-10-31' });

    expect(filas).toHaveLength(1);
    expect(filas[0]).toMatchObject({
      id: 'vc-1',
      comision_pendiente: 100,
      comision_liquidada: 50,
      comision_generada: 150,
      estado: 'parcial',
      moneda: PYG,
    });
  });

  it('resumen: estado pendiente o liquidada según lo que queda', async () => {
    const { service } = crearService([
      comision({ vendedor_cobrador_id: 'vc-1', monto_comision: '100', estado: 'pendiente' }),
      comision({
        vendedor_cobrador_id: 'vc-2',
        vendedor_cobrador: { ...vendedor, id: 'vc-2' },
        monto_comision: '70',
        estado: 'liquidada',
      }),
    ]);
    const filas = await service.getResumenComisiones('emp-1', {});
    expect(filas.find((f: any) => f.id === 'vc-1')?.estado).toBe('pendiente');
    expect(filas.find((f: any) => f.id === 'vc-2')?.estado).toBe('liquidada');
  });

  it('resumen: el filtro de moneda incluye las comisiones de recibo', async () => {
    const { service } = crearService([
      comision({
        monto_base: '300',
        monto_comision: '15',
        factura_cab: { moneda_id: USD.id, moneda: USD, dfeemide: new Date('2026-10-05T10:00:00Z') },
      }),
      comision({
        tipo: 'cobranza',
        factura_id: null,
        factura_cab: null,
        recibo_id: 'r-1',
        monto_base: '200',
        monto_comision: '4',
        recibos_cobro: { moneda_id: USD.id, moneda: USD, fecha_emision: new Date('2026-10-06T13:00:00Z') },
      }),
      comision({ monto_base: '999999', monto_comision: '999' }), // PYG: queda afuera
    ]);
    const filas = await service.getResumenComisiones('emp-1', { moneda_id: USD.id });

    expect(filas).toHaveLength(1);
    expect(filas[0]).toMatchObject({ ventas: 300, cobranzas: 200, comision_generada: 19, moneda: USD });
  });

  it('resumen: sin moneda_id usa la moneda base y no mezcla', async () => {
    const { service } = crearService([
      comision({ monto_comision: '10' }),
      comision({
        monto_comision: '7',
        factura_cab: { moneda_id: USD.id, moneda: USD, dfeemide: new Date('2026-10-05T10:00:00Z') },
      }),
    ]);
    const filas = await service.getResumenComisiones('emp-1', {});
    expect(filas).toHaveLength(1);
    expect(filas[0]).toMatchObject({ comision_generada: 10, moneda: PYG });
  });

  it('resumen: estado=liquidada filtra en la consulta y suma solo las liquidadas', async () => {
    // La base ya devuelve solo las liquidadas (el filtro va en el where).
    const { service, prisma } = crearService([comision({ monto_comision: '50', estado: 'liquidada' })]);
    const filas = await service.getResumenComisiones('emp-1', { estado: 'liquidada' });

    expect(JSON.stringify(prisma.comisiones.findMany.mock.calls[0][0].where)).toContain('{"estado":"liquidada"}');
    expect(filas[0]).toMatchObject({ comision_pendiente: 0, comision_liquidada: 50, estado: 'liquidada' });
  });

  it('detalle: filtra por fecha del documento, no por created_at', async () => {
    const { service, prisma } = crearService([
      comision({ factura_cab: { moneda_id: PYG.id, moneda: PYG, dfeemide: new Date('2026-10-31T23:30:00Z') } }),
      comision({
        tipo: 'cobranza',
        factura_id: null,
        factura_cab: null,
        recibo_id: 'r-1',
        recibos_cobro: { moneda_id: null, moneda: null, fecha_emision: new Date('2026-11-01T02:30:00Z') },
      }),
    ]);
    const filas = await service.getComisionesDetalle('emp-1', 'vc-1', {
      fecha_desde: '2026-10-01',
      fecha_hasta: '2026-10-31',
    });

    const where = prisma.comisiones.findMany.mock.calls[0][0].where;
    expect(rangosDe(where, 'created_at')).toHaveLength(0);
    expect(rangosDe(where, 'dfeemide')).toHaveLength(1);
    expect(rangosDe(where, 'fecha_emision')).toHaveLength(1);

    expect(filas).toHaveLength(2);
    // fecha_documento: ISO con los dígitos de Asunción (31/10 en los dos casos).
    for (const f of filas as any[]) {
      expect(f.fecha_documento.slice(0, 10)).toBe('2026-10-31');
      expect(f.moneda).toEqual(PYG); // el recibo sin moneda cae en la base
    }
  });

  describe('RECIBO_MULTI (recibo multi-factura: sin factura_id ni recibo_id, el recibo va en observaciones)', () => {
    const RECIBO_ID = '7b0f3c2e-1a2b-4c3d-9e8f-0123456789ab';
    const multi = (over: Record<string, any> = {}) =>
      comision({
        tipo: 'cobranza',
        factura_id: null,
        recibo_id: null,
        factura_cab: null,
        recibos_cobro: null,
        observaciones: `RECIBO_MULTI:${RECIBO_ID}`,
        monto_base: '200',
        monto_comision: '4',
        created_at: new Date('2026-12-15T12:00:00Z'),
        ...over,
      });
    const recibo = {
      id: RECIBO_ID,
      numero_recibo: 'R-001',
      fecha_emision: new Date('2026-11-01T02:30:00Z'), // 31/10 23:30 -03
      estado: 'emitido',
      moneda_id: USD.id,
      moneda: USD,
      clientes: null,
    };

    it('resumen y detalle toman la fecha y la moneda de su recibo', async () => {
      const { service, prisma } = crearService([multi()], [recibo]);
      const filas = await service.getResumenComisiones('emp-1', {
        fecha_desde: '2026-10-01',
        fecha_hasta: '2026-10-31',
        moneda_id: USD.id,
      });

      expect(JSON.stringify(prisma.comisiones.findMany.mock.calls[0][0].where)).toContain(
        '"startsWith":"RECIBO_MULTI:"',
      );
      expect(prisma.recibos_cobro.findMany.mock.calls[0][0].where).toEqual({ id: { in: [RECIBO_ID] } });
      expect(filas).toHaveLength(1);
      expect(filas[0]).toMatchObject({ cobranzas: 200, comision_generada: 4, moneda: USD });

      const detalle: any[] = await service.getComisionesDetalle('emp-1', 'vc-1', {
        fecha_desde: '2026-10-01',
        fecha_hasta: '2026-10-31',
        moneda_id: USD.id,
      });
      expect(detalle).toHaveLength(1);
      expect(detalle[0].fecha_documento.slice(0, 10)).toBe('2026-10-31');
      expect(detalle[0].moneda).toEqual(USD);
      expect(detalle[0].recibos_cobro.numero_recibo).toBe('R-001');

      // Fuera del período del recibo (noviembre) no entra, aunque created_at sea de diciembre.
      const { service: s2 } = crearService([multi()], [recibo]);
      expect(
        await s2.getResumenComisiones('emp-1', {
          fecha_desde: '2026-11-01',
          fecha_hasta: '2026-11-30',
          moneda_id: USD.id,
        }),
      ).toHaveLength(0);
    });

    it('sin recibo encontrado usa created_at y la moneda base', async () => {
      const sinRecibo = multi({ created_at: new Date('2026-10-15T12:00:00Z') });
      const { service } = crearService([sinRecibo], []);
      const filas = await service.getResumenComisiones('emp-1', {
        fecha_desde: '2026-10-01',
        fecha_hasta: '2026-10-31',
      });
      expect(filas).toHaveLength(1);
      expect(filas[0]).toMatchObject({ cobranzas: 200, moneda: PYG });

      const detalle: any[] = await service.getComisionesDetalle('emp-1', 'vc-1', {
        fecha_desde: '2026-10-01',
        fecha_hasta: '2026-10-31',
      });
      expect(detalle[0].fecha_documento.slice(0, 10)).toBe('2026-10-15');
      expect(detalle[0].moneda).toEqual(PYG);

      const { service: s2 } = crearService([sinRecibo], []);
      expect(
        await s2.getResumenComisiones('emp-1', { fecha_desde: '2026-11-01', fecha_hasta: '2026-11-30' }),
      ).toHaveLength(0);
    });

    it('la de un recibo anulado no cuenta', async () => {
      const { service } = crearService([multi()], [{ ...recibo, estado: 'anulado' }]);
      expect(await service.getResumenComisiones('emp-1', { moneda_id: USD.id })).toHaveLength(0);
    });
  });

  it('moneda_id inexistente → 400', async () => {
    const { service } = crearService([]);
    await expect(service.getResumenComisiones('emp-1', { moneda_id: 'm-no-existe' })).rejects.toThrow(
      'La moneda no existe',
    );
  });
});

describe('generarComisionesFacturasExistentes — motivos estructurados (I7.4)', () => {
  const factura = (n: string, over: Record<string, any> = {}) => ({
    id: `f-${n}`,
    dest: '001',
    dpunexp: '001',
    dnumdoc: n,
    vendedor_id: 'vc-1',
    vendedor,
    factura_subtotales: [{ dtotope: '1000' }],
    ...over,
  });
  const armar = (facturas: any[], existente: any = null, moduloActivo = true) => {
    const prisma: any = {
      factura_cab: { findMany: jest.fn().mockResolvedValue(facturas) },
      comisiones: { findFirst: jest.fn().mockResolvedValue(existente), create: jest.fn().mockResolvedValue({}) },
    };
    const service = new AsignacionFacturasService(prisma, {} as any);
    jest.spyOn(service as any, 'tieneModuloComisiones').mockResolvedValue(moduloActivo);
    return service;
  };

  it('sin el módulo: codigo MODULO_INACTIVO y sin motivos', async () => {
    expect(await armar([], null, false).generarComisionesFacturasExistentes('emp-1')).toMatchObject({
      codigo: 'MODULO_INACTIVO',
      motivos: [],
    });
  });

  it('cada factura salteada trae su codigo (y el estado si ya tiene comisión); detalles conserva el texto', async () => {
    const r = await armar([
      factura('0000001', { vendedor_id: null, vendedor: null }),
      factura('0000002', { vendedor: { ...vendedor, comision_venta: null, comision_porcentaje: null } }),
      factura('0000003', { factura_subtotales: [] }),
    ]).generarComisionesFacturasExistentes('emp-1');
    expect(r.codigo).toBe('OK');
    expect(r.motivos).toEqual([
      { factura: '001-001-0000001', codigo: 'SIN_VENDEDOR' },
      { factura: '001-001-0000002', codigo: 'SIN_PORCENTAJE' },
      { factura: '001-001-0000003', codigo: 'SIN_TOTAL' },
    ]);
    expect(r.detalles[0]).toBe('Factura 001-001-0000001: sin vendedor');
  });

  it('ya tiene comisión: YA_TIENE_COMISION con su estado', async () => {
    const r = await armar([factura('0000004')], { estado: 'liquidada' }).generarComisionesFacturasExistentes('emp-1');
    expect(r.motivos).toEqual([{ factura: '001-001-0000004', codigo: 'YA_TIENE_COMISION', estado: 'liquidada' }]);
  });
});
