import * as bcrypt from 'bcrypt';
import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import { UsersService } from './users.service';

/**
 * E2E 2026-10-25: el alta de un usuario con «Es supervisor» mandaba el PIN y el
 * servicio lo descartaba; el supervisor nuevo no podía autorizar nada («El
 * supervisor no tiene PIN configurado»). Además la respuesta devolvía el hash
 * de la contraseña.
 */
describe('UsersService.create — PIN de supervisor', () => {
  const crear = () => {
    const service = Object.create(UsersService.prototype) as any;
    service.logger = { log: jest.fn(), error: jest.fn() };
    service.auditService = { log: jest.fn() };
    service.planLimits = { checkLimit: jest.fn().mockResolvedValue(undefined) };
    service.resolveActorScope = jest.fn().mockResolvedValue({ elevated: true });
    service.assertEmailDisponible = jest.fn().mockResolvedValue(undefined);
    service.prisma = {
      usuario: {
        findFirst: jest.fn().mockResolvedValue(null),
        findUnique: jest.fn().mockResolvedValue(null),
        create: jest.fn(async ({ data }: any) => ({ id: 'u1', ...data })),
      },
      perfiles: { findUnique: jest.fn().mockResolvedValue(null) },
      usuario_perfiles: { create: jest.fn() },
    };
    return service;
  };
  const dto = (extra: Record<string, unknown> = {}) =>
    ({
      empresa_id: 'emp',
      username: 'super1',
      nombres: 'Super',
      password: 'Secreta1',
      estado: 'Activo',
      ...extra,
    }) as any;

  it('guarda el PIN hasheado cuando viene en el alta', async () => {
    const service = crear();
    const res = await service.create(dto({ pin_supervisor: '4321' }), 'actor', 'emp');
    const data = service.prisma.usuario.create.mock.calls[0][0].data;
    expect(data.pin_supervisor).toBeTruthy();
    expect(await bcrypt.compare('4321', data.pin_supervisor)).toBe(true);
    // La respuesta no expone hashes.
    expect(res.data.password).toBeUndefined();
    expect(res.data.pin_supervisor).toBeUndefined();
    expect(res.data.es_supervisor).toBe(true);
  });

  it('sin PIN el usuario nace sin PIN', async () => {
    const service = crear();
    await service.create(dto(), 'actor', 'emp');
    expect(service.prisma.usuario.create.mock.calls[0][0].data.pin_supervisor).toBeNull();
  });

  it('el DTO rechaza un PIN que no son 4 a 6 dígitos y acepta vacío (quitar) al editar', async () => {
    const malo = await validate(plainToInstance(CreateUserDto, dto({ pin_supervisor: '12a' })));
    expect(malo.some((e) => e.property === 'pin_supervisor')).toBe(true);
    const bueno = await validate(plainToInstance(CreateUserDto, dto({ pin_supervisor: '123456' })));
    expect(bueno.some((e) => e.property === 'pin_supervisor')).toBe(false);
    const quitar = await validate(plainToInstance(UpdateUserDto, { pin_supervisor: '' }));
    expect(quitar.some((e) => e.property === 'pin_supervisor')).toBe(false);
  });
});
