import { validatenull } from './validate';
import { DIC_PROPS, DIC_SPLIT } from 'global/variable';
const hasOwnProperty = Object.prototype.hasOwnProperty;

export function hasOwn(obj, key) {
 return hasOwnProperty.call(obj, key);
};
export function getFixed(val, len = 2) {
 return Number(val.toFixed(len));
}
export function dataURLtoFile(dataurl, filename) {
 let arr = dataurl.split(','),
 mime = arr[0].match(/:(.*?);/)[1],
 bstr = atob(arr[1]),
 n = bstr.length,
 u8arr = new Uint8Array(n);
 while (n--) {
 u8arr[n] = bstr.charCodeAt(n);
 }
 return new File([u8arr], filename, {
 type: mime
 });
}
/**
 * 生成随机数
 */
export function randomId() {
 let $chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
 let maxPos = $chars.length;
 let id = '';
 for (let i = 0; i < 16; i++) {
 id += $chars.charAt(Math.floor(Math.random() * maxPos));
 }
 return id;
}
export const getObjType = obj => {
 var toString = Object.prototype.toString;
 var map = {
 '[object Boolean]': 'boolean',
 '[object Number]': 'number',
 '[object String]': 'string',
 '[object Function]': 'function',
 '[object Array]': 'array',
 '[object Date]': 'date',
 '[object RegExp]': 'regExp',
 '[object Undefined]': 'undefined',
 '[object Null]': 'null',
 '[object Object]': 'object'
 };
 if (obj instanceof Element) {
 return 'element';
 }
 return map[toString.call(obj)];
};
/**
 *判断是否为json对象
 */

export const isJson = str => {
 if (Array.isArray(str)) {
 if (str[0] instanceof Object) {
 return true;
 } else {
 return false;
 }
 } else if (str instanceof Object) {
 return true;
 }
 return false;
};
/**
 * 对象深拷贝
 */
export const deepClone = data => {
 var type = getObjType(data);
 var obj;
 if (type === 'array') {
 obj = [];
 } else if (type === 'object') {
 obj = {};
 } else {
 // 不再具有下一层次
 return data;
 }
 if (type === 'array') {
 for (var i = 0, len = data.length; i < len; i++) {
 data[i] = (() => {
 if (data[i] === 0) {
 return data[i];
 }
 return data[i];
 })();
 delete data[i].$parent;
 obj.push(deepClone(data[i]));
 }
 } else if (type === 'object') {
 for (var key in data) {
 delete data.$parent;
 obj[key] = deepClone(data[key]);
 }
 }
 return obj;
};
/**
 * 根据字段数组排序
 */
export const sortArrys = (list, prop) => {
 list.sort(function(a, b) {
 if (a[prop] > b[prop]) {
 return -1;
 }
 if (a[prop] < b[prop]) {
 return 1;
 }
 return 0;
 });
 return list;
};

/**
 * 设置px像素
 */
export const setPx = (val, defval = '') => {
 if (validatenull(val)) val = defval;
 if (validatenull(val)) return '';
 val = val + '';
 if (val.indexOf('%') === -1) {
 val = val + 'px';
 }
 return val;
};

/**
 * 字符串数据类型转化
 */
export const detailDataType = (value, type) => {
 if (type === 'number') {
 return Number(value);
 } else if (type === 'string') {
 return value + '';
 } else {
 return value;
 }
};
// 获取url中的参数
export const getUrlParams = (url) => {
 let result = {
 url: '',
 params: []
 };
 result.url = url.split('?')[0];
 if (url[1]) {
 let str = url[1];
 url = str.substr(1);
 let list = url.split('&');
 list.forEach(ele => {
 let dic = ele.split('=');
 let label = dic[0];
 let value = dic[1];
 result.params[label] = value;
 });
 }
 return result;
};

/**
 * 数组的数据类型转化
 */
