import LinkList from '@ohos.util.List';
import HashMap from '@ohos.util.HashMap';

/**
 * ArrayUtils class.
 */

export class CollectionUtils {
  /**
   *  The Array utils tag.
   */
  private static readonly TAG: string = 'ArrayUtils';

  static isArray(value: any): boolean {
    if (typeof Array.isArray === 'function') {
      return Array.isArray(value);
    } else {
      return Object.prototype.toString.call(value) === '[object Array]';
    }
  }

  /**
   * Check collection is empty or not.
   * @param collection any[]
   * @returns  {boolean} true(empty)
   */
  static isEmpty(collection?: any[]): boolean {
    return !collection || collection.length === 0;
  }

  static isEmptyList<T>(list1?: LinkList<T>): boolean {
    return !list1 || list1.length === 0;
  }

  static isEmptyHashMap(obj?: HashMap<any, any>): boolean {
    if (!obj) {
      return true;
    }
    return obj.isEmpty();
  }

  static isEmptyMap(obj?: Map<any, any>): boolean {
    if (!obj) {
      return true;
    }
    return Object.keys(obj).length === 0 && obj.constructor === Object;
  }

  static isEmptyRecord(obj?: Record<string, string>): boolean {
    if (!obj) {
      return true;
    }
    return Object.keys(obj).length === 0 && obj.constructor === Object;
  }

  /**
   * Check collection is empty or not.
   * @param collection any[]
   * @returns  {boolean} true(not empty)
   */
  static isNotEmpty(collection?: any[]): boolean {
    if (!collection) {
      return false
    }
    return collection.length > 0;
  }

  static getListSize(collection?: any[]): number {
    return CollectionUtils.isEmpty(collection) ? 0 : collection.length;
  }

  static getListElement(collection?: any[], index?: number): any {
    if (CollectionUtils.isEmpty(collection) || index === undefined) {
      return null;
    }
    return index >= 0 && index < collection.length ? collection[index] : null;
  }

  static convertArray<T>(objectList: T[] | T): T[] {
    if (CollectionUtils.isArray(objectList)) {
      return objectList as T[];
    } else {
      return [objectList as T];
    }
  }

  /**
   * 把list2合入list1后
   * @param list1
   * @param list2
   * @returns
   */
  static addAll<T>(list1: LinkList<T>, list2: LinkList<T>): LinkList<T> {
    if (!list1) {
      list1 = new LinkList<T>();
    }
    if (!list2) {
      return list1;
    }

    for (let index = 0; index < list2.length; index++) {
      list1.add(list2[index])
    }
    return list1
  }

  static deepCopy(objectList: any[]): any[] {
    const list: any[] = [];
    for (const objectItem of objectList) {
      if (typeof objectItem !== 'object') {
        list.push(objectItem);
        continue;
      }
      if (objectItem.constructor === Date) {
        list.push(new Date(objectItem));
        continue;
      }
      if (objectItem.constructor === RegExp) {
        list.push(new RegExp(objectItem));
        continue;
      }
      if (objectItem.clone) {
        list.push(objectItem.clone());
        continue;
      }
      const newObj = new objectItem.constructor();
      for (const key in objectItem) {
        if (Object.hasOwnProperty.call(objectItem, key)) {
          const val = objectItem[key];
          newObj[key] = val;
        }
      }
      list.push(newObj);
    }
    return list;
  }

  static deepCopyNumber(values: Set<number>): Set<number> {
    const newSet: Set<number> = new Set();
    values.forEach((value => {
      newSet.add(value);
    }));
    return newSet;
  }

  /**
   * Uint8Array to string
   * @param fileData Uint8Array
   */
  static uint8ArrayToString(fileData: Uint8Array): string {
    return decodeURIComponent(escape(String.fromCharCode(...fileData)));
  }

  /**
   * string to Uint8Array
   * @param str string
   */
  static stringToUint8Array(str: string): Uint8Array {
    // spilt('') Each character is divided between them
    const arr = unescape(encodeURIComponent(str)).split('').map(val => val.charCodeAt(0));
    return new Uint8Array(arr);
  }

  /**
   * 截取集合部分数据。
   * start：0 - end：20  截取0-19，共20个数据
   */
  static getSubElements(collection?: any[], start?: number, end?: number): any[] {
    if (CollectionUtils.isEmpty(collection) || start === undefined || end === undefined) {
      return null;
    }
    if (start < 0 || end < start) {
      return null;
    }
    if (end > collection.length) {
      return null;
    }
    let ss = collection.slice(start, end);
    ss;
    return collection.slice(start, end);
  }
}