/**
 * Recibo anulado y factura de intereses moratorios:
 * - el job de reintento no toma recibos anulados y `emitirFacturaParaRecibo` nunca emite para uno anulado
 *   (sin sumar intento ni pisar el motivo: no es un error de SIFEN);
 * - anular un recibo deja marcadas las filas sin emitir (motivo visible en el drawer) y, si la factura de
 *   intereses ya salió, no la anula sola (es una NC fiscal): la devuelve en `facturas_intereses_por_revertir`
 *   y deja la auditoría para que el contador emita la NC.
 */
import { InteresesMoratoriosService } from './intereses-moratorios.service';
import { CobrosService } from 'src/cobros/cobros.service';
import { MOTIVO_RECIBO_ANULADO, SIN_MOTIVO_ANULACION, claveFacturaIntereses } from './intereses-moratorios.service';

const EMPRESA = 'emp-1';

describe('Job de reintento: recibos anulados', () => {
  function armar(recibos: Array<{ id: string; estado: string }>) {
    const filas = recibos.map((r) => ({ empresa_id: EMPRESA, recibo_cobro_id: r.id }));
    const prisma: any = {
      cob_interes_cobrado: {
        findMany: jest.fn(async ({ take }: any) => filas.slice(0, take)),
        updateMany: jest.fn().mockResolvedValue({ count: 1 }),
      },
      recibos_cobro: {
        findMany: jest.fn(async ({ where }: any) =>
          recibos.filter((r) => where.id.in.includes(r.id) && r.estado !== where.estado.not),
        ),
      },
    };
    return { s: new InteresesMoratoriosService(prisma, {} as any, {} as any, {} as any), prisma };
  }

  it('no devuelve recibos anulados, deja afuera las filas ya marcadas y usa el límite', async () => {
    const { s, prisma } = armar([
      { id: 'r-anulado', estado: 'anulado' },
      { id: 'r-1', estado: 'emitido' },
      { id: 'r-2', estado: 'emitido' },
    ]);
    const res = await s.listarRecibosConEmisionPendiente(5, 2);
    expect(res).toEqual([{ empresa_id: EMPRESA, recibo_cobro_id: 'r-1' }]);
    const where = prisma.cob_interes_cobrado.findMany.mock.calls[0][0].where;
    expect(where.AND).toContainEqual({ error_emision: { not: MOTIVO_RECIBO_ANULADO } });
    expect(prisma.cob_interes_cobrado.findMany.mock.calls[0][0].take).toBe(2);
  });

  it('marca con el motivo las filas de un recibo anulado antes del cambio, para que salgan de la cola', async () => {
    const { s, prisma } = armar([{ id: 'r-anulado', estado: 'anulado' }]);
    expect(await s.listarRecibosConEmisionPendiente(5, 50)).toEqual([]);
    expect(prisma.cob_interes_cobrado.updateMany).toHaveBeenCalledWith({
      where: { recibo_cobro_id: { in: ['r-anulado'] }, factura_cab_id: null, tipo_comprobante: 'FACTURA' },
      data: { error_emision: MOTIVO_RECIBO_ANULADO },
    });
  });
});

describe('emitirFacturaParaRecibo con el recibo anulado', () => {
  it('no emite, no suma intento y no guarda error', async () => {
    const facturas = { create: jest.fn() };
    const prisma: any = {
      cob_interes_cobrado: {
        findMany: jest.fn().mockResolvedValue([{ id: 'ic-1', monto_interes_cobrado: 15000 }]),
        updateMany: jest.fn(),
        update: jest.fn(),
      },
      recibos_cobro: {
        findUnique: jest.fn().mockResolvedValue({
          id: 'r-1',
          cliente_id: 'cli-1',
          empresa_id: EMPRESA,
          numero_recibo: 'R-1',
          estado: 'anulado',
        }),
      },
      cob_config_intereses: { findUnique: jest.fn() },
      factura_cab: { findFirst: jest.fn().mockResolvedValue(null) },
    };
    const s = new InteresesMoratoriosService(prisma, {} as any, facturas as any, {} as any);
    const res = await s.emitirFacturaParaRecibo(EMPRESA, 'r-1', null);
    expect(res).toEqual({ emitidos: 0, saltados: 1, error: MOTIVO_RECIBO_ANULADO });
    expect(facturas.create).not.toHaveBeenCalled();
    expect(prisma.cob_interes_cobrado.updateMany).not.toHaveBeenCalled();
    expect(prisma.cob_interes_cobrado.update).not.toHaveBeenCalled();
    expect(prisma.cob_config_intereses.findUnique).not.toHaveBeenCalled();
  });
});