export const detailDic = (list = [], props = {}, type) => {
 let valueKey = props.value || DIC_PROPS.value;
 let childrenKey = props.children || DIC_PROPS.children;
 list.forEach(ele => {
 ele[valueKey] = detailDataType(ele[valueKey], type);
 if (ele[childrenKey]) detailDic(ele[childrenKey], props, type);
 });
 return list;
};
/**
 * 根据字典的value显示label
 */

export const findByValue = (dic, value, props, isTree) => {
 // 如果为空直接返回
 if (validatenull(dic)) return value;
 let result = '';
 props = props || DIC_PROPS;
 if (value instanceof Array) {
 result = [];
 for (let i = 0; i < value.length; i++) {
 const dicvalue = value[i];
 if (isTree) {
 result.push(findLabelNode(dic, dicvalue, props) || dicvalue);
 } else {
 result.push(findArrayLabel(dic, dicvalue, props));
 }
 }
 result = result.join(DIC_SPLIT).toString();

 } else if (['string', 'number', 'boolean'].includes(typeof value)) {
 result = findLabelNode(dic, value, props) || value;
 }
 return result;
};
/**
 * 过滤字典翻译字段和空字段
 */
export const filterDefaultParams = (form, translate = true) => {
 let data = deepClone(form);
 if (translate) return data;
 for (let o in data) {
 if (o.indexOf('$') !== -1 || validatenull(data[o])) {
 delete data[o];
 }
 }
 return data;
};
/**
 * 处理存在group分组的情况
 */
export const detailDicGroup = (dic) => {
 dic = deepClone(dic);
 let list = [];
 if ((dic[0] || {}).groups) {
 dic.forEach(ele => {
 if (ele.groups) {
 list = list.concat(ele.groups);
 }
 });
 return list;
 }
 return dic;
};
/**
 * 根据label去找到节点
 */
export const findLabelNode = (dic, value, props) => {
 dic = detailDicGroup(dic);
 let result = '';
 let rev = (dic1, value1, props1) => {
 const labelKey = props1.label || DIC_PROPS.label;
 const valueKey = props1.value || DIC_PROPS.value;
 const childrenKey = props1.children || DIC_PROPS.children;
 for (let i = 0; i < dic1.length; i++) {
 const ele = dic1[i];
 const children = ele[childrenKey] || [];
 if (ele[valueKey] === value1) {
 result = ele[labelKey];
 } else {
 rev(children, value1, props1);
 }
 }
 };
 rev(dic, value, props);
 return result;
};
/**
 * 获取多层data
 */
export const getDeepData = (res) => {
 return (Array.isArray(res) ? res : res.data) || [];
};
export const getObjValue = (data, params = '', type) => {
 const list = params.split('.');
 let result = data;
 if (list[0] === '' && type !== 'object') {
 return getDeepData(data);
 } else if (list[0] !== '') {
 list.forEach(ele => {
 result = result[ele];
 });
 }
 return result;
};
/**
 * 根据字典的value查找对应的index
 */
export const findArrayLabel = (dic, value, props) => {
 dic = detailDicGroup(dic);
 const valueKey = props.value || DIC_PROPS.value;
 const labelKey = props.label || DIC_PROPS.label;
 for (let i = 0; i < dic.length; i++) {
 if (dic[i][valueKey] === value) {
 return dic[i][labelKey];
 }
 }
 return value;
};
/**
 * 根据值查找对应的序号
 */
export const findArray = (dic, value, valueKey) => {
 dic = detailDicGroup(dic);
 valueKey = valueKey || DIC_PROPS.value;
 for (let i = 0; i < dic.length; i++) {
 if (dic[i][valueKey] === value) {
 return i;
 }
 }
 return -1;
};
/**
 * 根据位数获取*密码程度
 */
export const getPasswordChar = (result = '', char) => {
 let len = result.toString().length;
 result = '';
 for (let i = 0; i < len; i++) {
 result = result + char;
 }
 return result;
};

/**
 * 验证是否存在true/false
 */
export const vaildData = (val, dafult) => {
 if (typeof val === 'boolean') {
 return val;
 }
 return !validatenull(val) ? val : dafult;
};