let arrUtil = {
    /**
     * 随机排序
     * @param arr
     */
    randomSort<T>(arr: Array<T>) {
        for (let j, x, i = arr.length; i; j = (Math.random() * i) | 0, x = arr[--i], arr[i] = arr[j], arr[j] = x) {
            ;
        }
    },
    /**
     * 移除数组index位置的元素
     * @param arr
     * @param index
     */
    spliceOne(arr: any[], index: number): boolean {
        if (index === -1 || index >= arr.length) {
            return false;
        }
        const len = arr.length - 1;
        for (let i = index; i < len; i++) {
            arr[i] = arr[i + 1];
        }
        arr.length = len;
        return true;
    },
    /**
     * 检查数组中是否含有另外一个object
     * @param arr 目标数组
     * @param obj 与数组同类型的obj | 同类型的数组 | 指定child字段的值 | 指定child字段的数组
     * @param child 比较字段
     */
    contains<T>(arr: Array<T>, obj: any, child: string): boolean {
        let result = false;
        if (child) {
            const isArr = Array.isArray(obj);
            if (isArr) {
                if (obj[0].hasOwnProperty(child)) {
                    let set0 = new Set();
                    for (let s of obj) {
                        set0.add(s[child]);
                    }
                    let set1 = new Set(arr.filter (x => set0.has(x)));
                    return set0.size === set1.size;
                } else {
                    let set0 = new Set(obj);
                    let set1 = new Set(arr.filter (x => set0.has(x)));
                    return set1.size === set0.size;
                }

            } else {
                if (obj.hasOwnProperty(child)) {
                    for (let sub of arr) {
                        if (sub.hasOwnProperty(child)) {
                            // @ts-ignore
                            if (sub[child] === obj[child]) {
                                result = true;
                                break;
                            }
                        }
                    }
                } else {
                    for (let sub of arr) {
                        if (sub.hasOwnProperty(child)) {
                            // @ts-ignore
                            if (sub[child] === obj) {
                                result = true;
                                break;
                            }
                        }
                    }
                }

            }
        } else {
            // 不指定 比较字段 的话, 只处理2种情况
            // 1: obj 为数组
            // 2: obj 不是数组
            if (Array.isArray(obj)) {
                let set0 = new Set(obj);
                let set1 = new Set(arr.filter (x => set0.has(x)));
                return set1.size === set0.size;
            } else {
                let idx = arr.indexOf(obj);
                return !!(~idx);
            }

        }
        return result;
    },
    /**
     * 将数组2随机插入数组1中
     * @param arr1
     * @param arr2
     */
    randomInsert<T>(arr1: Array<T>, arr2: Array<T>) {
        const length = arr1.length;
        arr2.forEach(value => {
            arr1.splice(Math.random() * length, 0 , value);
        })
        return arr1;
    },
    /**
     * 随机获取n个元素
     * @param arr
     * @param count
     */
    randomGet<T>(arr: Array<T>, count: number = 1) {
        let shuffled = arr.slice(0), i = arr.length, min = i - count, temp, index;
        if (min < 0) {
            return shuffled;
        }
        while (i-- > min) {
            index = Math.floor((i + 1) * Math.random());
            temp = shuffled[index];
            shuffled[index] = shuffled[i];
            shuffled[i] = temp;
        }
        return shuffled.slice(min);
    },
    /**
     * 随机获取1个
     * @param arr
     */
    randomOne<T>(arr: Array<T>) {
        let results = this.randomGet(arr, 1);
        if (results.length > 0) {
            return results[0];
        } else {
            return null;
        }
    },
    /**
     * 随机移除n个元素
     * @param arr
     * @param count
     */
    randomRemove<T>(arr: Array<T>, count: number = 1) {
        let result = [];
        while (count -- > 0 && arr.length > 0) {
            let index = Math.random() * arr.length | 0;
            result.push(...arr.splice(index, 1));
        }
        return result;
    },
    /**
     * 数组移动n位
     * @param arr
     * @param n n > 0 右移, n<0 左移
     */
    moveElement<T>(arr: Array<T>, n: number) {
        if (Math.abs(n) > arr.length) n = n % arr.length;
        return arr.slice(-n).concat(arr.slice(0, -n));
    }

}

export default arrUtil;