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

/**
 * Cancelar una NC de venta en una empresa sin SIFEN (cancelación local).
 *
 * (a) No revertía el asiento: la NC 001-001-0000719 de DOBA quedó anulada con su asiento CONFIRMADO. Ahora el asiento se revierte
 *     con el mismo mecanismo que anular una factura (`revertirDocumento`), solo si la empresa tiene CONTABILIDAD, en la misma
 *     transacción que marca la NC cancelada: si el período está cerrado, la NC no queda cancelada a medias.
 * (c) Dos cancelaciones a la vez (o un reintento) pasaban las dos el control de estado y devolvían el stock dos veces. Ahora la
 *     cancelación se reclama con un UPDATE condicional (solo una lo gana) y la segunda recibe 409 NC_YA_CANCELADA sin tocar nada.
 * I1: si devolver la aplicación o el stock falla, la NC queda cancelada pero la respuesta lo avisa y queda una alerta para reintentar.
 */
describe('MiddlewareSifenService — cancelación local de una NC de venta', () => {
  const crear = (opciones: { gana?: boolean; contabilidad?: boolean; stockFalla?: Error } = {}) => {
    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 = {
      nota_credito_cab: { updateMany: jest.fn().mockResolvedValue({ count: opciones.gana === false ? 0 : 1 }) },
    };
    service.prisma = {
      nota_credito_cab: {
        findFirst: jest.fn().mockResolvedValue({ id: 'nc-1', estado_sifen: 'Aprobado', estado_evento: null, dest: '001', dpunexp: '001', dnumdoc: '0000719' }),
        findUnique: jest.fn().mockResolvedValue({ dest: '001', dpunexp: '001', dnumdoc: '0000719' }),
        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.alertasEmpresa = { registrar: jest.fn().mockResolvedValue({ id: 'al-1', creada: true }), resolver: jest.fn().mockResolvedValue(true) };
    service.revertirAplicacionNC = jest.fn().mockResolvedValue(undefined);
    service.revertirStockNC = opciones.stockFalla ? jest.fn().mockRejectedValue(opciones.stockFalla) : jest.fn().mockResolvedValue(undefined);
    return { service, tx };
  };
  const cancelar = (service: any) => service.enviarEvento('emp-1', 'nota_credito', 'cancelacion', 'nc-1', 'ZZ motivo', undefined, 'usr-1');

  it('(a) revierte el asiento de la NC con el usuario, en la misma transacción que la marca cancelada', async () => {
    const { service, tx } = crear();
    const r = await cancelar(service);
    expect(r.success).toBe(true);
    expect(service.contabilidadIntegracion.revertirDocumento).toHaveBeenCalledWith('nota_credito_cab', 'nc-1', 'usr-1', tx);
    expect(tx.nota_credito_cab.updateMany.mock.invocationCallOrder[0]).toBeLessThan(
      service.contabilidadIntegracion.revertirDocumento.mock.invocationCallOrder[0],
    );
    expect(service.revertirAplicacionNC).toHaveBeenCalledWith('nc-1');
    expect(service.revertirStockNC).toHaveBeenCalledWith('nc-1', 'emp-1', undefined);
  });

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

  it('(a) si el asiento no se puede revertir (período cerrado), la NC no queda cancelada: el error sube y no 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.revertirAplicacionNC).not.toHaveBeenCalled();
    expect(service.revertirStockNC).not.toHaveBeenCalled();
  });

  it('(c) reclama la cancelación con un UPDATE condicional sobre la NC aprobada de la empresa', async () => {
    const { service, tx } = crear();
    await cancelar(service);
    expect(tx.nota_credito_cab.updateMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'nc-1', empresa_id: 'emp-1', estado_sifen: 'Aprobado' } }),
    );
    expect(service.prisma.nota_credito_cab.update).not.toHaveBeenCalled();
  });

  it('(c) la segunda cancelación (otra a la vez o un reintento) → 409 NC_YA_CANCELADA sin revertir nada', async () => {
    const { service } = crear({ gana: false });
    const error = await cancelar(service).catch((e: unknown) => e);
    expect(error).toBeInstanceOf(ConflictException);
    expect((error as ConflictException).getResponse()).toMatchObject({ codigo: 'NC_YA_CANCELADA' });
    expect(service.contabilidadIntegracion.revertirDocumento).not.toHaveBeenCalled();
    expect(service.revertirAplicacionNC).not.toHaveBeenCalled();
    expect(service.revertirStockNC).not.toHaveBeenCalled();
  });

  it('I1: si devolver el stock falla, la NC queda cancelada, la respuesta lo avisa y queda una alerta para reintentar', async () => {
    const { service } = crear({ stockFalla: new Error('Transaction already closed: timeout') });
    const r = await cancelar(service);
    expect(r.success).toBe(true);
    expect(r.advertencias).toEqual([expect.objectContaining({ paso: 'stock' })]);
    expect(r.message).toMatch(/stock/);
    expect(service.alertasEmpresa.registrar).toHaveBeenCalledWith(
      expect.objectContaining({ clave: 'reversion_pendiente:nota_credito:nc-1', entidadId: 'nc-1', criticidad: 'alta' }),
    );
  });
});

