import { isEmptyTrim } from './validate'

type LoopArrItem<K extends string, U extends object> =
U & { [key in K]?: Array<LoopArrItem<K, U>> }

/**
 * 转换数组
 * @param arr 旧数组
 * @param transformMap 新key和（旧key|获取新值的function）的映射
 * @returns 返回一个新的数组，该数组是浅拷贝的数组
 */
export function transformValueArr<U extends { [key in string]: unknown }, T extends {
  [key in string]: keyof U | ((data: U) => unknown)
}>(arr: Array<U>, transformMap: T) {
  return arr.map(item => ({
    ...item,
    ...Object.entries(transformMap)
      .reduce((collect, [key, value]) => {
        collect[key] = typeof value === 'function' ? value(item) : item[value]
        return collect
      }, {} as { [key: string]: unknown })
  })) as Array<U & { [key in keyof T]: T[key] extends (data: U) => unknown ? ReturnType<T[key]> : T[key] extends keyof U ? U[T[key]] : object }>
}

/**
 * 循环转换数组
 * @param arr 需要转换的数组
 * @param transfromMap 新key和（旧key|获取新值的function）的映射
 * @param childKey 数组的子节点的key值
 * @returns 返回一个新的数组，该数组是浅拷贝的数组
 */
export function loopTransformLabelArr<K extends string, U extends LoopArrItem<K, { [key in string]: unknown }>, T extends {
  [key in string]: keyof U | ((data: U) => unknown)
}> (arr: Array<U>, transfromMap: T, childKey: K): Array<LoopArrItem<K, U & { [key in keyof T]: T[key] extends (data: U) => unknown ? ReturnType<T[key]> : T[key] extends keyof U ? U[T[key]] : undefined }>> {
  const depMap = new Map()
  return arr.map(item => {
    if (depMap.has(item)) return depMap.get(item)
    const children = item[childKey]
    const childArr = children !== undefined ? loopTransformLabelArr(children as Array<U>, transfromMap, childKey) : children
    let result = {
      ...item,
      [childKey]: childArr
    }
    const transformObj = Object.entries(transfromMap)
      .reduce((collect, [key, value]) => {
        collect[key] = typeof value === 'function' ? value(item) : item[value]
        return collect
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      }, {} as any)
    result = {
      ...result,
      ...transformObj
    }
    depMap.set(item, result)
    return result
  })
}

type AnyElementOf<T extends unknown[]> = T[number]

/**
 * 浅拷贝对象并且剔除一些属性
 * @param obj 目标对象
 * @param filterKeys 需要剔除的属性集合
 * @returns 新的对象
 */
export function omitObjectKeys<T extends object, U extends keyof T> (obj: T, filterKeys: Array<U>) {
  const keys = filterKeys.map(item => String(item))
  return Object.fromEntries(
    Object.entries(obj)
      .filter(([key]) => !keys.includes(key))
  ) as Omit<T, AnyElementOf<Array<U & string>>>
}

/**
* 若为空则替换为指定的字符串
* @param s 要替换的字符串
* @param replaceString 为空时替换的字符串
* @return
*/
export function nvl (s:string, replaceString: string) {
  return isEmptyTrim(s) ? replaceString : s
}

export function getPropByPath <T extends object> (obj: T, path: string, strict?: boolean) {
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  let tempObj:any = obj
  path = path.replace(/\[(\w+)\]/g, '.$1')
  path = path.replace(/^\./, '')

  const keyArr = path.split('.')
  let i = 0
  for (let len = keyArr.length; i < len - 1; ++i) {
    if (!tempObj && !strict) break
    const key = keyArr[i]
    if (key in tempObj) {
      tempObj = tempObj[key]
    } else {
      if (strict) {
        throw new Error('please transfer a valid prop path to form item!')
      }
      break
    }
  }
  return {
    o: tempObj,
    k: keyArr[i],
    v: tempObj ? tempObj[keyArr[i]] : null
  }
}