import { Message } from 'element-ui';
import router from '@/router';
import api from '@/api/api';
export default {
  // 获取应用权限
  checkAuth (appname,auth) {
    // await this.sleep(3000)
    let _haveAuth = false
    
    let app = JSON.parse(sessionStorage.getItem('activeApp'))
    // 获取当前应用权限
    let auth_list = app.meta.auth
    // 判断是否拥有权限
    _haveAuth = auth_list.some(item=>item.option === auth)
    
    return _haveAuth
  },

  // 获取应用表格
  tabelCol (appname) {
    try {
      // 获取应用数据
      let apps = JSON.parse(sessionStorage.getItem('active_modules'))
      
      let module_list =  apps.apps
      // 获取当前应用数据
      let active_modules = module_list.filter(item => {
        return item.name === appname
      })
      // 获取当前应用表格数据
      let tablecols = active_modules[0].meta.tables
      return tablecols
    } catch (error) {
      console.log(error,'tool')
    }
  },

  // 操作响应提示
  showMessage (res,success) {
    if (res.code === 0)  return Message({
      message: res.msg,
      type: 'error',
      duration:3000,
      showClose:true
    });

    Message({
      message: '操作成功',
      type: 'success',
      duration:3000,
      showClose:true
    });
    success?success():''
  },
  /* 获取基本地址 */
  getBaseUrl () {
    // if (process.env.NODE_ENV == 'development') return 'https://oms.idcgroup.com.cn:8079'
    // if (process.env.NODE_ENV == 'development') return '/apis'
    let href = window.location.href
    let index = href.indexOf('/')
    let num = 0
    while (index != -1) {
      num++
      index = href.indexOf('/',index+1)
      if (num++ == 3) {
        return href.slice(0,index)
      } 
    }
  },
  // 处理省市县数据结构
  createMenu (node) {
    var that = this
    let obj = Object.keys(node).map((key,index,item)=>{
      var elNode = {
        label: key,
        value: key,
        item:node[key],
      }
      return elNode;
    })
    obj.forEach(e=>{
      if ((e.item) instanceof Array) {
        e.children = []
        e.item.forEach(c=>{
          e.children.push({
            label:c,
            value:c
          })
        })
      } else {
        if (Object.keys(e.item).length !== 0) {
          e.children = that.createMenu(e.item)
        }
      }
    })
    return obj
  },

  // 导出excel
  exportExcel(a,b,c,d) {
    let formatJson = function(filterVal, jsonData) {
      return jsonData.map(v => filterVal.map(j => v[j]))
    }
    require.ensure([], () => {
      const { export_json_to_excel } = require('./excel/Export2Excel');
      const tHeader = a;  // 设置Excel的表格第一行的标题
      const filterVal = b;  // index、nickName、name是tableData里对象的属性
      const list = c;  //把data里的tableData存到list
      const data = formatJson(filterVal, list);
      export_json_to_excel(tHeader, data, d);  //导出Excel 文件名
    })
  },

  // 数组去重
  unique(arr, uniId){
    const res = new Map();
    return arr.filter((item) => !res.has(item[uniId]) && res.set(item[uniId], 1));
  },
  // 金额格式化
  formatAmount(amount, decimalDigits, unit='') {
    // const amountStr = String(Number(amount).toFixed(decimalDigits))
    let a = new Intl.NumberFormat(undefined, { minimumFractionDigits: decimalDigits, maximumFractionDigits: decimalDigits }).format(amount)
    const amountStr = String(a)
    const reg = /\B(?=(?:\d{3})+$)/g
    // 是否是小数
    const isDecimal = amountStr.indexOf('.') > -1
    if (isDecimal) {
       // 整数部分
       const integerPart = amountStr.substring(0, amountStr.indexOf('.'))
       // 小数部分
       const decimalPart = amountStr.substring(amountStr.length, amountStr.indexOf('.'))
       return unit + `${integerPart.replace(reg, ',')}${decimalPart}`
    } else {
      return  unit + amountStr.replace(reg, ',')
    }
  },
  /* 给指定组件触发$emit事件 */
  dispatchFun(componentName, eventName, vm) {
    var parent = vm.$parent || vm.$root;
    var name = parent.$options.componentName;

    while (parent && (!name || name !== componentName)) {
      parent = parent.$parent;

      if (parent) {
        name = parent.$options.componentName;
      }
    }
    if (parent) {
      parent.$emit.apply(parent, [eventName]);
    }
  },
  // 数组深度拷贝
  deepClone(obj) {
    let res = null;
    const reference = [Date, RegExp, Set, WeakSet, Map, WeakMap, Error];
    if (reference.includes(obj?.constructor)) {
        res = new obj.constructor(obj);
    } else if (Array.isArray(obj)) {
        res = [];
        obj.forEach((e, i) => {
            res[i] = this.deepClone(e);
        });
    } else if (typeof obj === "object" && obj !== null) {
        res = {};
        for (const key in obj) {
            if (Object.hasOwnProperty.call(obj, key)) {
                res[key] = this.deepClone(obj[key]);
            }
        }
    } else {
        res = obj;
    }
    return res;
  },
  // 数组排序
  sortArr (data,str) {
    let cache = {} // cache存储的键是eid，值是这个eid在indices数组中的下标
    let indices = [] // 数组中的每一个值是一个数组，数组中的每一个元素是原数组中相同eid的下标
    data.forEach((item, i) => {
      let eid = item[str]
      let index = cache[eid]
      if (index !== undefined) {
        indices[index].push(i)
      } else {
        cache[eid] = indices.length
        indices.push([i])
      }
    })
    let result = []
    indices.forEach(item => {
      item.forEach(index => {
        result.push(data[index]) // 依次把index对应的元素data[index]添加进去即可
      })
    })
    
    return result
  }
}