/* eslint-disable no-mixed-operators */
/* eslint-disable no-unused-expressions */
/* eslint-disable max-statements-per-line */
/* eslint-disable prefer-regex-literals */
/**
 * Created by PanJiaChen on 16/11/18.
 */

/**
 * Parse the time to string
 * @param {(Object|string|number)} time
 * @param {string} cFormat
 * @returns {string | null}
 */
export function parseTime(time: string | number | Date, cFormat: string) {
  if (arguments.length === 0 || !time) {
    return null
  }
  const format = cFormat || '{y}-{m}-{d} {h}:{i}:{s}'
  let date
  if (typeof time === 'object') {
    date = time
  }
  else {
    if ((typeof time === 'string')) {
      if ((/^[0-9]+$/.test(time))) {
        // support "1548221490638"
        time = parseInt(time)
      }
      else {
        // support safari
        // https://stackoverflow.com/questions/4310953/invalid-date-in-safari
        time = time.replace(new RegExp(/-/gm), '/')
      }
    }

    if ((typeof time === 'number') && (time.toString().length === 10)) {
      time = time * 1000
    }
    date = new Date(time)
  }
  const formatObj = {
    y: date.getFullYear(),
    m: date.getMonth() + 1,
    d: date.getDate(),
    h: date.getHours(),
    i: date.getMinutes(),
    s: date.getSeconds(),
    a: date.getDay(),
  }
  const time_str = format.replace(/{([ymdhisa])+}/g, (result: any, key: string) => {
    const value = formatObj[key as unknown as keyof typeof formatObj]
    // Note: getDay() returns 0 on Sunday
    if (key === 'a') { return ['日', '一', '二', '三', '四', '五', '六'][value] }
    return value.toString().padStart(2, '0')
  })
  return time_str
}

/**
   * @param {number} time
   * @param {string} option
   * @returns {string}
   */
export function formatTime(time: string | number | Date, option: any) {
  if ((`${time}`).length === 10) {
    time = parseInt(time.toString()) * 1000
  }
  else {
    time = +time
  }
  const d = new Date(time)
  const now = Date.now()

  const diff = (now - d.getTime()) / 1000

  if (diff < 30) {
    return '刚刚'
  }
  else if (diff < 3600) {
    // less 1 hour
    return `${Math.ceil(diff / 60)}分钟前`
  }
  else if (diff < 3600 * 24) {
    return `${Math.ceil(diff / 3600)}小时前`
  }
  else if (diff < 3600 * 24 * 2) {
    return '1天前'
  }
  if (option) {
    return parseTime(time, option)
  }
  else {
    return (
      `${d.getMonth()
        + 1
        }月${
        d.getDate()
        }日${
        d.getHours()
        }时${
        d.getMinutes()
        }分`
    )
  }
}

/**
   * @param {string} input value
   * @returns {number} output value
   */
export function byteLength(str: string) {
  // returns the byte length of an utf8 string
  let s = str.length
  for (let i = str.length - 1; i >= 0; i--) {
    const code = str.charCodeAt(i)
    if (code > 0x7F && code <= 0x7FF) { s++ }
    else if (code > 0x7FF && code <= 0xFFFF) { s += 2 }
    if (code >= 0xDC00 && code <= 0xDFFF) { i-- }
  }
  return s
}

/**
   * @param {Array} actual
   * @returns {Array}
   */
export function cleanArray(actual: string | any[]) {
  const newArray = []
  for (let i = 0; i < actual.length; i++) {
    if (actual[i]) {
      newArray.push(actual[i])
    }
  }
  return newArray
}

/**
   * @param {Object} json
   * @returns {Array}
   */
export function param(json: { [x: string]: string | number | boolean }) {
  if (!json) { return '' }
  return cleanArray(
    Object.keys(json).map((key) => {
      if (json[key] === undefined) { return '' }
      return `${encodeURIComponent(key)}=${encodeURIComponent(json[key])}`
    }),
  ).join('&')
}

