/**
 * 删除数组中指定的元素,返回数组本身
 * @param {Array<any>} arr 需要操作的数组
 * @param {*} el 需要移除的元素
 */
export function arrayRemove<T>(arr: Array<T>, el: T): Array<T>
{
  let j = 0
  for (let i = 0, l = arr.length; i < l; i++)
  {
    if (arr[i] !== el)
    {
      arr[j++] = arr[i]
    }
  }
  arr.length = j

  return arr
}

export function arrayRemoveOnce<T>(arr: Array<T>, el: T): Array<T>
{
  let index = arr.indexOf(el)
  if (index !== -1)
    arr.splice(index, 1)
  return arr
}

/**
 * 删除通过函数校验的元素
 * @param {(e: T) => boolean} checkFuntion 校验函数
 */
export function arrayRemoveIf<T>(arr: Array<T>, checkFuntion: (e: T) => boolean): Array<T>
{
  let j = 0
  for (let i = 0, l = arr.length; i < l; i++)
  {
    if (!checkFuntion(arr[i]))
    {
      arr[j++] = arr[i]
    }
  }
  arr.length = j

  return arr
}

/** 获取数据第一个元素 */
export function arrayFirst<T>(arr: Array<T>): T
{
  return arr[0]
}

/** 获取数组最后一个元素 */
export function arrayLast<T>(arr: { [key: number]: T; length: number }): T
{
  return arr[arr.length - 1]
}

/**
 * 根据数值从小到大排序数组
 * @param {Array<T>} arr
 * @returns {Array<T>} 返回自身
 */
export function arraySortByNumber<T>(arr: Array<T>): Array<T>
{
  arr.sort(sortNumberCompart)
  return arr
}

/**
 * 对排序好的数组进行去重操作
 * @param {(e1, e2) => boolean} [checkFuction] 校验对象相等函数
 * @returns {Array<T>} 返回自身
 */
export function arrayRemoveDuplicateBySort<T>(arr: Array<T>, checkFuction: (e1: T, e2: T) => boolean = checkEqual): Array<T>
{
  if (arr.length < 2)
    return arr
  let j = 1
  for (let i = 1, l = arr.length; i < l; i++)
    if (!checkFuction(arr[j - 1], arr[i]))
      arr[j++] = arr[i]
  arr.length = j
  return arr
}

/** 原地更新数组,注意这个函数并不会比map快 */
export function arrayMap<T>(arr: Array<T>, mapFunc: (v: T) => T): Array<T>
{
  for (let i = 0, count = arr.length; i < count; i++)
    arr[i] = mapFunc(arr[i])
  return arr
}

/** 排序数比较 */
function sortNumberCompart(e1: any, e2: any)
{
  return e1 - e2
}

/** 判断两个数是否相等 */
function checkEqual(e1: any, e2: any): boolean
{
  return e1 === e2
}

/**
 * 改变数组的值顺序
 * @param arr 需要改变初始值位置的数组
 * @param index  //将index位置以后的值放到起始位置
 */
export function changeArrayStartIndex<T>(arr: T[], index: number): T[]
{
  arr.unshift(...arr.splice(index))
  return arr
}

/** 判断两个数组是否相等 */
export function equalArray<T>(a: T[], b: T[], checkF = checkEqual)
{
  if (a === b)
    return true
  if (a.length !== b.length)
    return false
  for (let i = 0; i < a.length; ++i)
    if (!checkF(a[i], b[i]))
      return false
  return true
}

/** 数组克隆 */
export function arrayClone<T>(arr: T[]): T[]
{
  return arr.slice()
}

/** 数组2元素合并到数组1末尾 */
// https://jsperf.com/merge-array-implementations/30
export function arrayPushArray<T>(arr1: T[], arr2: T[]): T[]
{
  let arr1Length = arr1.length
  let arr2Length = arr2.length
  arr1.length = arr1Length + arr2Length
  for (let i = 0; i < arr2Length; i++)
    arr1[arr1Length + i] = arr2[i]

  return arr1
}

/** 数组元素求合 */
export function arraySum(arr: number[])
{
  let sum = 0
  for (let n of arr) sum += n
  return sum
}

/** 条件过滤集合 */
export function FilterSet<T>(s: Set<T>, fn: (el: T) => boolean): Set<T>
{
  let ns = new Set<T>()
  for (let el of s)
  {
    if (fn(el))
      ns.add(el)
  }
  return ns
}

/** 查找数组中最大的元素 */
export function arrayMax<T>(arr: T[], f: (item: T) => number = a => (a as unknown as number)): [T, number]
{
  let max = Number.NEGATIVE_INFINITY
  let maxIndex = -1
  for (let i = 0; i < arr.length; i++)
  {
    let item = arr[i]
    let v = f(item)
    if (v > max)
    {
      maxIndex = i
      max = v
    }
  }
  return [arr[maxIndex], maxIndex]
}