import { ForbiddenException } from '@nestjs/common';
import { TesoreriaService } from './tesoreria.service';

/**
 * El «Fondo Fijo de Caja» de Configuración POS no hacía nada: si el monto de
 * apertura no coincidía, solo se escribía un aviso en el log. Ahora la caja abre
 * con su fondo fijo, y abrir con otro monto lo autoriza un supervisor con su PIN,
 * para ese monto y esa caja. De paso, el token tiene que ser de la operación que
 * se está haciendo: antes un PIN dado para un descuento servía para abrir.
 */
describe('TesoreriaService.abrirCaja — fondo fijo', () => {
  const crear = (config: Record<string, unknown> | null, token?: Record<string, unknown>) => {
    const service = Object.create(TesoreriaService.prototype) as any;
    service.logger = { log: jest.fn(), warn: jest.fn(), error: jest.fn() };
    service.auditService = { log: jest.fn().mockResolvedValue(undefined) };
    service.cajasAccesibles = jest.fn().mockResolvedValue([{ id: 'caja-1' }]);
    service.jwtService = {
      verifyAsync: jest.fn().mockResolvedValue({ tipo: 'autorizacion_caja', empresa_id: 'emp-1', sub: 'sup-1', autorizacion_id: 'aut-1', ...token }),
    };
    service.prisma = {
      cajas: { findFirst: jest.fn().mockResolvedValue({ id: 'caja-1', sucursal_id: 'suc-1' }) },
      sesiones_caja: {
        findFirst: jest.fn().mockResolvedValue(null),
        create: jest.fn(async ({ data }: any) => ({ id: 'ses-1', ...data })),
      },
      pos_config: { findUnique: jest.fn().mockResolvedValue(config) },
      autorizaciones_caja: {
        findFirst: jest.fn().mockResolvedValue(null),
        updateMany: jest.fn().mockResolvedValue({ count: 1 }),
      },
      caja_reversiones_pendientes: { findMany: jest.fn().mockResolvedValue([]) },
    };
    service.prisma.$transaction = jest.fn(async (fn: any) => fn(service.prisma));
    return service;
  };

  const abrir = (service: any, monto: number, token?: string) =>
    service.abrirCaja({ caja_id: 'caja-1', monto_apertura: monto, token_autorizacion: token }, 'emp-1', 'user-1');

  const conPin = (monto: number, caja_id = 'caja-1', operacion = 'apertura_caja') => ({
    operacion,
    contexto: { caja_id, monto_apertura: monto },
  });

  it('con el monto del fondo fijo abre sin pedir PIN', async () => {
    const service = crear({ fondo_fijo: '500000.00' });

    await abrir(service, 500000);

    expect(service.prisma.sesiones_caja.create).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ monto_apertura: 500000, autorizado_apertura_por: null }) }),
    );
  });

  it('con otro monto y sin PIN no abre, y dice cuál es el fondo', async () => {
    const service = crear({ fondo_fijo: '500000.00' });

    await expect(abrir(service, 300000)).rejects.toThrow(/fondo fijo de esta caja es 500\.000/);
    expect(service.prisma.sesiones_caja.create).not.toHaveBeenCalled();
  });

  it('con otro monto y el PIN para ese monto, abre y guarda quién autorizó', async () => {
    const service = crear({ fondo_fijo: 500000 }, conPin(300000));

    await abrir(service, 300000, 'tok');

    expect(service.prisma.sesiones_caja.create).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ monto_apertura: 300000, autorizado_apertura_por: 'sup-1' }) }),
    );
  });

  it('el PIN autorizado para otro monto no sirve', async () => {
    const service = crear({ fondo_fijo: 500000 }, conPin(300000));

    await expect(abrir(service, 900000, 'tok')).rejects.toThrow(/otro monto o para otra caja/);
  });

  it('el PIN autorizado para otra caja no sirve', async () => {
    const service = crear({ fondo_fijo: 500000 }, conPin(300000, 'caja-2'));

    await expect(abrir(service, 300000, 'tok')).rejects.toThrow(ForbiddenException);
  });

  it('una autorización remota toma el monto de la autorización aprobada', async () => {
    const service = crear({ fondo_fijo: 500000 }, { operacion: 'apertura_caja', autorizacion_id: 'aut-1' });
    service.prisma.autorizaciones_caja.findFirst.mockResolvedValue({ contexto: { caja_id: 'caja-1', monto_apertura: 300000 } });

    await abrir(service, 300000, 'tok');

    expect(service.prisma.autorizaciones_caja.findFirst).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'aut-1', empresa_id: 'emp-1' } }),
    );
    expect(service.prisma.sesiones_caja.create).toHaveBeenCalled();
  });

  it('sin fondo fijo abre con cualquier monto', async () => {
    const service = crear({ fondo_fijo: null });

    await abrir(service, 123000);

    expect(service.prisma.sesiones_caja.create).toHaveBeenCalled();
  });

  it('un PIN dado para otra operación (un descuento) no abre la caja', async () => {
    const service = crear({ requiere_autorizacion_apertura: true }, { operacion: 'descuento' });

    await expect(abrir(service, 0, 'tok')).rejects.toThrow(/otra operación/);
  });
});