/**
   * @param {string} url
   * @returns {Object}
   */
export function param2Obj(url: string) {
  interface Obj {
    name: String
  }
  const search = decodeURIComponent(url.split('?')[1]).replace(/\+/g, ' ')
  if (!search) {
    return {}
  }
  const obj = <Obj>({})
  const searchArr = search.split('&')
  searchArr.forEach((v) => {
    const index = v.indexOf('=')
    if (index !== -1) {
      const name = v.substring(0, index)
      const val = v.substring(index + 1, v.length)
      obj[name as unknown as keyof typeof obj] = val
    }
  })
  return obj
}

/**
   * @param {string} val
   * @returns {string}
   */
export function html2Text(val: string) {
  const div = document.createElement('div')
  div.innerHTML = val
  return div.textContent || div.innerText
}

/**
   * Merges two objects, giving the last one precedence
   * @param {Object} target
   * @param {(Object|Array)} source
   * @returns {Object}
   */
export function objectMerge(target: { [x: string]: any }, source: string | any[]) {
  if (typeof target !== 'object') {
    target = {}
  }
  if (Array.isArray(source)) {
    return source.slice()
  }
  Object.keys(source).forEach((property) => {
    const sourceProperty = source[property as unknown as keyof typeof source]
    if (typeof sourceProperty === 'object') {
      target[property] = objectMerge(target[property], sourceProperty)
    }
    else {
      target[property] = sourceProperty
    }
  })
  return target
}

/**
   * @param {HTMLElement} element
   * @param {string} className
   */
export function toggleClass(element: { className: any }, className: string | any[]) {
  if (!element || !className) {
    return
  }
  let classString = element.className
  const nameIndex = classString.indexOf(className)
  if (nameIndex === -1) {
    classString += `${className}`
  }
  else {
    classString
        = classString.substr(0, nameIndex)
        + classString.substr(nameIndex + className.length)
  }
  element.className = classString
}

/**
   * @param {string} type
   * @returns {Date}
   */
export function getTime(type: string) {
  if (type === 'start') {
    return new Date().getTime() - 3600 * 1000 * 24 * 90
  }
  else {
    return new Date(new Date().toDateString())
  }
}

/**
   * @param {Function} func
   * @param {number} wait
   * @param {boolean} immediate
   * @return {*}
   */

/**
   * @param {Array} arr
   * @returns {Array}
   */
export function uniqueArr(arr: Iterable<unknown> | null | undefined) {
  return Array.from(new Set(arr))
}

/**
   * @returns {string}
   */
export function createUniqueString() {
  const timestamp = `${+new Date()}`
  const randomNum = parseInt(((1 + Math.random()) * 6553).toString())
  return (+(randomNum + timestamp)).toString(32)
}

/**
   * Check if an element has a class
   * @param {HTMLElement} elm
   * @param {string} cls
   * @returns {boolean}
   */
export function hasClass(ele: { className: string }, cls: any) {
  return !!ele.className.match(new RegExp(`(\\s|^)${cls}(\\s|$)`))
}

/**
   * Add class to element
   * @param {HTMLElement} elm
   * @param {string} cls
   */
export function addClass(ele: { className: string }, cls: any) {
  if (!hasClass(ele, cls)) { ele.className += ` ${cls}` }
}

/**
   * Remove class from element
   * @param {HTMLElement} elm
   * @param {string} cls
   */
export function removeClass(ele: { className: string }, cls: any) {
  if (hasClass(ele, cls)) {
    const reg = new RegExp(`(\\s|^)${cls}(\\s|$)`)
    ele.className = ele.className.replace(reg, ' ')
  }
}

export function strArr2NumArr(actual: string | any[]) {
  const newArray = []
  for (let i = 0; i < actual.length; i++) {
    if (actual[i]) {
      newArray.push(parseInt(actual[i]))
    }
  }
  return newArray
}

