import { ForbiddenException } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { FacturasService } from './facturas.service';

/**
 * El POS retail pide el PIN de un supervisor para anular, pero el servidor
 * recibía `token_autorizacion` y no lo miraba. Ahora: anular una venta cobrada
 * en caja exige la autorización (salvo que anule un supervisor), se verifica
 * (operación «anulacion», esa factura) y se consume antes de tocar nada.
 */
const FACTURA = {
  id: 'fac-1',
  estado: 'Aprobado',
  estado_sifen: 'Aprobado',
  estado_evento: null,
  dest: '001',
  dpunexp: '001',
  dnumdoc: '0000001',
  factura_forma_pagos: [{ sesion_caja_id: 'ses-1' }],
  factura_det: [],
  factura_subtotales: [],
};

function crear(opts: { privilegios?: string[]; supervisor?: boolean; factura?: Record<string, unknown>; consumo?: number } = {}) {
  const service: any = Object.create(FacturasService.prototype);
  const privilegios = new Set(opts.privilegios ?? ['VEN_POS_VENTA_ANULAR']);
  if (opts.supervisor) privilegios.add('VEN_SUP_PIN_AUTORIZAR');
  service.prisma = {
    factura_cab: { findFirst: jest.fn().mockResolvedValue({ ...FACTURA, ...opts.factura }) },
    usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false }) },
    perfiles_privilegios: {
      findFirst: jest.fn(({ where }: any) =>
        Promise.resolve(where.privilegios.codigo.in.some((c: string) => privilegios.has(c)) ? { id: 'pp' } : null),
      ),
    },
    autorizaciones_caja: {
      findFirst: jest.fn().mockResolvedValue(null),
      updateMany: jest.fn().mockResolvedValue({ count: opts.consumo ?? 1 }),
    },
  };
  // Empresa con SIFEN y factura aprobada: el PIN se consume antes del evento (sin SIFEN se consume dentro de la transacción,
  // ver anular-factura-periodo.spec). Corta el flujo en el evento: lo que sigue no es de esta prueba.
  service.middlewareSifenService = {
    empresaUsaSifen: jest.fn().mockResolvedValue(true),
    enviarEvento: jest.fn().mockRejectedValue(new Error('SIGUE_EL_FLUJO')),
  };
  service.logger = { error: jest.fn(), log: jest.fn(), warn: jest.fn() };
  service.contabilidadIntegracion = { tieneModuloContabilidad: jest.fn().mockResolvedValue(false) };
  return service;
}

const token = (payload: Record<string, unknown>) =>
  jest.spyOn(JwtService.prototype, 'verifyAsync').mockResolvedValue({
    tipo: 'autorizacion_caja',
    empresa_id: 'emp-1',
    sub: 'sup-1',
    operacion: 'anulacion',
    autorizacion_id: 'aut-1',
    contexto: { factura_id: 'fac-1' },
    ...payload,
  } as never);

const anular = (service: any, token_autorizacion?: string) =>
  service.anularFactura('fac-1', 'emp-1', { motivo: 'Error de carga', token_autorizacion, user_id: 'caj-1' });

afterEach(() => jest.restoreAllMocks());

describe('Anular factura: autorización de supervisor', () => {
  it('venta de caja sin autorización: 403 con código para que la pantalla pida el PIN', async () => {
    const service = crear();
    await expect(anular(service)).rejects.toMatchObject({
      response: expect.objectContaining({ codigo: 'ANULACION_REQUIERE_AUTORIZACION' }),
    });
    expect(service.middlewareSifenService.empresaUsaSifen).not.toHaveBeenCalled();
  });

  it('con el PIN para esta factura: verifica, consume y sigue', async () => {
    token({});
    const service = crear();
    await expect(anular(service, 'tok')).rejects.toThrow('SIGUE_EL_FLUJO');
    expect(service.prisma.autorizaciones_caja.updateMany).toHaveBeenCalledWith({
      where: { id: 'aut-1', empresa_id: 'emp-1', estado: 'aprobada' },
      data: { estado: 'utilizada' },
    });
  });

  it('un token ya usado: 403 «ya se usó» y no sigue', async () => {
    token({});
    const service = crear({ consumo: 0 });
    await expect(anular(service, 'tok')).rejects.toThrow(/Esta autorización ya se usó/);
    expect(service.middlewareSifenService.enviarEvento).not.toHaveBeenCalled();
  });

  it('un PIN de otra operación o para otra factura no sirve', async () => {
    token({ operacion: 'descuento' });
    await expect(anular(crear(), 'tok')).rejects.toThrow(/otra operación/);
    jest.restoreAllMocks();
    token({ contexto: { factura_id: 'fac-2' } });
    await expect(anular(crear(), 'tok')).rejects.toThrow(/otra factura/);
  });

  it('un supervisor anula sin pedirle el PIN a otro', async () => {
    const service = crear({ supervisor: true });
    await expect(anular(service)).rejects.toThrow('SIGUE_EL_FLUJO');
    expect(service.prisma.autorizaciones_caja.updateMany).not.toHaveBeenCalled();
  });

  it('una factura que no se cobró en caja no la exige', async () => {
    const service = crear({ factura: { factura_forma_pagos: [] } });
    await expect(anular(service)).rejects.toThrow('SIGUE_EL_FLUJO');
  });

  it('si llega una autorización aunque no haga falta, igual se verifica (nunca se ignora)', async () => {
    token({ operacion: 'descuento' });
    const service = crear({ factura: { factura_forma_pagos: [] } });
    await expect(anular(service, 'tok')).rejects.toThrow(ForbiddenException);
  });
});