describe('anular un recibo con factura de intereses', () => {
  function armar(opts: { facturaEstado: string | null; estadoBajoBloqueo?: string; porClave?: boolean }) {
    const tx: any = {
      $queryRaw: jest.fn().mockResolvedValue([{ estado: opts.estadoBajoBloqueo ?? 'emitido' }]),
      recibos_cobro: { update: jest.fn(async ({ data }: any) => ({ id: 'r-1', ...data })) },
      cob_interes_cobrado: { updateMany: jest.fn().mockResolvedValue({ count: 1 }) },
      factura_cuotas: { findUnique: jest.fn() },
    };
    const prisma: any = {
      recibos_cobro: {
        findUnique: jest.fn().mockResolvedValue({
          id: 'r-1',
          empresa_id: EMPRESA,
          cliente_id: 'cli-1',
          numero_recibo: 'R-1',
          estado: 'emitido',
          monto_total: 0,
          mora_total: 0,
          sesion_caja_id: null,
          observacion: null,
          recibo_cobro_detalle: [],
        }),
      },
      cob_interes_cobrado: {
        findMany: jest.fn().mockResolvedValue(opts.facturaEstado === null || opts.porClave ? [] : [{ factura_cab_id: 'fc-1' }]),
      },
      factura_cab: {
        findFirst: jest.fn().mockResolvedValue(opts.porClave ? { id: 'fc-1' } : null),
        findMany: jest.fn(async ({ where }: any) =>
          opts.facturaEstado && where.OR?.some((c: any) => c.estado?.not === 'Anulado') && opts.facturaEstado !== 'Anulado'
            ? [{ id: 'fc-1', dest: '001', dpunexp: '002', dnumdoc: '0000123', estado: opts.facturaEstado, estado_sifen: 'Aprobado', total_factura: 16500 }]
            : [],
        ),
      },
      $transaction: jest.fn(async (fn: any) => fn(tx)),
    };
    const audit = { log: jest.fn().mockResolvedValue(undefined) };
    const interesManual = { revertirDeRecibo: jest.fn().mockResolvedValue(undefined) };
    const asignacion = { cancelarComisionesPorRecibo: jest.fn().mockResolvedValue(undefined) };
    const contab = { revertirDocumento: jest.fn().mockResolvedValue(undefined) };
    const service = new (CobrosService as any)(
      prisma, audit, {}, contab, asignacion, {}, {}, {}, {}, interesManual,
    ) as CobrosService;
    return { service, tx, audit };
  }

  it('marca las filas sin emitir con el motivo y devuelve la factura emitida para revertir', async () => {
    const { service, tx, audit } = armar({ facturaEstado: 'Aprobado' });
    const res: any = await service.anular('r-1', 'error', EMPRESA, 'u-1');

    expect(tx.cob_interes_cobrado.updateMany).toHaveBeenCalledWith({
      where: { empresa_id: EMPRESA, recibo_cobro_id: 'r-1', factura_cab_id: null, tipo_comprobante: 'FACTURA' },
      data: { error_emision: MOTIVO_RECIBO_ANULADO },
    });
    expect(res.estado).toBe('anulado');
    expect(res.facturas_intereses_por_revertir).toEqual([
      expect.objectContaining({ id: 'fc-1', numero: '001-002-0000123' }),
    ]);
    expect(audit.log).toHaveBeenCalledWith(
      expect.objectContaining({ entity_type: 'cob_interes_cobrado', entity_id: 'r-1', action: 'UPDATE' }),
    );
  });

  it('lista también la factura hallada solo por la clave (emitida, vinculación fallida)', async () => {
    const { service } = armar({ facturaEstado: 'Aprobado', porClave: true });
    const res: any = await service.anular('r-1', undefined, EMPRESA, 'u-1');
    expect(res.facturas_intereses_por_revertir).toEqual([expect.objectContaining({ id: 'fc-1' })]);
  });

  it('sin factura emitida (o ya anulada) no hay nada por revertir', async () => {
    const { service } = armar({ facturaEstado: 'Anulado' });
    const res: any = await service.anular('r-1', undefined, EMPRESA, 'u-1');
    expect(res.facturas_intereses_por_revertir).toEqual([]);
  });
});