// 格式化日期：yyyy-MM-dd
export function formatDate(date: Date) {
  const myyear = date.getFullYear()
  const mymonth = date.getMonth() + 1
  const myweekday = date.getDate()
  let _mymonth
  let _myweekday
  if (mymonth < 10) {
    _mymonth = `0${mymonth}`
  }
  if (myweekday < 10) {
    _myweekday = `0${myweekday}`
  }
  return (`${myyear}-${_mymonth}-${_myweekday}`)
}

// 获得某月的天数
export function getMonthDays(myMonth: number) {
  const now = new Date() // 当前日期
  const nowYear = now.getFullYear() // 当前年
  const monthStartDate = new Date(nowYear, myMonth, 1).getTime()
  const monthEndDate = new Date(nowYear, myMonth + 1, 1).getTime()
  const days = (monthEndDate - monthStartDate) / (1000 * 60 * 60 * 24)
  return days
}

// 获得本季度的开始月份
export function getQuarterStartMonth() {
  const now = new Date() // 当前日期
  const nowMonth = now.getMonth() // 当前月
  let quarterStartMonth = 0
  if (nowMonth < 3) {
    quarterStartMonth = 0
  }
  if (nowMonth > 2 && nowMonth < 6) {
    quarterStartMonth = 3
  }
  if (nowMonth > 5 && nowMonth < 9) {
    quarterStartMonth = 6
  }
  if (nowMonth > 8) {
    quarterStartMonth = 9
  }
  return quarterStartMonth
}

//  获得本周的开始日期
export function getWeekStartDate() {
  const now = new Date() // 当前日期
  const nowDay = now.getDate() // 当前日
  const nowDayOfWeek = now.getDay() - 1 // 今天本周的第几天
  const nowMonth = now.getMonth()
  const nowYear = now.getFullYear() // 当前年
  const weekStartDate = new Date(nowYear, nowMonth, nowDay - nowDayOfWeek)
  return formatDate(weekStartDate)
}

//  获得本周的结束日期
export function getWeekEndDate() {
  const now = new Date() // 当前日期
  const nowDay = now.getDate() // 当前日
  const nowMonth = now.getMonth() // 当前月
  const nowYear = now.getFullYear() // 当前年
  const nowDayOfWeek = now.getDay() - 1 // 今天本周的第几天
  const weekEndDate = new Date(nowYear, nowMonth, nowDay + (6 - nowDayOfWeek))
  return formatDate(weekEndDate)
}

//  获得上周的开始日期
export function getLastWeekStartDate() {
  const now = new Date() // 当前日期
  const nowDay = now.getDate() // 当前日
  const nowMonth = now.getMonth() // 当前月
  const nowYear = now.getFullYear() // 当前年
  const nowDayOfWeek = now.getDay() - 1 // 今天本周的第几天
  const weekStartDate = new Date(nowYear, nowMonth, nowDay - nowDayOfWeek - 7)
  return formatDate(weekStartDate)
}

// 获得上周的结束日期
export function getLastWeekEndDate() {
  const now = new Date() // 当前日期
  const nowDay = now.getDate() // 当前日
  const nowMonth = now.getMonth() // 当前月
  const nowYear = now.getFullYear() // 当前年
  const nowDayOfWeek = now.getDay() - 1 // 今天本周的第几天
  const weekEndDate = new Date(nowYear, nowMonth, nowDay - nowDayOfWeek - 1)
  return formatDate(weekEndDate)
}

// 获得本月的开始日期
export function getMonthStartDate() {
  const now = new Date() // 当前日期
  const nowMonth = now.getMonth() // 当前月
  const nowYear = now.getFullYear() // 当前年
  const monthStartDate = new Date(nowYear, nowMonth, 1)
  return formatDate(monthStartDate)
}
// 获得本月的结束日期
export function getMonthEndDate() {
  const now = new Date() // 当前日期
  const nowMonth = now.getMonth() // 当前月
  const nowYear = now.getFullYear() // 当前年
  const monthEndDate = new Date(nowYear, nowMonth, getMonthDays(nowMonth))

  return formatDate(monthEndDate)
}

