import { forEach,hasOneOf, objEqual } from '@/libs/tools'
export const showTitle = (item:any, vm:any) => {
  let { title, __titleIsFunction__ } = item
  if (!title) return
  title = (item && item.title) || item.name
  return title
}

export const findNodeUpperByClasses = (ele : any, classes : any) => {
  let parentNode = ele.parentNode
  if (parentNode) {
    let classList = parentNode.classList
    if (classList && classes.every(className => classList.contains(className))) {
      return parentNode
    } else {
      return findNodeUpperByClasses(parentNode, classes)
    }
  }
}

/**
 * @description 根据name/params/query判断两个路由对象是否相等
 * @param {*} route1 路由对象
 * @param {*} route2 路由对象
 */
export const routeEqual = (route1 : any, route2 : any) => {
  const params1 = route1.params || {}
  const params2 = route2.params || {}
  const query1 = route1.query || {}
  const query2 = route2.query || {}
  return (route1.name === route2.name) && objEqual(params1, params2) && objEqual(query1, query2)
}

/**
 * @param {Array} routeMetched 当前路由metched
 * @returns {Array}
 */
export const getBreadCrumbList = (route : any, homeRoute : any) => {
  let homeItem = { ...homeRoute, icon: homeRoute.meta.icon }
  let routeMetched = route.matched
  if (routeMetched.some(item => item.name === homeRoute.name)) return [homeItem]
  let res = routeMetched.filter(item => {
    return item.meta === undefined || !item.meta.hideInBread
  }).map(item => {
    let meta = { ...item.meta }
    if (meta.title && typeof meta.title === 'function') {
      meta.__titleIsFunction__ = true
      meta.title = meta.title(route)
    }
    let obj = {
      icon: (item.meta && item.meta.icon) || '',
      name: item.name,
      meta: meta
    }
    return obj
  })
  res = res.filter(item => {
    return !item.meta.hideInMenu
  })
  return [{ ...homeItem, to: homeRoute.path }, ...res]
}

/**
 * @param {Array} routers 路由列表数组
 * @description 用于找到路由列表中name为home的对象
 */
export const getHomeRoute = (routers : Array<any>, homeName = 'home') => {
  let i = -1
  let len = routers.length
  let homeRoute = {}
  while (++i < len) {
    let item = routers[i]
    if (item.children && item.children.length) {
      let res = getHomeRoute(item.children, homeName)
      if (res.name) return res
    } else {
      if (item.name === homeName) homeRoute = item
    }
  }
  return homeRoute
}

/**
 * @returns {Array} 其中的每个元素只包含路由原信息中的name, path, meta三项
 */
export const getTagNavListFromSessionstorage = ():Array<any> => {
  const list = sessionStorage.tagNaveList
  return list ? JSON.parse(list) : []
}

/**
 * @description 本地存储和获取标签导航列表
 */
export const setTagNavListInSessionstorage = list => {
  sessionStorage.tagNaveList = JSON.stringify(list)
}


/**
 * @param {Array} list 标签列表
 * @param {String} name 当前关闭的标签的name
 */
export const getNextRoute = (list : Array<any>, route : any) => {
  let res = {}
  if (list.length === 2) {
    res = getHomeRoute(list)
  } else {
    const index = list.findIndex(item => routeEqual(item, route))
    if (index === list.length - 1) res = list[list.length - 2]
    else res = list[index + 1]
  }
  return res
}

export const getRouteTitleHandled = (route : any) => {
  let router = { ...route }
  let meta = { ...route.meta }
  let title = ''
  if (meta.title) {
    if (typeof meta.title === 'function') {
      meta.__titleIsFunction__ = true
      title = meta.title(router)
    } else title = meta.title
  }
  meta.title = title
  router.meta = meta
  return router
}

/**
 * 判断打开的标签列表里是否已存在这个新添加的路由对象
 */
export const routeHasExist = (tagNavList : Array<any>, routeItem : any) => {
  let len = tagNavList.length
  let res = false
  doCustomTimes(len, (index : number) => {
    if (routeEqual(tagNavList[index], routeItem)) res = true
  })
  return res
}

