/**
 * `ObjectUtils`: Utilizado para manipulação de objetos.
 */
export default class ObjectUtils{


    /**
     * Faz a cópia do objeto.
     * 
     * @param data - Objeto a ser copiado.
     * @returns - A cópia do objeto válido.
     */ 
    public static copy<T>(data:Object | Array<Object>): T {
        return this.stringToObject(this.objectToString(data)) as T;
    }

    /**
     * Converte um objeto em string/JSON.
     * 
     * @param data - Objeto a ser convertido.
     * @returns - Uma string JSON.
     * 
     * @example
     * @Informado: ```{nome : "Sankhya", cidade: "Uberlandia"}``` | Obtenho: ```"{"nome" : "Sankhya", "cidade":"Uberlandia"}"```
     */ 
    public static objectToString(data:Object | Array<Object>):string{
        return JSON.stringify(data);
    }

    /**
     * Converte uma string/JSON em objeto.
     * 
     * @param data - String a ser convertida.
     * @returns - Um objeto válido.
     * 
     * @example
     * Informado: ```"{"nome" : "Sankhya", "cidade":"Uberlandia"}"``` | Obtenho: ```{nome : "Sankhya", cidade: "Uberlandia"}```
     */ 
    public static stringToObject(data:string):Object | Array<Object>{
        return JSON.parse(data)
    }

    /**
     * Faz a ordenação de um objeto por uma propriedade.
     * 
     * @param data - Objeto a ser ordenado.
     * @param property - Nome da propriedade a ser ordenada.
     * @returns - O objeto ordenado pela propriedade.
     */
    public static sortByProperty(data: any, property: string): any {
        return Object.keys(data)
          .sort(function(keyA: string, keyB: string) { // Ordenação pela `property`
            const x = data[keyA][property];
            const y = data[keyB][property];
            return x < y ? -1 : x > y ? 1 : 0;
          }).reduce((obj: any, key: string) => { // Reconstrução do Objeto de retorno
            obj[key] = data[key];
            return obj;
          }, {});
    }
    
    /**
     * Remove atributos nulos e indefinidos de um objeto.
     * 
     * @param data - Objeto a ser filtrado.
     * @returns - O objeto com as propriedades válidas.
     */    
    public static removeEmptyValues(obj: object): object {
      return Object.fromEntries(
        Object.entries(obj)
          .filter(([, v]) => v != null)
          .map(([k, v]) => [k, v === Object(v) ? ObjectUtils.removeEmptyValues(v) : v])
      );

    }

    /**
     * Compara se um objeto é igual a outro objeto.
     * 
     * @param obj1 - Objeto a ser comparado.
     * @param obj2 - Objeto a ser comparado.
     * @returns - Se o objeto 1 é igual ao objeto 2.
     */
    public static equals(obj1: any, obj2: any): any {
      return ObjectUtils.objectToString(obj1) === ObjectUtils.objectToString(obj2);
    }

    /**
     * Compara se o valor de dois items são equivalentes.
     * Comparando tanto o valor do item em si, quanto sua propriedade "value"
     *
     * @param obj1 - Objeto a ser comparado.
     * @param obj2 - Objeto a ser comparado.
     * @param propToCompare - propriedade que deve ser comparada.
     * @returns - Se o objeto 1 é equivalente ao objeto 2.
     *
     * * @example
     * hasEquivalentProps('123', {value: '123', label: teste}, 'value') | Retorna: true
     * @example
     * hasEquivalentProps('xpto', {value: '123', label: teste}, 'propName') | Retorna: false
     */
    public static hasEquivalentProps(obj1: any, obj2: any, propToCompare:string = "value"): boolean{
      return this.getComparableProp(obj1, propToCompare) == this.getComparableProp(obj2, propToCompare);
    }

    private static getComparableProp(value: any, propToCompare:string = "value"): boolean{
      if (typeof value === 'object' && value !== null && propToCompare in value) {
        return value[propToCompare];
      }
      return value;
    }

    /**
    * Verifica se o objeto está vazio (sem atributos).
    * 
    * @param obj - Objeto a ser verificado.
    * @returns - True caso o objeto esteja vazio.
    */
    public static isEmpty(obj: object): boolean{
      return Object.keys(obj).length === 0 && obj.constructor === Object;
    }

  /**
   * Verifica se o objeto está vazio (sem atributos) e retorna true caso seja undefined ou null.
   *
   * @param obj - Objeto a ser verificado.
   * @returns - True caso o objeto esteja vazio.
   */
  public static isEmptySafetyCheck(obj: object): boolean{
    if(obj === null || obj === undefined) return true;
    return Object.keys(obj).length === 0 && obj.constructor === Object;
  }

    /**
     * Verifica se o objeto NÃO está vazio (sem atributos).
     * 
     * @param obj - Objeto a ser verificado.
     * @returns - True caso o objeto NÃO esteja vazio
     */
    public static isNotEmpty(obj: object): boolean{
      return !this.isEmpty(obj);
    }

  /**
   * Verifica se o objeto NÃO está vazio (sem atributos) e retorna false caso objeto seja null ou undefined.
   *
   * @param obj - Objeto a ser verificado.
   * @returns - True caso o objeto NÃO esteja vazio
   */
  public static isNotEmptySafetyCheck(obj: object): boolean{
    return !this.isEmptySafetyCheck(obj);
  }

    /**
     * Busca a propriedade de um objeto baseado em seu caminho.
     * 
     * @param obj - Objeto a ser verificado.
     * @param keyPath - Caminho da propriedade a ser buscada.
     * @returns - O valor da propriedade caso ela exista.
     */
    public static getProp(obj: Record<string, any>, keyPath: string): Record<string, any> | undefined {
      return keyPath.split('.').reduce((previous, current) => previous?.[current], obj);
    }
}