/**
 * @description 用于表单提交时候的验证
 * @param
 */
 const formRegular = {
	specialChart: /[^%&',;=?$\x22]+/, // 含有特殊字符
	password: /^[a-zA-Z]\w{5,11}$/, // 字母开头，6-12位，只能包含字符、数字和下划线
	phone: /^[1][2,3,4,5,6,7,8,9][0-9]{9}$/, // 电话
	emial: /^([a-zA-Z]|[0-9])(\w|\-)+@[a-zA-Z0-9]+\.([a-zA-Z]{2,4})$/, // 邮箱
	idCard: /^\d{15}|\d{}18$/, // 身份证
	float: /^[0-9]+(.[0-9]{0,2})?$/, // 最多两位小数
	int: /^\+?[1-9][0-9]*$/ // 非0正整数
 }

const dealRegular = (type, val) => {
	let isOk = true
	for (let key in formRegular) {
		if (type === key) {
			isOk = formRegular[key].test(val)
			return isOk
		}
	}
}

const deepCopy = (source, trimIf) => {
	if (!source) {
		return source;
	}
	let sourceCopy = source instanceof Array ? [] : {};
	for (let item in source) {
		if (typeof source[item] === 'object') {
			sourceCopy[item] = deepCopy(source[item])
		} else {
			sourceCopy[item] = trimIf && Object.prototype.toString.call(source[item]) == "[object String]" ? source[
				item].trim() : source[item];
		}
	}
	return sourceCopy;
};
/* 规范化输入
	validateForm通过校验时返回经过trim及空值处理的新对象，如果未通过校验则返回false
	rule：字段校验规则
	rule:{
		"goodsNum":[
			{
				type:'number',
				message:"领用数量最大为100"
			},
			{
				required:true,
				message:"领用数量最大为100"
			},
			{
				min:1,
				max:100,
				message:"领用数量为1-100!"
			}
		],
		"goodsNum":[
			{
				type:'phone',
				message:"请输入正确的手机号码"
			}
		],
		"remark":[
			{
				len:500,
				message:"备注最多支持500个字符"
			}
		],
		"specialPattren":[
			{
				pattern:/^[A-Z]{1}[0-9]{9}/g,
				message:"请输入以大写字母开头的长度为10的字符"
			}
		]
	},
	trimIf：是否需要去除空格 
	removeNull：是否需要将值为undefined,null,""的属性移除，默认值为false
	目前支持校验方式：
	1、针对number类型支持最大值max，最小值min校验，对于字符串支持长度len校验
	2、对type等于phone,email等类型进行校验
	3、支持用户传入pattern进行正则扩充校验
	4、对于进行规范化输入的表单默认进行trim处理
	5、removeNull默认为false，false时不对对具有undefined,null,空字符等处理，为true时会从对象上面剔除相关属性
*/
let breakIf = false;

const validateForm = (data, rule = null, trimIf = true, removeNull = false) => {
	let newobj = Object.prototype.toString.call(data) == '[object Array]' ? [] : {}
	for (let key in data) {
		if (breakIf) {
			break;
		}
		let type = Object.prototype.toString.call(data[key])
		//针对引用类型做深拷贝处理
		if (type === '[object Array]' || type === '[object Object]') {
			newobj[key] = deepCopy(data[key], trimIf)
		}else if (type === '[object Date]' || data[key] ===
			'') {
			newobj[key] = data[key]
		} else if (data[key] === null || data[key] === undefined || data[key] === '') {
			//removeNull默认false，此时需要将值赋给新对象
			if(!removeNull){
				newobj[key] = data[key]
			}
		}else{
			newobj[key] = trimIf && type === '[object String]' ? data[key].trim() : data[key]
		}
		if (rule && rule[key]) {
			for (let k in rule[key]) {
				// 判断是否为数字
				if (rule[key][k].type && rule[key][k].type == "number" && isNaN(data[key])) {
					actionNext(rule[key][k].message)
					break;
				}
				// 判断手机号邮箱身份证等类型详见
				if (rule[key][k].type && formRegular[rule[key][k].type] && !dealRegular(rule[key][k]
						.type, data[key])) {
					actionNext(rule[key][k].message)
					break;
				}
				// 根据用户提供的正则表达式判断
				if (rule[key][k].pattern && !rule[key][k].pattern.test(data[key])) {
					actionNext(rule[key][k].message)
					break;
				}
				// 判断是否必填
				if (rule[key][k].required && isEmpty(data[key])) {
					actionNext(rule[key][k].message)
					break;
				}
				//判断是否超过最大值最小值
				if ((rule[key][k].max || rule[key][k].min) && data[key] && (data[key] > rule[key][k].max ||
						data[key] < rule[key][k].min)) {
					actionNext(rule[key][k].message)
					break;
				}
				//长度校验（string,Array等具有length属性的类型都支持）
				if (rule[key][k].len && data[key] && data[key].length > rule[key][k].len) {
					actionNext(rule[key][k].message)
					break;
				}
			}
		}
	}
	initBreakIf()
	return !breakIf ? newobj : false;
}

const initBreakIf = () => {
	setTimeout(() => {
		breakIf = false
	}, 0)
}

const actionNext = (message) => {
	wx.showToast({
		title: message,
		icon: 'none'
	})
	breakIf = true
	// initBreakIf()
}

//判断是否为空
const isEmpty = (value) => {
	if (value === undefined || value === null || value === '') {
		return true
	}
	//数组
	if (Object.prototype.toString.call(value) == '[object Array]' && value.length == 0) {
		return true
	}
	//对象
	if (Object.prototype.toString.call(value) == '[object Object]' && Object.keys(value).length == 0) {
		return true
	}
}

/**
 * 校验字段是否为空
 * @param {*} params 要校验的参数 
 * @param {*} rules 哪些字段要必传，和他要展示的错误提示内容
 * @returns 
 */
const checkParamsIsMust = (params, rules) => {
	let errMsg = ''

	for (let i = 0; i < rules.length; i++) { 
		const key = rules[i].key
		const checkResult = isEmpty(params[key])

		if (checkResult) { 
			errMsg = `请填写${rules[i].keyStr}！`
			break
		}
	}
		
	return errMsg
}

export {
	validateForm,
	deepCopy,
  checkParamsIsMust,
  formRegular
}
