import { Injectable } from '@nestjs/common';
import {
  UserRoleNotValidException,
  DeleteFailedException,
  EmailAddressExistException,
} from 'exceptions';
import { PageMetaDto } from 'common/dtos';
import { UserRegisterDto, UserPartnerRegisterDto  } from 'modules/auth/dtos';
import { UserUpdateDto, UsersPageDto, UsersPageOptionsDto, UserSelfUpdateDto } from 'modules/user/dtos';
import { UserEntity } from 'modules/user/entities';
import { UserRepository } from 'modules/user/repositories';
import { PartnerService } from 'modules/partner/services';
import { Transactional } from 'typeorm-transactional-cls-hooked';
import { UserAuthService } from './user-auth.service';
import { UserConfigService } from './user-config.service';
import { RoleType, AdminRoleType, PAdminRoleType } from 'common/constants';



@Injectable()
export class UserService {
  constructor(
    private readonly _userRepository: UserRepository,
    private readonly _partnerService: PartnerService,
    private readonly _userAuthService: UserAuthService,
    private readonly _userConfigService: UserConfigService,
  ) {}

  @Transactional()
  public async createUser(
    userRegisterDto: UserPartnerRegisterDto,
    authUser?: UserEntity,
    role?: string
  ): Promise<UserEntity> {
    // try {
      const user = this._userRepository.create(userRegisterDto);
      
      const userEntity = await this._userRepository.save(user);
      let createdUser = {}
      if(role) { 
      if (authUser.userAuth.role === RoleType.ROOT) {
        createdUser = { ...userRegisterDto, role : RoleType[role] , user };
      } else if (authUser.userAuth.role === RoleType.ADMIN){
      createdUser = { ...userRegisterDto, role : AdminRoleType[role] , user };
      } else {
      createdUser = { ...userRegisterDto, role : PAdminRoleType[role] , user };
      }
      } 
      else {
        createdUser = { ...userRegisterDto, user };
      }
      await Promise.all([
        this._userAuthService.createUserAuth(createdUser),
        this._userConfigService.createUserConfig(createdUser)
      ]);

      return userEntity;

  }

  public async getUser(
    options: Partial<{ uuid: string; email: string }>,
  ): Promise<UserEntity | undefined> {
    const queryBuilder = this._userRepository.createQueryBuilder('user');

    if (options.uuid) {
      queryBuilder
        .leftJoinAndSelect('user.userAuth', 'userAuth')
        .leftJoinAndSelect('user.userConfig', 'userConfig')
        .leftJoinAndSelect('user.partner', 'partner' )
        .orWhere('user.uuid = :uuid', { uuid: options.uuid });
    }

    if (options.email) {
      queryBuilder.orWhere('user.email = :email', {
        email: options.email,
      });
    }
    /**
     * @todo hide partner address and contact.
     */
    const result = await queryBuilder.getOne();
    return result;
  }

  public async getUsersCount(): Promise<number> {
    const queryBuilder = this._userRepository.createQueryBuilder('user');
    return queryBuilder.getCount();
  }
  
  public async updateOwnAccount(
    user: UserEntity,
    userUpdateDto: UserSelfUpdateDto,
  ): Promise<UserEntity> {
    if (userUpdateDto.email) {
      const isEmail = await this.getUser({ email: userUpdateDto.email });

      if (isEmail) {
        throw new EmailAddressExistException();
      }

      await this._userRepository.update(user.id, {
        email: userUpdateDto.email,
      });
    }

    if (userUpdateDto.lastName) {
      await this._userRepository.update(user.id, {
        lastName: userUpdateDto.lastName,
      });
    }

    if (userUpdateDto.password) {
      await this._userAuthService.updatePassword(
        user.userAuth,
        userUpdateDto.password,
      );
    }

    return this.getUser({ uuid: user.uuid });
  }
  public async getUsers(
    user: UserEntity,
    pageOptionsDto: UsersPageOptionsDto
  ): Promise<UsersPageDto | undefined> {
    const queryBuilder = this._userRepository.createQueryBuilder(
      'user',
    );
    if(user.partner.id && user.userAuth.role === RoleType.P_ADMIN) {
      queryBuilder.orWhere('user.partner = :id', {
        id : user.partner.id,
      });
    }
    const [users, usersCount] = await queryBuilder
      .leftJoinAndSelect('user.userAuth', 'userAuth')
      .skip(pageOptionsDto.skip)
      .take(pageOptionsDto.take)
      .orderBy('user.createdAt', pageOptionsDto.order)
      .getManyAndCount();

    const pageMetaDto = new PageMetaDto({
      pageOptionsDto,
      itemCount: usersCount,
    });

    return new UsersPageDto(users.toDtos(), pageMetaDto);
  }
  public async updateUserData(
    uuid : string,
    user : UserEntity,
    userUpdateDto: UserUpdateDto,
  ): Promise<UserEntity> {
    const userData = await this.getUser({ uuid: uuid })

    if (userUpdateDto.email) {
      const isEmail = await this.getUser({ email: userUpdateDto.email });

      if (isEmail) {
        throw new EmailAddressExistException();
      }

      await this._userRepository.update(userData.id, {
        email: userUpdateDto.email,
      });
    }
    
    if (userUpdateDto.partner && (user.userAuth.role === RoleType.ADMIN || user.userAuth.role === RoleType.ROOT)) {
      const partner = await this._partnerService.getPartnerEntity({uuid: userUpdateDto.partner})
      await this._userRepository.update(userData.id, {
        partner: partner,
      });
    }
    if (userUpdateDto.lastName) {
      await this._userRepository.update(userData.id, {
        lastName: userUpdateDto.lastName,
      });
    }
    if (userUpdateDto.firstName) {
      await this._userRepository.update(userData.id, {
        firstName: userUpdateDto.firstName,
      });
    }
    if (userUpdateDto.role){
      try {
        switch (user.userAuth.role) {
          case RoleType.P_ADMIN:
            await this._userAuthService.updateRole(
              userData.userAuth,
              PAdminRoleType[userUpdateDto.role],
            );
            break;
          case RoleType.ROOT:
            await this._userAuthService.updateRole(
              userData.userAuth,
              RoleType[userUpdateDto.role],
            );  
            break;
          case RoleType.ADMIN:
            await this._userAuthService.updateRole(
              userData.userAuth,
              AdminRoleType[userUpdateDto.role],
            );
          default:
            break;
        }
      } catch (error) {
        throw new UserRoleNotValidException(); 
      }

    }
    if (userUpdateDto.password) {
      await this._userAuthService.updatePassword(
        userData.userAuth,
        userUpdateDto.password,
      );
    }
    return this.getUser({ uuid: userData.uuid });
  }
  public async deleteUser(uuid:string): Promise<void> {
    try {
      const found = await this.getUser({uuid: uuid})
      await this._userRepository.delete(found.id)
    } catch (error) {
      throw new DeleteFailedException();
    }
  }
}