/**
 * @param {Number} times 回调函数需要执行的次数
 * @param {Function} callback 回调函数
 */
export const doCustomTimes = (times : any, callback : any) => {
  let i = -1
  while (++i < times) {
    callback(i)
  }
}

/**
 * @param {Array} list 通过路由列表得到菜单列表
 * @returns {Array}
 */
export const getMenuByRouter = (list : Array<any>, access : any) => {
  let res :Array<any> = [];
  // list.forEach(ele=>{
  //   ele.children.forEach((item,index) => {
  //     if(item.meta&&item.meta.hideInMenu){
  //       ele.children.splice(index,1)
  //     }
  //   });
  // })
  list.forEach((ele,index,arr)=>{
    if(ele.target!=null&&ele.meta&&ele.meta.hideInMenu){
      arr.splice(index,1)
    }
  })
  return list
}

export const hasChild = (item : any) => {
  return item.children && item.children.length !== 0
}

const showThisMenuEle = (item : any, access : any) => {
  if (item.meta && item.meta.access && item.meta.access.length) {
    if (hasOneOf(item.meta.access, access)) return true
    else return false
  } else return true
}

/**
 * @param {*} list 现有标签导航列表
 * @param {*} newRoute 新添加的路由原信息对象
 * @description 如果该newRoute已经存在则不再添加
 */
export const getNewTagList = (list : Array<any>, newRoute : any) : Array<any> => {
  const { name, path, meta } = newRoute
  let newList = [...list]
  if (newList.findIndex(item => item.name === name) >= 0) return newList
  else newList.push({ name, path, meta })
  return newList
}

// scrollTop animation
export const scrollTop = (el : any, from = 0, to : any, duration = 500, endCallback :Function) => {
  if (!window.requestAnimationFrame) {
    window.requestAnimationFrame = (
      window.webkitRequestAnimationFrame ||
      (window as any).mozRequestAnimationFrame ||
      (window as any).msRequestAnimationFrame ||
      function (callback) {
        return window.setTimeout(callback, 1000 / 60)
      }
    )
  }
  const difference = Math.abs(from - to)
  const step = Math.ceil(difference / duration * 50)

  const scroll = (start : any, end : any, step : any) => {
    if (start === end) {
      endCallback && endCallback()
      return
    }

    let d = (start + step > end) ? end : start + step
    if (start > end) {
      d = (start - step < end) ? end : start - step
    }

    if (el === window) {
      window.scrollTo(d, d)
    } else {
      el.scrollTop = d
    }
    window.requestAnimationFrame(() => scroll(d, end, step))
  }
  scroll(from, to, step)
}


export const getRules=(paramList : Array<any>) :any=>{
  let rule={};
  paramList.forEach(item=>{
    rule[item.key]=[{ required: true, message: "该项不能为空", trigger: item.triggerEvent }]
  })
  return rule;
}

export const formatTen=(val : any)=>{
  return val.toString().padStart(2,"0");
}

export const formatDate=(param : any)=>{
  let date = new Date(param);
  let year = date.getFullYear();
  let month=formatTen(date.getMonth()+1);
  let day=formatTen(date.getDate());
  return `${year}-${month}-${day}`;
}

export const formatDateTime = (date : any, fmt : any) => {
  if (/(y+)/.test(fmt)) {
    fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length))
  }
  let o = {
    'M+': date.getMonth() + 1,
    'd+': date.getDate(),
    'h+': date.getHours(),
    'm+': date.getMinutes(),
    's+': date.getSeconds()
  }
  for (let k in o) {
    if (new RegExp(`(${k})`).test(fmt)) {
      let str = o[k] + ''
      fmt = fmt.replace(RegExp.$1, RegExp.$1.length === 1 ? str : padLeftZero(str))
    }
  }
  return fmt
}

const padLeftZero = (str : any) => {
  return ('00' + str).substr(str.length)
}

export const getQueryUrl = (url:any) => { 
  return decodeURIComponent(url.substring(url.indexOf('?name=') + 6,url.length)) 
}