describe('anular: la decisión se toma bajo el bloqueo del recibo', () => {
  it('si otra anulación ganó el bloqueo, no revierte nada', async () => {
    const tx: any = {
      $queryRaw: jest.fn().mockResolvedValue([{ estado: 'anulado' }]),
      recibos_cobro: { update: jest.fn() },
      cob_interes_cobrado: { updateMany: jest.fn() },
    };
    const prisma: any = {
      recibos_cobro: {
        findUnique: jest.fn().mockResolvedValue({ id: 'r-1', empresa_id: EMPRESA, estado: 'emitido', recibo_cobro_detalle: [] }),
      },
      $transaction: jest.fn(async (fn: any) => fn(tx)),
    };
    const interesManual = { revertirDeRecibo: jest.fn() };
    const service = new (CobrosService as any)(prisma, {}, {}, {}, {}, {}, {}, {}, {}, interesManual) as CobrosService;
    await expect(service.anular('r-1', undefined, EMPRESA, 'u-1')).rejects.toThrow('El recibo ya está anulado');
    expect(interesManual.revertirDeRecibo).not.toHaveBeenCalled();
    expect(tx.recibos_cobro.update).not.toHaveBeenCalled();
  });
});

describe('emitirFacturaParaRecibo: carrera con la anulación', () => {
  /** Recibo vigente al empezar; `estadoAlVincular` es lo que se lee bajo el bloqueo después de emitir. */
  function armar(opts: { estadoAlVincular: string; createFalla?: boolean; vinculoFalla?: boolean; yaEmitida?: boolean; estadoInicial?: string }) {
    const fila = {
      id: 'ic-1', factura_cuota_id: 'cu-1', monto_interes_cobrado: 15000, monto_iva: 1500,
      dias_mora: 30, tasa_aplicada: 0.1, monto_exonerado: 0,
    };
    const tx: any = {
      $queryRaw: jest.fn().mockResolvedValue([{ estado: opts.estadoAlVincular }]),
      cob_interes_cobrado: { update: jest.fn() },
    };
    const prisma: any = {
      cob_interes_cobrado: { findMany: jest.fn().mockResolvedValue([fila]), updateMany: jest.fn().mockResolvedValue({ count: 1 }) },
      recibos_cobro: {
        findUnique: jest.fn(async ({ select }: any) =>
          select.cliente_id
            ? { id: 'r-1', cliente_id: 'cli-1', empresa_id: EMPRESA, numero_recibo: 'R-1', estado: opts.estadoInicial ?? 'emitido' }
            : { estado: opts.estadoAlVincular },
        ),
      },
      factura_cab: { findFirst: jest.fn().mockResolvedValue(opts.yaEmitida ? { id: 'fc-vieja' } : null) },
      cob_config_intereses: {
        findUnique: jest.fn().mockResolvedValue({ tipo_comprobante: 'FACTURA', producto_servicio_id: 'p-1', numeracion_id: 'n-1', iva_porcentaje: 10 }),
      },
      moneda: { findFirst: jest.fn().mockResolvedValue({ id: 'm-1' }) },
      indicador_presencia: { findFirst: jest.fn().mockResolvedValue({ id: 'x' }) },
      tipo_impuesto: { findFirst: jest.fn().mockResolvedValue({ id: 'x' }) },
      tipo_transaccion: { findFirst: jest.fn().mockResolvedValue({ id: 'x' }) },
      condicion_operacion: { findFirst: jest.fn().mockResolvedValue({ id: 'x' }) },
      medio_pago: { findFirst: jest.fn().mockResolvedValue({ id: 'x' }) },
      productos: { findUnique: jest.fn().mockResolvedValue({ id: 'p-1' }) },
      factura_cuotas: { findMany: jest.fn().mockResolvedValue([]) },
      factura_det: { findMany: jest.fn().mockResolvedValue([{ id: 'fd-1' }]) },
      $transaction: opts.vinculoFalla
        ? jest.fn().mockRejectedValue(new Error('Transaction API error: Unable to start a transaction in the given time.'))
        : jest.fn(async (fn: any) => fn(tx)),
    };
    const facturas = {
      create: opts.createFalla
        ? jest.fn().mockRejectedValue(new Error('SIFEN caído'))
        : jest.fn().mockResolvedValue({ data: { id: 'fc-1' } }),
    };
    const audit = { log: jest.fn().mockResolvedValue(undefined) };
    const s = new InteresesMoratoriosService(prisma, {} as any, facturas as any, audit as any);
    return { s, tx, prisma, audit, facturas };
  }

  it('la factura se crea con la clave de idempotencia del recibo', async () => {
    const { s, facturas } = armar({ estadoAlVincular: 'emitido' });
    await s.emitirFacturaParaRecibo(EMPRESA, 'r-1', 'u-1');
    expect(facturas.create.mock.calls[0][0].cabecera.offline_id).toBe(claveFacturaIntereses('r-1'));
  });

  it('falla la vinculación después de SIFEN: se vincula sin bloqueo, limpia el error viejo (salvo el motivo de anulación) y se audita', async () => {
    const { s, prisma, audit } = armar({ estadoAlVincular: 'emitido', vinculoFalla: true });
    const res = await s.emitirFacturaParaRecibo(EMPRESA, 'r-1', 'u-1');
    expect(res).toEqual({ factura_cab_id: 'fc-1', emitidos: 1, saltados: 0 });
    expect(prisma.cob_interes_cobrado.updateMany).toHaveBeenCalledTimes(2);
    // Las filas con un error viejo de SIFEN quedan vinculadas y sin ese error.
    expect(prisma.cob_interes_cobrado.updateMany).toHaveBeenNthCalledWith(1, {
      where: { id: { in: ['ic-1'] }, factura_cab_id: null, ...SIN_MOTIVO_ANULACION },
      data: { factura_cab_id: 'fc-1', emitido_at: expect.any(Date), error_emision: null },
    });
    // Las que tienen el motivo de la anulación lo conservan: solo el vínculo.
    expect(prisma.cob_interes_cobrado.updateMany).toHaveBeenNthCalledWith(2, {
      where: { id: { in: ['ic-1'] }, factura_cab_id: null },
      data: { factura_cab_id: 'fc-1', emitido_at: expect.any(Date) },
    });
    expect(audit.log).toHaveBeenCalledWith(expect.objectContaining({ new_value: { factura_cab_id: 'fc-1' } }));
  });

  it('falla la vinculación con el recibo ya anulado: igual queda vinculada y marcada para NC', async () => {
    const { s } = armar({ estadoAlVincular: 'anulado', vinculoFalla: true });
    const res = await s.emitirFacturaParaRecibo(EMPRESA, 'r-1', 'u-1');
    expect(res).toEqual({ factura_cab_id: 'fc-1', emitidos: 1, saltados: 0, recibo_anulado: true });
  });

  it('reintento con la factura ya emitida (hallada por la clave): no emite otra, vincula la existente', async () => {
    const { s, facturas, tx } = armar({ estadoAlVincular: 'emitido', yaEmitida: true });
    const res = await s.emitirFacturaParaRecibo(EMPRESA, 'r-1', null);
    expect(facturas.create).not.toHaveBeenCalled();
    expect(res).toEqual({ factura_cab_id: 'fc-vieja', emitidos: 1, saltados: 0 });
    expect(tx.cob_interes_cobrado.update).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ factura_cab_id: 'fc-vieja' }) }),
    );
  });

  it('recibo anulado con una factura ya emitida sin vincular: la vincula y la marca para NC, no emite', async () => {
    const { s, facturas } = armar({ estadoInicial: 'anulado', estadoAlVincular: 'anulado', yaEmitida: true });
    const res = await s.emitirFacturaParaRecibo(EMPRESA, 'r-1', null);
    expect(facturas.create).not.toHaveBeenCalled();
    expect(res).toEqual({ factura_cab_id: 'fc-vieja', emitidos: 1, saltados: 0, recibo_anulado: true });
  });

  it('recibo anulado mientras SIFEN emitía: vincula la factura, conserva el motivo y audita la NC', async () => {
    const { s, tx, audit } = armar({ estadoAlVincular: 'anulado' });
    const res = await s.emitirFacturaParaRecibo(EMPRESA, 'r-1', 'u-1');
    expect(res).toEqual({ factura_cab_id: 'fc-1', emitidos: 1, saltados: 0, recibo_anulado: true });
    expect(tx.$queryRaw).toHaveBeenCalledTimes(1);
    expect(tx.cob_interes_cobrado.update).toHaveBeenCalledWith({
      where: { id: 'ic-1' },
      data: expect.objectContaining({ factura_cab_id: 'fc-1', error_emision: MOTIVO_RECIBO_ANULADO }),
    });
    expect(audit.log).toHaveBeenCalledWith(
      expect.objectContaining({ entity_type: 'cob_interes_cobrado', entity_id: 'r-1', new_value: { factura_cab_id: 'fc-1' } }),
    );
  });

  it('recibo vigente: vincula la factura y limpia el error como siempre', async () => {
    const { s, tx, audit } = armar({ estadoAlVincular: 'emitido' });
    const res = await s.emitirFacturaParaRecibo(EMPRESA, 'r-1', 'u-1');
    expect(res).toEqual({ factura_cab_id: 'fc-1', emitidos: 1, saltados: 0 });
    expect(tx.cob_interes_cobrado.update.mock.calls[0][0].data.error_emision).toBeNull();
    expect(audit.log).not.toHaveBeenCalled();
  });

  it('si la emisión falla, el error no pisa el motivo de una anulación que entró en el medio', async () => {
    const { s, prisma } = armar({ estadoAlVincular: 'emitido', createFalla: true });
    await s.emitirFacturaParaRecibo(EMPRESA, 'r-1', 'u-1');
    expect(prisma.cob_interes_cobrado.updateMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: { in: ['ic-1'] }, ...SIN_MOTIVO_ANULACION } }),
    );
  });
});

