/**
   * Populate entit(y|ies) passed in paramter with "userCreated" and "userUpdated" properties
   * @param entities Array of entities OR an entity to populate
   * @returns Entit(y|ies) populated
   */
  private async populate(entities: Array<T> | any): Promise<Array<T> | any> {
    if (!entities) return;

    let tmp = entities;
    if (!Array.isArray(tmp)) tmp = [tmp];

    for (const idx in tmp) {
      const { userCreated, userUpdated } = tmp[idx];

      if (userCreated)
        tmp[idx].userCreated = await findByField(this.repository, { _id: userCreated?._id ?? userCreated });

      if (userUpdated)
        tmp[idx].userUpdated = await findByField(this.repository, { _id: userUpdated?._id ?? userUpdated });
    }

    return Array.isArray(entities) ? tmp : tmp[0];
  }

private createObject(dto: createDto | updateDto): T {
    const newEntity = {} as T;
    return Object.assign(newEntity, dto);
  }

async findAll(condition = { isDeleted: false }): Promise<T[]> {
    const where: FindConditions<T> = { ...condition };
    return this.repository.find({ where });
  }

async paginate(take, skip, condition = { isDeleted: false }, type?): Promise<any> {
    const queryTake = Number(take) || PaginationConstants.DEFAULT_TAKE;
    const querySkip = Number(skip) || PaginationConstants.DEFAULT_SKIP;

    let where = { ...condition };
    if (type) {
      where = { ...condition, ...{ type } };
    }
    const [result, total] = await this.repository.findAndCount({
      where,
      //order: { createdAt: -1 },
      take: queryTake,
      skip: querySkip
    });
    return {
      data: result,
      count: total
    };
  }

async findOne(_id: ObjectID): Promise<T> {
    // throws error 404 if not found
    const entity = await findByField(this.repository, { id: _id }, true);
    return await this.populate(entity);
  }

/**
   *
   * @param data : the CreateDTO of the submitted entity
   * @returns : The created entity
   */
  async create(data: createDto): Promise<T> {
    const newEntity = this.createObject(data);
    newEntity.isDeleted = false;
    if (this.request.user) {
      newEntity.userCreated = this.request.user._id;
      newEntity.userUpdated = this.request.user._id;
    }
    const entity = this.repository.create(newEntity as any);
    return this.repository.save(entity as any);
  }

/**
 *
 * @param _id : the ID of the entity
 * @param dto : the DTO to be assigned for the entity
 * @returns : The modified entity
 */
async update(_id: ObjectID, dto: updateDto): Promise<T> {
  let newEntity = this.createObject(dto);
  if (this.request.user) {
    newEntity.userUpdated = this.request.user._id;
  }
  newEntity = await this.repository.preload({
    _id: (await findByField(this.repository, { id: _id }, true))._id,
    ...dto
  } as any);
  return this.repository.save(newEntity as any);
  }

/**
   *
   * @param _id : ObjectID of the given entity
   * This method applies logical deletion or restoration from the database by setting the isDeleted to true or false
   */
  async updateStatus(_id: ObjectID, isDeleted: boolean): Promise<T> {
    let entity = {} as T;
    entity = await findByField(this.repository, { _id }, true);
    entity.isDeleted = isDeleted;
    if (this.request.user) {
      entity.userUpdated = this.request.user._id;
    }
    return await this.repository.save(entity as any);
  }

@Patch('archive/:id')
async archive(@Param(new ValidateObjectIdPipe('')) params): Promise<T> {
  return this.service.updateStatus(new ObjectID(params.id), true);
}

@Patch('unarchive/:id')
async unarchive(@Param(new ValidateObjectIdPipe('')) params): Promise<T> {
  return this.service.updateStatus(new ObjectID(params.id), false);
} 

async delete(_id: ObjectID): Promise<void> {
    await findByField(this.repository, { _id }, true);
    await this.repository.delete(_id);
}

/**
   * This method deletes permanently from the database
   */
  async clear(): Promise<void> {
    try {
      await this.repository.clear();
    } catch (error) {
      if (error.name === 'MongoError' && error.code === 26) {
        // Handle "is not found" error
        // Perform alternative logic or error handling
        console.log('Collection does not exist. Unable to clear.');
      } else {
        // Handle other errors
        console.log('An error occurred:', error);
      }
    }
  }

