// 数组工具方法
export const forEach = (arr, fn) => {
  if (!arr.length || !fn) return
  let i = -1
  let len = arr.length
  while (++i < len) {
    let item = arr[i]
    fn(item, i, arr)
  }
}

export const reverse = (arr) => {
  let arrResult = []
  let j = 0
  for (let i = arr.length - 1; i >= 0; i--, j++) {
    arrResult[j] = arr[i]
  }
  return arrResult
}

import dayjs from 'dayjs'
import Cookies from 'js-cookie'

export const getIntersection = (arr1, arr2) => {
  let len = Math.min(arr1.length, arr2.length)
  let i = -1
  let res = []
  while (++i < len) {
    const item = arr2[i]
    if (arr1.indexOf(item) > -1) res.push(item)
  }
  return res
}

export const getUnion = (arr1, arr2) => {
  return Array.from(new Set([...arr1, ...arr2]))
}

export const hasOneOf = (targetarr, arr) => {
  return targetarr.some(_ => arr.indexOf(_) > -1)
}

export function oneOf(value, validList) {
  for (let i = 0; i < validList.length; i++) {
    if (value === validList[i]) {
      return true
    }
  }
  return false
}

export const hasKey = (obj, key) => {
  if (key) return key in obj
  else {
    let keysArr = Object.keys(obj)
    return keysArr.length
  }
}

// 对象工具方法
export const objEqual = (obj1, obj2) => {
  const keysArr1 = Object.keys(obj1)
  const keysArr2 = Object.keys(obj2)
  if (keysArr1.length !== keysArr2.length) return false
  else if (keysArr1.length === 0 && keysArr2.length === 0) return true
  else return !keysArr1.some(key => obj1[key] !== obj2[key])
}

export const isObjectEqual = (a, b) => {
  let isEqual = true
  for (var key in a) {
    if (a[key] !== b[key]) {
      isEqual = false
      break
    }
  }
  return isEqual
}

// 文件下载工具方法
export const downStream = res => {
  const fileName = new Date().getTime() + '.xlsx'
  let blob = new Blob([res.data])
  let downloadElement = document.createElement('a')
  let href = window.URL.createObjectURL(blob)
  downloadElement.href = href
  downloadElement.download = fileName
  document.body.appendChild(downloadElement)
  downloadElement.click()
  document.body.removeChild(downloadElement)
  window.URL.revokeObjectURL(href)
}

export const downloadImg = (url, name) => {
  const aLink = document.createElement('a')
  aLink.download = name
  aLink.href = url
  aLink.dispatchEvent(new MouseEvent('click', {}))
}

// 数据验证工具方法
export const isNullorEmpty = (obj) => {
  if (typeof obj === 'undefined' || obj == null || obj === '') {
    return true
  }
  return false
}

export const removeEmptyObject = (data) => {
  data = data || {}
  for (let index in data) {
    if (data[index] === '' || data[index] === '全部') {
      delete data[index]
    }
  }
  return data
}

// 随机数生成工具方法
export const generateUUID = () => {
  var d = new Date().getTime()
  if (window.performance && typeof window.performance.now === 'function') {
    d += performance.now()
  }
  var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(
    /[xy]/g,
    function(c) {
      var r = (d + Math.random() * 16) % 16 | 0
      d = Math.floor(d / 16)
      return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16)
    }
  )
  return uuid
}

export const createCode = (codeLength = 4) => {
  var code = ''
  var random = '[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]'
  random = JSON.parse(random)
  for (var i = 0; i < codeLength; i++) {
    var index = Math.floor(Math.random() * 36)
    code += random[index]
  }
  return code
}

export const getRandomNum = (minNum, maxNum) => {
  switch (arguments.length) {
    case 1:
      return parseInt(Math.random() * minNum + 1, 10)
    case 2:
      return parseInt(Math.random() * (maxNum - minNum + 1) + minNum, 10)
    default:
      return 0
  }
}

// 数据转换工具方法
export const toJson = (data) => {
  return JSON.parse(JSON.stringify(data))
}

// Cookie 工具方法
export const setCookie = (name, value) => {
  var exdate = new Date()
  var expiredays = 7
  exdate.setDate(exdate.getDate() + expiredays)
  document.cookie =
    name +
    '=' +
    escape(value) +
    (expiredays == null ? '' : ';expires=' + exdate.toGMTString())
}

export const getCookie = (name) => {
  if (document.cookie.length > 0) {
    var c_start = document.cookie.indexOf(name + '=')
    if (c_start !== -1) {
      c_start = c_start + name.length + 1
      var c_end = document.cookie.indexOf(';', c_start)
      if (c_end === -1) c_end = document.cookie.length
      return unescape(document.cookie.substring(c_start, c_end))
    }
  }
  return ''
}

// 日期格式化工具方法
export const formatDate = (val, fmt) => {
  val = val || new Date()
  if (!isNullorEmpty(val)) {
    fmt = fmt || 'YYYY-MM-DD'
    if (!val.getDate) {
      val = new Date(val)
    }
    var date = dayjs(val).format(fmt)
    return date
  }
  return val
}