/**
 * (c) `revertirStockNC` idempotente: la NC se bloquea (FOR UPDATE) antes que cualquier fila de stock y, si ya tiene su reversión
 * (movimiento ANUL_DEV_VENTA o el «Reversión stock…» viejo), responde 409 NC_STOCK_YA_REVERTIDO sin escribir.
 */
describe('MiddlewareSifenService — revertirStockNC no devuelve dos veces', () => {
  const crear = (yaRevertida: number) => {
    const service = Object.create(MiddlewareSifenService.prototype) as any;
    service.logger = { log: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() };
    service.lotesService = { bloquearStockDe: jest.fn().mockResolvedValue(undefined) };
    service.prisma = {
      $transaction: jest.fn(async (fn: any) => fn(service.prisma)),
      $queryRaw: jest.fn().mockResolvedValue([{ id: 'nc-1' }]),
      nota_credito_cab: { findUnique: jest.fn().mockResolvedValue({ dest: '001', dpunexp: '001', dnumdoc: '0000009', factura_cab_id: null }) },
      nota_credito_det: {
        findMany: jest.fn().mockResolvedValue([
          { producto_id: 'p-b', deposito_id: 'dep-1', dcantproser: 1, devuelve_mercaderia: true, productos: { maneja_inventario: true } },
        ]),
      },
      depositos: { findFirst: jest.fn().mockResolvedValue({ id: 'dep-1' }) },
      tipo_movimiento_inventario: { findUnique: jest.fn().mockResolvedValue({ id: 'tipo-x' }) },
      movimientos_inventario: { findMany: jest.fn().mockResolvedValue([]), count: jest.fn().mockResolvedValue(yaRevertida), create: jest.fn() },
      stock_lote: { findUnique: jest.fn(), update: jest.fn() },
      stock_deposito: { upsert: jest.fn() },
    };
    return service;
  };

  it('bloquea la NC antes que el stock', async () => {
    const service = crear(0);
    await service.revertirStockNC('nc-1', 'emp-1');
    const sql = (service.prisma.$queryRaw.mock.calls[0][0] as string[]).join('?');
    expect(sql).toMatch(/FROM nota_credito_cab[\s\S]*FOR UPDATE/);
    expect(service.prisma.$queryRaw.mock.invocationCallOrder[0]).toBeLessThan(service.lotesService.bloquearStockDe.mock.invocationCallOrder[0]);
    expect(service.prisma.stock_deposito.upsert).toHaveBeenCalledTimes(1);
  });

  it('ya revertida → 409 NC_STOCK_YA_REVERTIDO y no escribe stock ni movimientos', async () => {
    const service = crear(1);
    const error = await service.revertirStockNC('nc-1', 'emp-1').catch((e: unknown) => e);
    expect(error).toBeInstanceOf(ConflictException);
    expect((error as ConflictException).getResponse()).toMatchObject({ codigo: 'NC_STOCK_YA_REVERTIDO' });
    expect(service.prisma.stock_deposito.upsert).not.toHaveBeenCalled();
    expect(service.prisma.movimientos_inventario.create).not.toHaveBeenCalled();
    // La marca cuenta el tipo nuevo y el texto viejo.
    const where = service.prisma.movimientos_inventario.count.mock.calls[0][0].where;
    expect(where).toMatchObject({ documento_origen: 'nota_credito', documento_id: 'nc-1' });
    expect(JSON.stringify(where.OR)).toMatch(/Reversión stock/);
  });
});
