import { ConflictException } from '@nestjs/common';
import { FacturasService } from './facturas.service';

/**
 * m1 (re-revisión de la ola 5 de Existencias): `PATCH /facturas/:id/anular` sin evento SIFEN marcaba la factura anulada en su
 * transacción y revertía el asiento después. Con el período cerrado la factura quedaba anulada con el asiento vivo y una
 * alerta que se reintentaba sin fin, mientras que «Eventos › Cancelación» (la cancelación local) la rechazaba. Ahora la regla es
 * la misma: el reclamo es condicional (409 a la segunda) y el asiento se revierte en la misma transacción; período cerrado → no
 * se anula nada. Con SIFEN no cambia (SIFEN ya canceló: lo que no se revierte queda en la alerta, cuyo mensaje dice que se reabra
 * el período).
 */
describe('FacturasService.anularFactura — asiento en la transacción de la anulación', () => {
  const crear = (o: { sifen?: boolean; estadoSifen?: string; contabilidad?: boolean; gana?: boolean; aplicaciones?: any[] } = {}) => {
    const service: any = Object.create(FacturasService.prototype);
    const tx = {
      factura_cab: { updateMany: jest.fn().mockResolvedValue({ count: o.gana === false ? 0 : 1 }), update: jest.fn() },
      nota_remision_det_aplicacion: { findMany: jest.fn().mockResolvedValue(o.aplicaciones ?? []), deleteMany: jest.fn() },
      nota_remision_factura: { deleteMany: jest.fn() },
      $executeRaw: jest.fn().mockResolvedValue(1),
      autorizaciones_caja: { updateMany: jest.fn().mockResolvedValue({ count: 1 }) },
    };
    service.prisma = {
      factura_cab: {
        findFirst: jest.fn().mockResolvedValue({
          id: 'fac-1', estado: 'Aprobado', estado_sifen: o.estadoSifen ?? 'Aprobado', estado_evento: null,
          dest: '001', dpunexp: '001', dnumdoc: '0000009', factura_forma_pagos: [], factura_det: [], factura_subtotales: [],
        }),
      },
      $transaction: jest.fn(async (fn: any) => fn(tx)),
      autorizaciones_caja: { updateMany: jest.fn().mockResolvedValue({ count: 1 }) },
    };
    service.logger = { log: jest.fn(), error: jest.fn(), warn: jest.fn() };
    service.auditService = { log: jest.fn().mockResolvedValue(undefined) };
    service.contabilidadIntegracion = {
      tieneModuloContabilidad: jest.fn().mockResolvedValue(o.contabilidad !== false),
      revertirDocumento: jest.fn().mockResolvedValue(undefined),
    };
    service.middlewareSifenService = {
      empresaUsaSifen: jest.fn().mockResolvedValue(!!o.sifen),
      enviarEvento: jest.fn().mockResolvedValue({ success: true, message: 'ok' }),
      revertirFacturaAnulada: jest.fn().mockResolvedValue({ pendientes: [] }),
    };
    return { service, tx };
  };
  const anular = (service: any) => service.anularFactura('fac-1', 'emp-1', { motivo: 'ZZ motivo', user_id: 'usr-1' });

  it('sin SIFEN: reclama la factura de la empresa no anulada y revierte el asiento en la misma transacción', async () => {
    const { service, tx } = crear();
    await anular(service);
    expect(tx.factura_cab.updateMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'fac-1', empresa_id: 'emp-1', estado: { not: 'Anulado' } } }),
    );
    expect(service.contabilidadIntegracion.revertirDocumento).toHaveBeenCalledWith('factura_cab', 'fac-1', 'usr-1', tx);
    expect(service.middlewareSifenService.revertirFacturaAnulada).toHaveBeenCalledWith(
      'fac-1', 'emp-1', expect.objectContaining({ revertirContabilidad: false }),
    );
  });

  it('período cerrado: el error sube y no se anula nada ni se revierte lo demás (igual que la cancelación local)', async () => {
    const { service } = crear();
    service.contabilidadIntegracion.revertirDocumento.mockRejectedValue(new Error('No se puede revertir: el período 10/2026 del asiento está CERRADO.'));
    await expect(anular(service)).rejects.toThrow(/período/);
    expect(service.middlewareSifenService.revertirFacturaAnulada).not.toHaveBeenCalled();
    expect(service.auditService.log).not.toHaveBeenCalled();
  });

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

  it('sin el módulo CONTABILIDAD no toca asientos', async () => {
    const { service } = crear({ contabilidad: false });
    await anular(service);
    expect(service.contabilidadIntegracion.revertirDocumento).not.toHaveBeenCalled();
  });

  it('con SIFEN (cancelación aprobada): no cambia, el asiento lo revierte la reversión posterior', async () => {
    const { service, tx } = crear({ sifen: true });
    await anular(service);
    expect(tx.factura_cab.updateMany).not.toHaveBeenCalled();
    expect(service.contabilidadIntegracion.revertirDocumento).not.toHaveBeenCalled();
    expect(service.middlewareSifenService.revertirFacturaAnulada).toHaveBeenCalledWith(
      'fac-1', 'emp-1', expect.objectContaining({ revertirContabilidad: false }),
    );
  });

  // m-A (re-revisión de la ola 6): el PIN del supervisor se gastaba fuera de la transacción, antes del rechazo por período
  // cerrado o por otra anulación que se adelantó; el cajero tenía que pedir otro PIN por una anulación que no ocurrió.
  describe('m-A: la autorización del supervisor', () => {
    const conPin = (service: any) => {
      jest.spyOn(require('src/autorizaciones-caja/token-autorizacion'), 'exigirAutorizacionAnulacionVenta')
        .mockResolvedValue({ autorizacion_id: 'aut-1' });
      return service.anularFactura('fac-1', 'emp-1', { motivo: 'ZZ motivo', user_id: 'usr-1', token_autorizacion: 'tok' });
    };
    afterEach(() => jest.restoreAllMocks());

    it('sin SIFEN se consume dentro de la transacción, después de ganar el reclamo', async () => {
      const { service, tx } = crear();
      await conPin(service);
      expect(service.prisma.autorizaciones_caja.updateMany).not.toHaveBeenCalled();
      expect(tx.autorizaciones_caja.updateMany).toHaveBeenCalledWith({
        where: { id: 'aut-1', empresa_id: 'emp-1', estado: 'aprobada' }, data: { estado: 'utilizada' },
      });
      expect(tx.factura_cab.updateMany.mock.invocationCallOrder[0]).toBeLessThan(tx.autorizaciones_caja.updateMany.mock.invocationCallOrder[0]);
    });

    it('sin SIFEN y con el período cerrado: el PIN no se gasta fuera de la transacción que se deshace', async () => {
      const { service } = crear();
      service.contabilidadIntegracion.revertirDocumento.mockRejectedValue(new Error('el período 10/2026 está CERRADO'));
      await expect(conPin(service)).rejects.toThrow(/CERRADO/);
      expect(service.prisma.autorizaciones_caja.updateMany).not.toHaveBeenCalled();
    });

    it('sin SIFEN y otra anulación se adelantó (409): no se consume', async () => {
      const { service, tx } = crear({ gana: false });
      await expect(conPin(service)).rejects.toMatchObject({ response: expect.objectContaining({ codigo: 'FACTURA_YA_ANULADA' }) });
      expect(service.prisma.autorizaciones_caja.updateMany).not.toHaveBeenCalled();
      expect(tx.autorizaciones_caja.updateMany).not.toHaveBeenCalled();
    });

    it('con SIFEN se consume antes del evento (el evento es irreversible)', async () => {
      const { service, tx } = crear({ sifen: true });
      await conPin(service);
      expect(service.prisma.autorizaciones_caja.updateMany).toHaveBeenCalled();
      expect(tx.autorizaciones_caja.updateMany).not.toHaveBeenCalled();
      expect(service.prisma.autorizaciones_caja.updateMany.mock.invocationCallOrder[0])
        .toBeLessThan(service.middlewareSifenService.enviarEvento.mock.invocationCallOrder[0]);
    });
  });

  // m-B: la anulación tomaba los renglones de remisión en el orden de las aplicaciones; la creación los toma en orden de id.
  it('m-B: devuelve el saldo de los renglones de remisión en orden de id (el mismo de la creación)', async () => {
    const { service, tx } = crear({
      aplicaciones: [{ id: 'ap-1', nota_remision_det_id: 'det-a', cantidad_aplicada: 1 }],
    });
    await anular(service);
    expect(tx.nota_remision_det_aplicacion.findMany).toHaveBeenCalledWith(
      expect.objectContaining({ orderBy: { nota_remision_det_id: 'asc' } }),
    );
  });
});