describe('reintento manual', () => {
  it('si el recibo se anuló antes de tomar el bloqueo, no reinicia ni borra el motivo', async () => {
    const tx: any = {
      $queryRaw: jest.fn().mockResolvedValue([{ estado: 'anulado' }]),
      cob_interes_cobrado: { findMany: jest.fn(), updateMany: jest.fn() },
    };
    const prisma: any = {
      recibos_cobro: { findFirst: jest.fn().mockResolvedValue({ id: 'r-1', numero_recibo: 'R-1', estado: 'emitido' }) },
      $transaction: jest.fn(async (fn: any) => fn(tx)),
    };
    const intereses = { emitirFacturaParaRecibo: jest.fn() };
    const service = new (CobrosService as any)(prisma, {}, {}, {}, {}, intereses, {}, {}, {}, {}) as CobrosService;
    await expect(service.reintentarEmisionIntereses('r-1', EMPRESA, 'u-1')).rejects.toThrow('anulado');
    expect(tx.cob_interes_cobrado.updateMany).not.toHaveBeenCalled();
    expect(intereses.emitirFacturaParaRecibo).not.toHaveBeenCalled();
  });

  it('el reinicio no toca filas con el motivo de anulación', async () => {
    const tx: any = {
      $queryRaw: jest.fn().mockResolvedValue([{ estado: 'emitido' }]),
      cob_interes_cobrado: { findMany: jest.fn().mockResolvedValue([{ id: 'ic-1' }]), updateMany: jest.fn() },
    };
    const prisma: any = {
      recibos_cobro: { findFirst: jest.fn().mockResolvedValue({ id: 'r-1', numero_recibo: 'R-1', estado: 'emitido' }) },
      factura_cab: { findUnique: jest.fn() },
      $transaction: jest.fn(async (fn: any) => fn(tx)),
    };
    const intereses = { emitirFacturaParaRecibo: jest.fn().mockResolvedValue({ emitidos: 0, saltados: 1, error: 'x' }) };
    const audit = { log: jest.fn().mockResolvedValue(undefined) };
    const service = new (CobrosService as any)(prisma, audit, {}, {}, {}, intereses, {}, {}, {}, {}) as CobrosService;
    await service.reintentarEmisionIntereses('r-1', EMPRESA, 'u-1').catch(() => undefined);
    expect(tx.cob_interes_cobrado.updateMany).toHaveBeenCalledWith({
      where: { id: { in: ['ic-1'] }, ...SIN_MOTIVO_ANULACION },
      data: { intento_emision: 0, error_emision: null },
    });
  });
});
