import api from '@/api'
import router from '../router'
import { Message } from 'element-ui'
export default {
  /**
   * 防抖
   * @param {Function} func 
   * @param {Number} duration 
   * @returns 
   */
  debounce(func, duration = 500) {
    let timer;
    return () => {
      clearTimeout(timer)
      timer = setTimeout(func, duration)
    }
  },
  /**
   * 节流
   * @param {Function} func 
   * @param {Number} delay 
   * @returns 
   */
  throttle(func, delay = 2000) {
    let flag = true
    return () => {
      if (!flag) return;
      flag = false;
      setTimeout(() => {
        func()
        flag = true
      }, delay)
    }
  },
  //对象转数组
  objectToArray(val){
    var data = []
    if (Object.keys(val).length > 0) {
      Object.keys(val).forEach(item => {
        if(val[item]){
          data.push(
            {
              key: item,
              value: val[item]
            }
          )
        }
        
      })
    } else {
      return []
    }
    return data
  },
  //转简单数组
  ArrayToArray(data){
    var arr = []
    data.forEach(item => {
      if (item.type == 3) {
        arr.push({
          key:item.value,
          value:item.searchValue.map(itemValue => {
            return itemValue.value
          })
        })
      } else {
        arr.push({
          key:item.value,
          value:item.searchValue.label
        })
      }
    })
    return arr
  },
  //object转字符串
  objectToString(val) {
    var data = []
    if (val.constructor == Object) {
      if (Object.keys(val).length > 0) {
        Object.keys(val).forEach(item => {
          data.push(
            {
              key: item,
              value: val[item]
            }
          )
        })
      } else {
        return ''
      }
    } else if (val.constructor == Array) {
      if (val.length > 0) {
        data = val
      } else {
        return ''
      }
    } else {
      return val
    }
    // 生成字符串
    var str = ''
    data.forEach(item => {
      var value = ''
      if (Array.isArray(item.value)) {
        value = '(' + item.value.join(' OR ') + ')'
      } else {
        if (item.value) {
          value = item.value
        } else {
          return
        }
      }
      if (str) {
        str = str + ' AND ' + item.key + '=' + value
      } else {
        str = str + item.key + '=' + value
      }

    })
    return str
  },

  /**
   * 获取字段列表
   * @param {Array} array 
   * @param {Function} fun 
   * @param {Object} props 
   * @returns 
   */
  getField(array, fun, props) {
    var type = {
      'Array': '3',
      'DateTime': '2',
      'String': '1'
    }

    //获取规范数据
    var keys = []
    var arr = []
    if (props) {
      keys = Object.keys(props)
    }
    //获取所需要的数据
    var newArray = array.filter(item => {
      return fun(item)
    })
    if (keys.length > 0) {
      newArray.forEach(item => {
        var obj = {}
        keys.forEach(key => {
          if (key == 'type') {
            obj[key] = type[item[props[key]]] || item[props[key]]
          }else if(key == 'value' && props.value == 'value'){
            obj[key] = item.field
          }else{
            obj[key] = item[props[key]]
          }

        })
        // 过滤不需要的数据
        if (['id'].includes(obj.value) == false) {
          arr.push(obj)
        }
      })
      return arr;
    }
    return newArray
  },

  /**
   * 获取表格数据
   * @author zhuliu
   * @param {object} row 当前行数据
   * @param {object} field 对应的栏位
   * @param {String} prop 数据类型为数组对象时所需要使用的字段
   * @param {object} data 需要获取对应label值时的字典对象（包含数据以及配置及{data,prop}）
   * @param {object} data.prop
   * @return {String} 返回值
   * @example
   * getColumnData({value:1},{type:'String',value:'value'}) //返回字符串1 
   */
  getColumnData(row, field, prop, data) {
    if (field.type == 'Array') {
      if (row[field.value] && row[field.value].length > 0) {
        if (prop) {
          return row[field.value].map(item => {
            return item[prop]
          }).join('、')
        }
        return row[field.value].join('、')
      } else {
        return '--'
      }
    } else if (field.type == 'Object') {
      if (!row[field.value]) {
        return '--'
      }
      if (prop) {
        return row[field.value][prop]
      }
      return row[field.value].name
    }
    else {
      if (data) {
        if (data.data.constructor == Array) {
          var dataProp = data.prop || {
            label: 'label',
            value: 'value'
          }
          var obj = data.data.find(item => {
            return item[dataProp.value] == row[field.value]
          })
          if (obj) {
            return obj[dataProp.label]
          } else {
            return '--'
          }
        } else {
          return data.data[row[field.value]]
        }

      }
      if (row[field.value] == '0') {
        return '0'
      }
      return row[field.value] || '--'
    }
  },

  //查看图片
  checkViewer(guid) {
    if(!guid){
      return ''
    }
    return `/api/fileManager/downloadFile?fileId=${guid}`
  },

   //查看专利详情
   checkPatentDetails(patentNo,projectId) {
      router.push(
        {
          path: '/patentDetails/' + patentNo,
          query: {
            projectId: projectId,
          }
        }
      )
  },

  //查看显示栏位管理
  async getCustomField(type, patentObj = {}) {
    var params = {
      tableName: type,
      ...patentObj,
    }
    let apiItem = Object.keys(patentObj).length > 0 ? 'getTableColumns':'getCustomField'
    var a = []
    await api[apiItem](params).then((response) => {
      if (response.code == 200) {
        a = response.data.data
      }
    }).catch(error => {
      return []
    });
    return a
  },


  /**
   * 获取排序字段(sortProp:{order})
   * @param {Object} param0 {sort,column, prop, order,sortProp,defaultValue,multiple}
   * @returns 
   */
  getSortData({ sort, column, prop, order, sortProp, defaultValue, multiple }) {
    var sortProp1 = sortProp || {
      "orderBy": "orderBy",
      "orderType": 'orderType'
    }
    if (multiple) {
      var sortData = sort
    } else {
      var sortData = []
    }
    if (order == null) {
      if (defaultValue) {
        this.sort = [defaultValue]
      }
      this.sort = [
        {
          "orderBy": "createTime",
          "orderType": 1
        }
      ]
    } else {
      var orderType = {
        ascending: 0,
        descending: 1
      }
      var params = sortData.find(item => {
        return item[sortProp1.orderBy] == prop
      })
      if (params) {
        params[sortProp1.orderType] = orderType[order]
      } else {
        params = {}
        params[sortProp1.orderBy] = prop
        params[sortProp1.orderType] = orderType[order]
        sortData.push(params)
      }
    }
    return sortData
  },

  //显示表头数据
  renderHeaderMethods(h, { column }, message) {
    var message = '点击升序'
    switch (column.order) {
      case "":
        message = '点击升序'
        break;
      case "ascending":
        message = '点击降序'
        break;
      case 'descending':
        message = '点击取消排序'
        break
    }
    return [
      ,
      h(
        'el-tooltip',
        {
          props: {
            content: message, // 鼠标悬停时要展示的文字提示
            placement: 'top' // 悬停内容展示的位置
          }
        },
        [h('span', column.label)] // 图标
      )
    ]
  },

  /**
   * 跳转到导入专利界面
   * @param {Object} data 参数
   * @param {*} type 导入类型
   */
  toImportParent(data, type) {
    var types = {
      1: '/import',
      2: '/PatentNoImport',
      4: '/conditionImport'
    }
    router.push(
      {
        path: types[type],
        query: {
          ...data
        }
      }
    )
  },
  // 校验文件是否全部上传并处理文件的guid
  allUploadFile(form) {
    var arr =[]
    let allUpload = this.validFile(form.systemFileList,arr)
    if (allUpload) {
      Message.warning('文件未全部上传，请耐心等待')
      return false
    }
    if(form.systemFileList && form.systemFileList.length>0){
      form.fileGuids = form.systemFileList.map(item => {
        return item.guid
      })
    }else{
      form.fileGuids = []
    }
    
  },
  //校验文件是否全部上传
  validFile(data,arr) {
    if (data && data.length > 0) {
      for(var i =0;i<data.length;i++){
        if(data[i] && data[i].guid){
          arr.push(data[i].guid)
        }else{
          return true
        }
      }
      return false
    } else {
      return false
    }
  },
  //校验是否全部上传
  checkUploadFile(data) {
    if(!data){
      return []
    }
    var arr = []
    let allUpload = this.validFile(data,arr)
    if (allUpload) {
      Message.warning('文件未全部上传，请耐心等待')
      return false
    }

    return arr
  },
}