// 获得本年的开始日期
export function getYearStartDate() {
  const now = new Date() // 当前日期
  const nowYear = now.getFullYear() // 当前年
  const monthStartDate = new Date(nowYear, 1, 1)
  return formatDate(monthStartDate)
}
// 获得本年的结束日期
export function getYearEndDate() {
  const now = new Date() // 当前日期
  const nowYear = now.getFullYear() // 当前年
  const yarEndDate = new Date(nowYear, 11, 31)
  return formatDate(yarEndDate)
}

// 获得上月开始时间
export function getLastMonthStartDate() {
  const now = new Date() // 当前日期
  const nowYear = now.getFullYear() // 当前年
  const nowMonth = now.getMonth() // 当前月
  let lastMonthStartDate
  if (nowMonth === 0) {
    lastMonthStartDate = new Date(nowYear - 1, 12, 1)
  }
  else {
    lastMonthStartDate = new Date(nowYear, nowMonth - 1, 1)
  }
  return formatDate(lastMonthStartDate)
}
// 获得上月结束时间
export function getLastMonthEndDate() {
  const now = new Date() // 当前日期
  const nowMonth = now.getMonth() // 当前月
  const nowYear = now.getFullYear() // 当前年

  let lastMonthEndDate
  if (nowMonth === 0) {
    lastMonthEndDate = new Date(nowYear - 1, 12, 31)
  }
  else {
    lastMonthEndDate = new Date(nowYear, nowMonth - 1, getMonthDays(nowMonth - 1))
  }
  return formatDate(lastMonthEndDate)
}

// 获得本季度的开始日期
export function getQuarterStartDate() {
  const now = new Date() // 当前日期
  const nowYear = now.getFullYear() // 当前年
  const quarterStartDate = new Date(nowYear, getQuarterStartMonth(), 1)
  return formatDate(quarterStartDate)
}
// 或的本季度的结束日期
export function getQuarterEndDate() {
  const now = new Date() // 当前日期
  const nowYear = now.getFullYear() // 当前年
  const quarterEndMonth = getQuarterStartMonth() + 2
  const quarterStartDate = new Date(nowYear, quarterEndMonth, getMonthDays(quarterEndMonth))
  return formatDate(quarterStartDate)
}
// 平级转树结构
/* treeArr 基础数据
   * id 唯一id
   * parentId 父级id
   * childrenList 子级数组名 */
export function packageTreeData(params: { data: any; id?: any; parentId?: any; children?: any }) {
  const treeArr = params && params.data || []
  const id = params && params.id || 'id'
  const parentId = params && params.parentId || 'parentId'
  const childrenList = params && params.children || 'children'
  const cloneData = JSON.parse(JSON.stringify(treeArr))
  return cloneData.filter((fatherItem: { [x: string]: any }) => {
    const warpArr = cloneData.filter((sonItem: { [x: string]: any }) => fatherItem[id] === sonItem[parentId])
    warpArr.length ? fatherItem[childrenList] = warpArr : null
    return !fatherItem[parentId]
  })
}
// 根据根id处理树结构
export function getNestedChildren(arr: any = [], parent_id = 'parent_id', id = 'id', parent: any = 0) {
  const res: any[] = []
  for (const item of arr) {
    if (item[parent_id] === parent) {
      const children = getNestedChildren(arr, item[id])
      if (children.length) {
        item.children = children
      }
      res.push(item)
    }
  }
  return res
}

// 风险类型
export function riskType(val: string | number) {
  const strs = [
    '默认',
    '人',
    '物',
    '管',
  ]
  return strs[val as unknown as keyof typeof strs]
}

