import {Component, InternalServerErrorException} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';

import { User } from '../entities/user.entity';
import { Role } from '../entities/role.entity';
import { UserEditDto } from '../dto/user-edit.dto';
import { Project } from '../entities/project.entity';

import { genSalt, hash } from 'bcrypt';

const saltRounds = 10;

export function generateHash(password?: string): Promise<string> {
    return new Promise((resolve, reject) => {
        genSalt(saltRounds, (err, salt) => {
            return hash(password, salt, (err, hash) => {
                if (err) {
                    reject('Could not hash password.');
                }
                resolve(hash);
            });
        });
    });
}

@Component()
export class UsersService {

    constructor(
        @InjectRepository(User) private userRepository: Repository<User>,
        @InjectRepository(Role) private roleRepository: Repository<Role>,
        @InjectRepository(Project) private projectRepository: Repository<Project>,
    ) {}

    async addUser(userEditDto?: UserEditDto): Promise<User> {
        let hashPassword;
        const projects = await this.projectRepository.findByIds(userEditDto.projects);
        await generateHash(userEditDto.password).then((hashPass) => {
            hashPassword = hashPass;
        }).catch((err) => {
            throw new InternalServerErrorException(err);
        });
        const user = await Object.assign(new User(), {
          firstName: userEditDto.firstName,
          lastName: userEditDto.lastName,
          email: userEditDto.email,
          password: hashPassword,
        });
        console.log('test');
        console.log(userEditDto.roles);
        user.roles = userEditDto.roles;
        user.projects = projects;
        if (!user) {
            return null;
        }

        return this.userRepository.save(user);
    }
}