const TokenKey = 'A-Token'
const UserIdKey = 'userData'
const EmployeelistKey='employeeList'
const DeptTreeKeu='deptTree'
import Vue from 'vue'
/* 角色*/
/*
创始人 creator
主管理员 masterAdministrator
子管理员 childAdministrator
部门管理员 deptManager
员工 employee

权限
1   绩效考核
2   OKR
3   管理范围 全公司
4   管理范围 所在部门以及下级部门
5   管理范围 特定部门
6   考核管理 可见考核结果
7   考核管理 发起考核
8   考核管理 开始评分
9   考核管理 调整结果
10  考核管理 等级配置
11  考核管理 导出报表
12  指标库管理
13  指定考核表管理
14  全部考核表管理
15  基础设置
16  绩效报表
17  批量转交
18  批量修改目标
*/

// 获取当前登录者在绩效系统中的身份
export function getRole(type) {
  /* type为判断哪些角色*/
  var role = JSON.parse(localStorage.getItem('role'))
  let is = false
  switch (type) {
    case 1: // 判断是否是主,子管理员
      if (role == 'masterAdministrator' || role == 'childAdministrator') {
        is = true
      }
      break
    case 2: // 判断是否是部门管理员
      if (role == 'deptManager') {
        is = true
      }
      break
    case 3: // 判断是否是员工
      if (role == 'employee') {
        is = true
      }
      break
    case 4: // 判断是否是创始人
      if (role == 'creator') {
        is = true
      }
      break
  }
	return is
}
// 获取当前用户详情
export function getUserData() {
  return getCache(UserIdKey)||{}
}
export function setUserData(data) {
  return setCache(UserIdKey,data)
}
// 获取用户列表
export function getEmployeeList() {
  return getCache(EmployeelistKey)||{}
}
export function setEmployeeList(data) {
  return setCache(EmployeelistKey,data)
}
// 获取部门列表
export function getDeptTree() {
  return getCache(DeptTreeKeu)||{}
}
export function setDeptTree(data) {
  return setCache(DeptTreeKeu,data)
}

//返回用户Code
export function returnCode(data) {
	let list=getEmployeeList();
	if(!list||!data){
		return data
	}
	if(Array.isArray(data)){
		let result =data.map(e=>{
			if(list[e]){
				return list[e].code
			}
		})
		console.log(JSON.stringify(result))
		return JSON.stringify(result)
	}else{
		data=data.toString()
		var arr = data.split(",");
		let result =arr.map(e=>{
			if(list[e]){
				return list[e].code
			}
		})
		return result.toString()
	}
}

// 判断是否有绩效的某项权限
export function isAuthoritys(id, arr) { // 判断是否为某项权限：id为权限ID，arr为数据源
  var jurisdictions
  if (arr) {
    jurisdictions = arr.map((item) => {
      return item.id
    })
  } else {
    jurisdictions = getUserData().permission_info.permission.map((item) => {
      return item.id
    })
  }
  if (typeof(id) === 'number') { // 单个权限
    return jurisdictions.indexOf(id) >= 0
  } else { // 多个权限一起判断，如果有一个真就返回真
    const is = jurisdictions.some(item => {
      if (id.indexOf(item) >= 0) {
        return true
      }
    })
    return is
  }
}

// 考核表类型设置
export function getCycleType(id) {
  const options = [{
      value: 0,
      label: '全部'
    },
    {
      value: 2,
      label: '月度'
    },
    {
      value: 3,
      label: '季度'
    },
    {
      value: 4,
      label: '半年度'
    },
    {
      value: 5,
      label: '年度'
    },
    {
      value: 1,
      label: '天'
    },
    {
      value: 6,
      label: '自定义'
    }
  ]
  if (id) {
    let str = ''
    options.forEach(item => {
      if (id == item.value) {
        str = item.label
      }
    })
    return str
  } else {
    return options
  }
}

// 获取唯一标识（uid）
export function generateUUID() {
	var d = new Date().getTime();
	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 function getCache(key) {
	return JSON.parse(localStorage.getItem(key))
}
// 设置缓存
export function setCache(key, data) {
	localStorage.setItem(key, JSON.stringify(data))
}
// 清除缓存
export function removeCache(key) {
	localStorage.removeItem(key)
}
//判断数据类型
export function getClass(o) {
	return Object.prototype.toString.call(o).slice(8, -1);
}
//深度拷贝对象
export function deepCopy(obj = {}, map = new Map()) {
	if (typeof obj !== "object") {
		return obj;
	}
	if (map.get(obj)) {
		return map.get(obj);
	}
	let result = {};
	// 初始化返回结果
	// 加 || 的原因是为了防止 Array 的 prototype 被重写，Array.isArray 也是如此
	if (obj instanceof Array ||Object.prototype.toString(obj) === "[object Array]") {
		result = [];
	}
	// 防止循环引用
	map.set(obj, result);
	for (const key in obj) {
		// 保证 key 不是原型属性
		if (obj.hasOwnProperty(key)) {
			// 递归调用
			result[key] = deepClone(obj[key], map);
		}
	}
	// 返回结果
	return result;
}

// 判断是否创始人
export function getIsCreator(key) {
	return key==JSON.parse(localStorage.getItem('role'))
}
export function supremeAuthority() { 
	if (getIsCreator('creator')) {
		return 'creator'
	} else if (getIsCreator('masterAdministrator')) {
		return 'masterAdministrator'
	} else if (getIsCreator('childAdministrator')) {
		return 'childAdministrator'
	} else if (getIsCreator('deptManager')) {
		return 'deptManager'
	} else if (getIsCreator('employee')) {
		return 'employee'
	}
}
//判断是否有某项权限：this.$authoritys('masterAdministrator')
export function authoritys(key) {
	return supremeAuthority() == key
}

export function getToken() {
	return localStorage.getItem(TokenKey)
}
export function setToken(token) {
	localStorage.setItem(TokenKey, token)
}
// 防抖
export function _debounce(fn, delay = 500) {
	let timer = null
	return function() {
		let arg = arguments
		clearTimeout(timer)
		timer = setTimeout(() => {
			fn.apply(this, arg)
		}, delay)
	}
}
// 节流
export function _throttle(fn, interval = 500) {
	var last;
	var timer;
	return function() {
		var th = this;
		var args = arguments;
		var now = +new Date();
		if (last && now - last < interval) {
			clearTimeout(timer);
			timer = setTimeout(function() { //用户最后一次点击时间间隔小于设置时间执行
				last = now;
				fn.apply(th, args);
			}, interval);
		} else {
			last = now;
			fn.apply(th, args);
		}
	}
}