async search(data: QueryDto<T>): Promise<SearchResponse<T>> {
    const query: FindManyOptions<T> = { where: {} }; // initialize query to an empty object

    const queryTake = +data.take || PaginationConstants.DEFAULT_TAKE;
    const querySkip = +data.skip || PaginationConstants.DEFAULT_SKIP;
    const filterCriteria = data.attributes.map(attribute => {
      return {
        [attribute.key]:
          attribute.comparator == ComparatorEnum.EQUALS
            ? attribute.value
            : attribute.comparator == ComparatorEnum.LIKE
            ? RegExp(`^${attribute.value}`, 'i')
            : attribute.value
      };
    });
    query.where =
      data.type.toUpperCase() === ComparaisonTypeEnum.AND ? { $and: filterCriteria } : { $or: filterCriteria };
    const [result, total] = await this.repository.findAndCount({
      where: query.where,
      order: data.orders,
      ...(data.isPaginable == true || data.isPaginable == undefined
        ? {
            take: queryTake,
            skip: querySkip
          }
        : {})
    });
    return {
      data: result,
      count: total,
      ...(data.isPaginable == true || data.isPaginable == undefined
        ? {
            page: querySkip,
            totalPages: total == queryTake ? Math.trunc(total / queryTake) : Math.trunc(total / queryTake + 1)
          }
        : {})
    };
  }async search(data: QueryDto<T>): Promise<SearchResponse<T>> {
    const query: FindManyOptions<T> = { where: {} }; // initialize query to an empty object

    const queryTake = +data.take || PaginationConstants.DEFAULT_TAKE;
    const querySkip = +data.skip || PaginationConstants.DEFAULT_SKIP;
    const filterCriteria = data.attributes.map(attribute => {
      return {
        [attribute.key]:
          attribute.comparator == ComparatorEnum.EQUALS
            ? attribute.value
            : attribute.comparator == ComparatorEnum.LIKE
            ? RegExp(`^${attribute.value}`, 'i')
            : attribute.value
      };
    });
    query.where =
      data.type.toUpperCase() === ComparaisonTypeEnum.AND ? { $and: filterCriteria } : { $or: filterCriteria };
    const [result, total] = await this.repository.findAndCount({
      where: query.where,
      order: data.orders,
      ...(data.isPaginable == true || data.isPaginable == undefined
        ? {
            take: queryTake,
            skip: querySkip
          }
        : {})
    });
    return {
      data: result,
      count: total,
      ...(data.isPaginable == true || data.isPaginable == undefined
        ? {
            page: querySkip,
            totalPages: total == queryTake ? Math.trunc(total / queryTake) : Math.trunc(total / queryTake + 1)
          }
        : {})
    };
  }

generateResetPasswordJWT(user) {
  return jwt.sign(
    {
      email: user.email,
      username: user.username
    },
    process.env.SECRET,
    { expiresIn: process.env.RESET_PASSWORD_EXPIRATION || '24h' }
  );
}

/**
 * Find user by email
 * @param email to search (unique index)
 * @throws Error if user not found
 * @returns {IUser} populated user
 */
async findByEmail(email: string): Promise<IUser> {
  // throws error 404 if not found
  const user = await findByField(this.userRepository, { email }, true);
  return this.populateUsers(user);
}

/**
 * Populate entit(y|ies) passed in paramter with "userCreated" and "userUpdated" properties
 * @param entities Array of entities OR an entity to populate
 * @returns Entit(y|ies) populated
 */
public async populateUsers(entities: Array<any> | any): Promise<Array<any> | any> {
  if (!entities) return;

  let tmp = entities;
  if (!Array.isArray(tmp)) tmp = [tmp];

  for (const idx in tmp) {
    const { userCreated, userUpdated } = tmp[idx];

    if (userCreated)
      tmp[idx].userCreated = await findByField(this.userRepository, { _id: userCreated?._id ?? userCreated });

    if (userUpdated)
      tmp[idx].userUpdated = await findByField(this.userRepository, { _id: userUpdated?._id ?? userUpdated });
  }

  return Array.isArray(entities) ? tmp : tmp[0];
}

async findAll(): Promise<UserEntity[]> {
  const users = await this.userRepository.find({ status: true, isDeleted: false });
  return await this.populateUsers(users);
}

async createUser(dto: UserCreateDto): Promise<IUser> {
  const newUser = Object.assign(new UserEntity({}), dto);
  newUser.isDeleted = false;
  return await this.userRepository.save(newUser);
}

async update(toUpdate: UserEntity, dto: UserUpdateDto): Promise<IUser> {
    toUpdate.userCreated = this.request.user._id;
    toUpdate.userUpdated = this.request.user._id;
    Object.assign(toUpdate, dto);
    return this.populateUsers(await this.userRepository.save(toUpdate));
  }

async delete(id: ObjectID): Promise<IUser> {
  // throws error 404 if not found
  const user = await findByField(this.userRepository, { id }, true);
    user.status = false;
    user.isDeleted = false;
  return await this.userRepository.save(user);
}