import { StringUtils } from "./StringUtils.js";
import { NumberUtils } from './NumberUtils.js';
import ObjectUtils from "./ObjectUtils.js";

/**
 * `ArrayUtils`: Utilitário com a responsabilidade de manipular Arrays.
 */
export default class ArrayUtils {
    /**
     * Filtra um array a partir de um critério textual.
     * 
     * @param argument - Texto a ser usado no filtro.
     * @param originalArray - Array no formato original.
     * @param alphabeticalSorting - Determina se o resultado deve ser ordenado ou mantido na ordem original. Por padrão ordena.
     * @param fieldName - Caso o objeto deva ser filtrado por um campo diferente de "label", pode-se usar esse parâmetro.
     * @returns - Um array filtrado e ordenado conforme necessidade..
     */
    static applyStringFilter(argument: string, originalArray: Array<any>, alphabeticalSorting: boolean = true, fieldName: string = "label"): Array<any>{
       if(!argument){
            return originalArray;
        }
        const normalizedArgument = ArrayUtils.normalizeSearchString(argument);
        const filteredArray = originalArray.filter(item => {
            const itemValue: string = ArrayUtils.normalizeSearchString(item[fieldName]);
            return itemValue.includes(normalizedArgument);
        });
        return alphabeticalSorting ? ArrayUtils.sortAlphabetically(filteredArray, fieldName) : filteredArray;
    }

    /**
     * Converte texto para caixa alta e substitui caracteres acentuados.
     * 
     * @param original - Texto a ser convertido.
     * @returns - Texto com as letras acentuadas sem os acentos e em caixa alta.
     */
    private static normalizeSearchString(original:string ): string{
        return StringUtils.replaceAccentuatedCharsKeepSymbols(String(original).toUpperCase());
    }

    /**
     * Ordena valores de um array alfabeticamente.
     *
     * @param originalArray - Array a ser ordenado.
     * @returns - Array ordenado alfabeticamente..
     */
    static sortAlphabetically(originalArray: Array<any>, fieldName: string = "label"): Array<any>{
        return originalArray.sort((fieldA, fieldB) => {
          
          const valueStringA = fieldA[fieldName];
          const valueStringB = fieldB[fieldName];
          
          const valueIntA = NumberUtils.stringToNumber(valueStringA);
          const valueIntB = NumberUtils.stringToNumber(valueStringB);

          if(isNaN(valueIntA) || isNaN(valueIntB)){
            return StringUtils.compare(valueStringA, valueStringB)
          } else {
            return NumberUtils.compare(valueIntA, valueIntB);
          }
        });
    }

    /**
     * Ordena valores de um array alfabeticamente.
     *
     * @param arr - Array a ser ordenado.
     * @returns - Array ordenado alfabeticamente..
     */
    public static find(arr: any, checkerFn: any) {
      if (arr) {
        for (let i = 0, length = arr.length; i < length; i++) {
          if (checkerFn(arr[i], i, arr)) {
            return arr[i];
          }
        }
      } else {
        return undefined;
      }
    }

    /**
     * Retorna o objeto se for encontrado no array, ou -1 se não for encontrado.
     *
     * @param arr - Array onde está o objeto.
     * @param obj - Objeto a ser procurado.
     * @returns - Array ordenado alfabeticamente..
     */
    public static indexOf(arr: any, obj: any) {
      let index = -1;
      if (Array.isArray(arr)) {
        ArrayUtils.find(arr, (item: any, i: number) => {
          index = i;
          return ObjectUtils.equals(obj, item);
        });
      }
      return index;
    }

    /**
     * Remove um item de array de acordo com o index.
     *
     * @param array - Array onde está o item.
     * @param index - Index do item a ser removido.
     * @returns - Array sem o item do index informado.
     */
    public static removeAtIndex(array: any, index: number) {
      if (index >= 0 && index < array.length) {
        return array.splice(index, 1)[0];
      }
    }

    /**
     * Remove um objeto do array.
     *
     * @param array - Array onde está o objeto.
     * @param obj - Objeto a ser removido.
     * @returns - Array sem o Objeto informado.
     */
    public static removeReference(array: any, obj: any) {
      let index = ArrayUtils.indexOf(array, obj);
      return ArrayUtils.removeAtIndex(array, index);
    }

    /**
     * Remove um objeto do array.
     *
     * @param array - Array onde está o objeto.
     * @param obj - Objeto a ser removido.
     * @returns - Array sem o Objeto informado.
     */
    public static isIn(arr: any, obj: any) {
      return ArrayUtils.indexOf(arr, obj) > -1;
    }
}