import { ForbiddenException } from '@nestjs/common';
import * as bcrypt from 'bcrypt';
import { PRIVILEGIO_PIN_SUPERVISOR } from 'src/seguridad/privilegio-pin-supervisor';
import { UsersService } from './users.service';

/**
 * El PIN de supervisor pedía el privilegio POS_SUPERVISOR, que ya no existía en el
 * catálogo: solo un superadmin podía autorizar. Ahora el permiso es
 * VEN_SUP_PIN_AUTORIZAR (Panel Supervisor), que trae el perfil Supervisor.
 */
describe('UsersService.validarPinSupervisor — permiso para autorizar con PIN', () => {
  let hash: string;
  beforeAll(async () => {
    hash = await bcrypt.hash('4321', 4);
  });

  const conPrivilegio = (codigo: string, active = true) => [
    { perfiles: { perfiles_privilegios: [{ active, privilegios: { codigo } }] } },
  ];

  const crear = (supervisor: Record<string, unknown>) => {
    const service = Object.create(UsersService.prototype) as any;
    service.logger = { log: jest.fn(), warn: jest.fn(), error: jest.fn() };
    service.auditService = { log: jest.fn().mockResolvedValue(undefined) };
    service.jwtService = { signAsync: jest.fn().mockResolvedValue('token-1') };
    service.prisma = {
      usuario: { findFirst: jest.fn().mockResolvedValue({ id: 'sup-1', username: 'ana', pin_supervisor: hash, is_superadmin: false, ...supervisor }) },
      autorizaciones_caja: { create: jest.fn().mockResolvedValue({ id: 'aut-1' }) },
    };
    return service;
  };

  const validar = (service: any) =>
    service.validarPinSupervisor({ usuario_id_or_username: 'ana', pin: '4321', tipo_operacion: 'apertura_caja' }, 'emp-1', 'cajero-1');

  it('con el permiso del Panel Supervisor y el PIN correcto, autoriza', async () => {
    const service = crear({ usuario_perfiles: conPrivilegio(PRIVILEGIO_PIN_SUPERVISOR) });

    await expect(validar(service)).resolves.toBeDefined();
    expect(service.jwtService.signAsync).toHaveBeenCalled();
  });

  it('el token nombra la autorización registrada, para que la operación la marque usada', async () => {
    const service = crear({ usuario_perfiles: conPrivilegio(PRIVILEGIO_PIN_SUPERVISOR) });
    const r = await validar(service);
    expect(service.jwtService.signAsync).toHaveBeenCalledWith(
      expect.objectContaining({ autorizacion_id: 'aut-1', operacion: 'apertura_caja' }),
      expect.anything(),
    );
    expect(r.autorizacion_id).toBe('aut-1');
  });

  it('si no se puede registrar la autorización, no se entrega token (antes solo quedaba un warn)', async () => {
    const service = crear({ usuario_perfiles: conPrivilegio(PRIVILEGIO_PIN_SUPERVISOR) });
    service.prisma.autorizaciones_caja.create.mockRejectedValue(new Error('db caída'));
    await expect(validar(service)).rejects.toThrow('db caída');
    expect(service.jwtService.signAsync).not.toHaveBeenCalled();
  });

  it('sin el permiso no autoriza, y el mensaje dice dónde se asigna', async () => {
    const service = crear({ usuario_perfiles: conPrivilegio('VEN_SUP_PANEL_VER') });

    await expect(validar(service)).rejects.toThrow(ForbiddenException);
    await expect(validar(service)).rejects.toThrow(/Perfiles y Roles/);
  });

  it('el viejo POS_SUPERVISOR ya no alcanza', async () => {
    const service = crear({ usuario_perfiles: conPrivilegio('POS_SUPERVISOR') });

    await expect(validar(service)).rejects.toThrow(ForbiddenException);
  });

  it('un permiso desactivado en el perfil no cuenta', async () => {
    const service = crear({ usuario_perfiles: conPrivilegio(PRIVILEGIO_PIN_SUPERVISOR, false) });

    await expect(validar(service)).rejects.toThrow(ForbiddenException);
  });

  it('busca al supervisor solo dentro de la empresa, y con sus perfiles de esa empresa', async () => {
    const service = crear({ usuario_perfiles: conPrivilegio(PRIVILEGIO_PIN_SUPERVISOR) });

    await validar(service);

    const args = service.prisma.usuario.findFirst.mock.calls[0][0];
    expect(args.where.OR).toEqual(
      expect.arrayContaining([
        { empresa_id: 'emp-1' },
        { usuario_empresas: { some: { empresa_id: 'emp-1', active: true } } },
      ]),
    );
    expect(args.include.usuario_perfiles.where).toEqual({ perfiles: { OR: [{ empresa_id: 'emp-1' }, { empresa_id: null }] } });
  });

  it('el dueño (is_superadmin) de ESTA empresa no necesita el permiso', async () => {
    const service = crear({ is_superadmin: true, empresa_id: 'emp-1', usuario_perfiles: [] });

    await expect(validar(service)).resolves.toBeDefined();
  });

  it('C0 ronda 2: el is_superadmin de otra empresa no entra por ser superadmin (lo buscaba en toda la plataforma)', async () => {
    const service = crear({ usuario_perfiles: conPrivilegio(PRIVILEGIO_PIN_SUPERVISOR) });
    await validar(service);
    const or = service.prisma.usuario.findFirst.mock.calls[0][0].where.OR;
    expect(or).toEqual([{ empresa_id: 'emp-1' }, { usuario_empresas: { some: { empresa_id: 'emp-1', active: true } } }]);
  });

  it('C0 ronda 2: el dueño de otra empresa con acceso asignado a esta, sin el permiso en esta, es rechazado', async () => {
    // Se registró gratis (is_superadmin de su empresa) y tiene una asignación a esta: su PIN no saltea el permiso.
    const service = crear({ is_superadmin: true, empresa_id: 'emp-otra', usuario_perfiles: [] });

    await expect(validar(service)).rejects.toThrow(ForbiddenException);
    expect(service.prisma.autorizaciones_caja.create).not.toHaveBeenCalled();
  });
});
