import { ConflictException } from '@nestjs/common';
import { MiddlewareSifenService } from './middleware-sifen.service';

/**
 * Re-revisión de la ola 4 de Existencias.
 * M2: con el período contable cerrado la NC no se cancelaba pero la factura sí (quedaba anulada con el asiento vivo y una alerta que
 *     se reintentaba sin fin). Regla única: la factura se cancela igual que la NC, reclamada con un UPDATE condicional y con el
 *     asiento revertido en la misma transacción; si el período está cerrado, no se cancela nada.
 * M4: si algo falla después de cancelar, la respuesta no dice «Error al cancelar»: dice que quedó cancelada y qué falló.
 */
describe('MiddlewareSifenService — cancelación local de una factura', () => {
  const crear = (opciones: { gana?: boolean; contabilidad?: boolean } = {}) => {
    const service = Object.create(MiddlewareSifenService.prototype) as any;
    service.logger = { log: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() };
    const tx: any = { factura_cab: { updateMany: jest.fn().mockResolvedValue({ count: opciones.gana === false ? 0 : 1 }) } };
    service.prisma = {
      factura_cab: {
        findFirst: jest.fn().mockResolvedValue({ id: 'fac-1', estado_sifen: 'Aprobado', estado_evento: null }),
        update: jest.fn(),
      },
      empresas: { findUnique: jest.fn().mockResolvedValue({ sifen_activo: false }) },
      $transaction: jest.fn(async (fn: any) => fn(tx)),
    };
    service.contabilidadIntegracion = {
      tieneModuloContabilidad: jest.fn().mockResolvedValue(opciones.contabilidad !== false),
      revertirDocumento: jest.fn().mockResolvedValue(undefined),
    };
    service.auditService = { log: jest.fn().mockResolvedValue(undefined) };
    service.revertirFacturaAnulada = jest.fn().mockResolvedValue({ pendientes: [] });
    return { service, tx };
  };
  const cancelar = (service: any) => service.enviarEvento('emp-1', 'factura', 'cancelacion', 'fac-1', 'ZZ motivo', undefined, 'usr-1');

  it('M2: reclama la factura aprobada de la empresa y revierte el asiento en la misma transacción', async () => {
    const { service, tx } = crear();
    const r = await cancelar(service);
    expect(r.success).toBe(true);
    expect(tx.factura_cab.updateMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'fac-1', empresa_id: 'emp-1', estado_sifen: 'Aprobado' } }),
    );
    expect(service.contabilidadIntegracion.revertirDocumento).toHaveBeenCalledWith('factura_cab', 'fac-1', 'usr-1', tx);
    expect(service.revertirFacturaAnulada).toHaveBeenCalled();
  });

  it('M2: período cerrado → el error sube y la factura no queda cancelada ni se revierte nada más', async () => {
    const { service } = crear();
    service.contabilidadIntegracion.revertirDocumento.mockRejectedValue(new Error('período cerrado'));
    await expect(cancelar(service)).rejects.toThrow('período cerrado');
    expect(service.revertirFacturaAnulada).not.toHaveBeenCalled();
    expect(service.prisma.factura_cab.update).not.toHaveBeenCalled();
  });

  it('dos a la vez: la segunda → 409 FACTURA_YA_CANCELADA', async () => {
    const { service } = crear({ gana: false });
    const e = await cancelar(service).catch((x: unknown) => x);
    expect(e).toBeInstanceOf(ConflictException);
    expect((e as ConflictException).getResponse()).toMatchObject({ codigo: 'FACTURA_YA_CANCELADA' });
    expect(service.revertirFacturaAnulada).not.toHaveBeenCalled();
  });

  it('M4: si falla un paso posterior a cancelar, la respuesta dice que quedó cancelada (aviso, no error)', async () => {
    const { service } = crear();
    service.auditService.log.mockRejectedValue(new Error('auditoría caída'));
    const r = await cancelar(service);
    expect(r.success).toBe(true);
    expect(r.message).toMatch(/cancel/i);
    expect(r.message).not.toMatch(/^Error al cancelar/);
    expect(r.advertencias).toEqual(expect.arrayContaining([expect.objectContaining({ error: 'auditoría caída' })]));
  });

  it('m2: si falla la reversión entera, la advertencia dice «reversión» y queda la alerta para el reintento', async () => {
    const { service } = crear();
    service.revertirFacturaAnulada.mockRejectedValue(new Error('conexión perdida'));
    service.anotarReversion = jest.fn().mockResolvedValue(undefined);
    const r = await cancelar(service);
    expect(r.success).toBe(true);
    expect(r.advertencias).toEqual([{ paso: 'reversión', error: 'conexión perdida' }]);
    expect(service.anotarReversion).toHaveBeenCalledWith('factura', 'fac-1', 'emp-1', [{ paso: 'reversión', error: 'conexión perdida' }], 'usr-1');
  });

  it('m2: si además falla anotar la alerta, también se avisa (no queda solo en el log)', async () => {
    const { service } = crear();
    service.revertirFacturaAnulada.mockRejectedValue(new Error('conexión perdida'));
    service.anotarReversion = jest.fn().mockRejectedValue(new Error('alertas caídas'));
    const r = await cancelar(service);
    expect(r.advertencias).toEqual([
      { paso: 'reversión', error: 'conexión perdida' },
      { paso: 'alerta de reversión pendiente', error: 'alertas caídas' },
    ]);
  });

  it('m2: si falla solo la auditoría, la etiqueta es «registro de la cancelación» y no se anota otra alerta', async () => {
    const { service } = crear();
    service.auditService.log.mockRejectedValue(new Error('auditoría caída'));
    service.anotarReversion = jest.fn().mockResolvedValue(undefined);
    const r = await cancelar(service);
    expect(r.advertencias).toEqual([{ paso: 'registro de la cancelación', error: 'auditoría caída' }]);
    expect(service.anotarReversion).not.toHaveBeenCalled();
  });
});