// 风险等级
export function riskLevel(val: string | number) {
  const strs = [
    '默认',
    '重大',
    '较大',
    '一般',
    '较小',
  ]
  return strs[val as unknown as keyof typeof strs]
}

// 风险等级
export function riskPointStatus(val: string | number) {
  const strs = [
    '未知',
    '安全受控',
    '失控',
  ]
  return strs[val as unknown as keyof typeof strs]
}

// 风险点等级
export function riskPointLevel(val: string | number) {
  const strs = [
    '默认',
    '重大',
    '较大',
    '一般',
    '较小',
  ]
  return strs[val as unknown as keyof typeof strs]
}

export function taskPriority(i: string | number) {
  const strs = [
    '未知',
    '较低',
    '普通',
    '紧急',
    '非常紧急',
  ]
  return strs[i as unknown as keyof typeof strs]
}

export function taskType(i: string | number) {
  const strs = [
    '未知',
    '常规',
    '临时',
    '立即',
  ]
  return strs[i as unknown as keyof typeof strs]
}

export function taskStatus(i: number) {
  const strs = [
    '待处理',
    '已完成',
  ]
  if (i === -1) {
    return '已撤消'
  }
  else {
    return strs[i]
  }
}

export function checkResult(i: string | number) {
  const strs = [
    '没执行',
    '通过',
    '没通过',
    '有隐患',
    '已完成',
  ]
  return strs[i as unknown as keyof typeof strs]
}

export function dangerStatus(i: number) {
  if (i >= 0) {
    const strs = [
      '未开始',
      '处理中',
      '已完成',
    ]
    return strs[i]
  }
  else {
    return '已撤销'
  }
}

export function dangerLevel(i: string | number) {
  const strs = [
    '未知',
    '一般隐患',
    '重大隐患',
  ]
  return strs[i as unknown as keyof typeof strs]
}

export function dangerSource(i: string | number) {
  const strs = [
    '自查',
    '内部反馈',
    '上级抽查',
    '政府执法',
  ]
  return strs[i as unknown as keyof typeof strs]
}

export function rectifyCat(i: string | number) {
  const strs = [
    '自行整改',
    '外协整改',
  ]
  return strs[i as unknown as keyof typeof strs]
}

export function wfInsStatus(i: number) {
  if (i >= 0) {
    const strs = [
      '未开始',
      '执行中',
      '已完成',
    ]
    return strs[i]
  }
  else {
    return '已撤销'
  }
}

export function wfActivityInsStatus(i: string | number) {
  const strs = [
    '未开始',
    '已完成',
  ]
  return strs[i as unknown as keyof typeof strs]
}

export function dangerRectifyCat(i: string | number) {
  const strs = [
    '自行整改',
    '外协整改',
  ]
  return strs[i as unknown as keyof typeof strs]
}

export function alertLevel(i: string | number) {
  const strs = [
    '未知',
    '1级',
    '2级',
    '3级',
    '4级',
    '5级',
    '6级',
  ]
  return strs[i as unknown as keyof typeof strs]
}

export function alertStatus(i: number) {
  if (i >= 0) {
    const strs = [
      '未知',
      '待处理',
      '已处理',
    ]
    return strs[i]
  }
  else {
    return '已撤销'
  }
}
export function hosStoryTitle(i: number) {
  if (i >= 0) {
    const strs = [
      '未知',
      '平安医院',
      '质量医院',
      '满意医院',
      '智慧医院',
      '健康医院',
      '节约型医院',
    ]
    return strs[i]
  }
  else {
    return '未知'
  }
}

export function hosStory(code: string | number) {
  const enums = {
    pingAn: 1,
    zhiLiang: 2,
    manYi: 3,
    zhiHui: 4,
    jianKang: 5,
    jieYue: 6,
  }
  return enums[code as unknown as keyof typeof enums]
}

export function ocAccess(i: string | number) {
  const strs = [
    '未接入',
    '已接入',
  ]
  return strs[i as unknown as keyof typeof strs]
}