// 组件高度计算工具方法
export const getComponentHeight = (diffHegiht) => {
  let curBodyHeight = document.documentElement.clientHeight
  let height = curBodyHeight - diffHegiht
  return height
}

// URL 参数获取工具方法
export const getUrlParam = (key) => {
  var index = window.location.href.indexOf('?') + 1
  var reg = new RegExp('(^|&)' + key + '=([^&]*)(&|$)')
  var r = window.location.href.substr(index).match(reg)
  if (r != null) return unescape(r[2])
  return null
}

// 日期验证工具方法
export const isDate = (date) => {
  var reDateTime = /^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2})$/
  var isDateTime = reDateTime.test(date)
  return isDateTime
}

// 安全检查字符串工具方法
export const getCheckString = (value) => {
  let curTemp = !isNullorEmpty(value) ? value : ''
  return curTemp
}

// Token 管理工具方法
export const TOKEN_KEY = 'token'
export const MENU_KEY = 'authoritymenu'

export const setToken = (token, cookieExpires = 7) => {
  Cookies.set(TOKEN_KEY, token, {
    expires: cookieExpires
  })
}

export const getToken = () => {
  const token = Cookies.get(TOKEN_KEY)
  if (token) return token
  else return false
}

// 路由和菜单工具方法
export const hasChild = item => {
  return item.children && item.children.length !== 0
}

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

export const getMenuByRouter = (list, access) => {
  let res = []
  forEach(list, item => {
    if (!item.meta || (item.meta && !item.meta.hideInMenu)) {
      let obj = {
        icon: (item.meta && item.meta.icon) || '',
        name: item.name,
        meta: item.meta
      }
      if (
        (hasChild(item) || (item.meta && item.meta.showAlways)) &&
        showThisMenuEle(item, access)
      ) {
        obj.children = getMenuByRouter(item.children, access)
      }
      if (item.meta && item.meta.href) obj.href = item.meta.href
      if (showThisMenuEle(item, access)) res.push(obj)
    }
  })
  return res
}

export const getBreadCrumbList = (route, homeRoute) => {
  let routeMetched = route.matched

  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
      }

      if (item.name === homeRoute.name) {
        obj.to = homeRoute.path
      }
      return obj
    })

  res = res.filter(item => {
    return !item.meta.hideInMenu
  })

  res.splice(0, 1)

  return [...res]
}

export const getRouteTitleHandled = route => {
  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 showTitle = (item, vm) => {
  let title = item.name
  if (!title) return
  return title
}

export const setTagNavListInLocalstorage = list => {
  localStorage.tagNaveList = JSON.stringify(list)
}

export const getTagNavListFromLocalstorage = () => {
  const list = localStorage.tagNaveList
  return list ? JSON.parse(list) : []
}

export const getHomeRoute = (routers, homeName = 'home') => {
  let homeRoute = routers.find(item => {
    return item.name === homeName
  })
  if (homeRoute) {
    delete homeRoute.children
    delete homeRoute.component
  }
  return homeRoute || {}
}

export const getNewTagList = (list, newRoute) => {
  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
}

const hasAccess = (access, route) => {
  if (route.meta && route.meta.access)
    return hasOneOf(access, route.meta.access)
  else return true
}

export const canTurnTo = (name, access, routes) => {
  const routePermissionJudge = list => {
    return list.some(item => {
      if (item.children && item.children.length) {
        return routePermissionJudge(item.children)
      } else if (item.name === name) {
        return hasAccess(access, item)
      }
    })
  }

  return routePermissionJudge(routes)
}

export const getParams = url => {
  const keyValueArr = url.split('?')[1].split('&')
  let paramObj = {}
  keyValueArr.forEach(item => {
    const keyValue = item.split('=')
    paramObj[keyValue[0]] = keyValue[1]
  })
  return paramObj
}

export const getNextRoute = (list, route) => {
  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 routeEqual = (route1, route2) => {
  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)
  )
}

export const localSave = (key, value) => {
  localStorage.setItem(key, value)
}

export const localRead = key => {
  return localStorage.getItem(key) || ''
}

export const filterMenu = menu => {
  if (menu && menu.length > 0) {
    menu = menu.filter(p => {
      return !(p.meta && p.meta.isMenu === false)
    })
    menu.forEach(p => {
      if (p.children && p.children.length > 0) {
        p.children = filterMenu(p.children)
      }
    })
    return menu
  }
  return menu
}

// DOM 操作工具方法
export const findNodeUpperByClasses = (ele, classes) => {
  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)
    }
  }
}

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

  function scroll (start, end, step) {
    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 on = (element, event, handler) => {
  if (element && event && handler) {
    element.addEventListener(event, handler, false)
  }
}

export const off = (element, event, handler) => {
  if (element && event && handler) {
    element.removeEventListener(event, handler, false)
  }
}