/**
 * 获取距离date的dayCount天数( 年月日)
 * @param {*} dayCount 距离date的天数
 * @param {*} date 日期
 * @returns 返回 yyyy-MM-dd
 */
export function getDay(dayCount, date) {
	var today = date ? new Date(date) : new Date();
	var targetday_milliseconds = today.getTime() + 1000 * 60 * 60 * 24 * dayCount;
	today.setTime(targetday_milliseconds); //注意，这行是关键代码
	var tYear = today.getFullYear();
	var tMonth = today.getMonth();
	var tDate = today.getDate();
	tMonth = doHandleMonth(tMonth + 1);
	tDate = doHandleMonth(tDate);
	return tYear + '-' + tMonth + '-' + tDate;
}
function doHandleMonth(month) {
	var m = month;
	if (month.toString().length == 1) {
		m = '0' + month;
	}
	return m;
}

// 格式化时间格式
/**
 * 格式化时间格式
 * @param {*} template  格式化模板
 * @param {*} date 格式化日期
 * @returns
 */
export function formatTime(template, date) {
	var today = date ? new Date(date) : new Date();
	var o = {
		'M+': today.getMonth() + 1, //月份
		'd+': today.getDate(), //日
		'h+': today.getHours(), //小时
		'm+': today.getMinutes(), //分
		's+': today.getSeconds(), //秒
		'q+': Math.floor((today.getMonth() + 3) / 3), //季度
		S: today.getMilliseconds(), //毫秒
	};
	var fmt = template;
	if (/(y+)/.test(fmt)) {
		fmt = fmt.replace(RegExp.$1, (today.getFullYear() + '').substr(4 - RegExp.$1.length));
	}

	for (var k in o) {
		if (new RegExp('(' + k + ')').test(fmt)) {
			fmt = fmt.replace(RegExp.$1, RegExp.$1.length == 1 ? o[k] : ('00' + o[k]).substr(('' + o[k]).length));
		}
	}
	return fmt;
}

/**
 * 数组去重
 * @param {*} arr  原始数组
 * @returns
 */
export function uniqueInArray(arr) {
	if (Array.hasOwnProperty('from')) {
		return Array.from(new Set(arr));
	} else {
		var n = {},
			r = [];
		for (var i = 0; i < arr.length; i++) {
			if (!n[arr[i]]) {
				n[arr[i]] = true;
				r.push(arr[i]);
			}
		}
		return r;
	}
}

/**
 * 计算echarts 的 max ，min ，interval
 * @param {*} max 最大值
 * @param {*} min 最小值
 * @param {*} splitNumber 分隔数
 * @returns '{ max: 0, min: 0, interval: 0 }'
 */
export function getChartMaxMinInterval(max, min, splitNumber) {
	function getMaxMinNumber(n, l) {
		var a1 = Math.floor(Math.log(n) / Math.LN10);
		var b;
		if (l) {
			a1 < 2
				? (b =
						n / Math.pow(10, a1) - parseInt(n / Math.pow(10, a1)) > 0.5
							? Math.round(n / Math.pow(10, a1)) * Math.pow(10, a1)
							: (parseInt(n / Math.pow(10, a1)) + 0.5) * Math.pow(10, a1))
				: (b = Math.ceil(n / Math.pow(10, 1)) * Math.pow(10, 1));
		} else {
			a1 < 2
				? (b =
						n / Math.pow(10, a1) - parseInt(n / Math.pow(10, a1)) > 0.5
							? (parseInt(n / Math.pow(10, a1)) + 0.5) * Math.pow(10, a1)
							: Math.floor(n / Math.pow(10, a1)) * Math.pow(10, a1))
				: (b = Math.floor(n / Math.pow(10, 1)) * Math.pow(10, 1));
		}
		return l ? (-20 <= a1 ? +b.toFixed(a1 < 0 ? -a1 + 1 : 0) : b) : b;
	}
	var interval = 0;
	if ((max - min) % splitNumber != 0) {
		interval = getMaxMinNumber((max - min) / splitNumber, 1);
		max = parseFloat((parseFloat((interval * splitNumber).toFixed(12)) + min).toFixed(12)); //解决小数精度一般问题，极端问题并不能解决。
		min = min;
	} else {
		interval = (max - min) / splitNumber;
		min = min;
		max = max;
	}
	return { max: max, min: min, interval: interval };
}

/**
 * 保留几位小数
 * @param {*} val  要保留小数的值
 * @param {*} n 保留的小数位数
 * @returns
 */
export function getToFixed(val, n) {
	let temp = parseFloat(val);
	n = n ? n : 0;
	if (typeof temp == NaN) {
		console.warn('传入的为非数字类型');
		return NaN;
	}
	temp = parseFloat(temp.toFixed(n));
	return temp;
}

/**
 * 根据扬程算流量
 * @param {*} curve 贝塞尔曲线
 * @param {*} y 扬程
 * @returns '{x: 0,y: 0,}'
 */
export function getSectPointFlowbyH(curve, y) {
	if (curve == null) return null;
	var iPtCount = curve.length;
	if (y > curve[0].Point0.Y) {
		return null;
	}
	if (y < curve[iPtCount - 1].Point3.Y) {
		return null;
	}

	for (var i = 0; i < iPtCount; i++) {
		if (y > curve[i].Point3.Y && y < curve[i].Point0.Y) {
			var ptBizer = curve[i];
			//
			try {
				var minDis = Math.abs(ptBizer.Point3.Y - ptBizer.Point0.Y);
				var sectY = 0;
				var sectX = 0;
				//console.log(minDis)
				for (var uu = 0; uu <= 1; uu = uu + 0.01) {
					var y0 = ptBizer.Point0.Y * uu * uu * uu;
					var y1 = 3 * ptBizer.Point1.Y * uu * uu * (1 - uu);
					var y2 = 3 * ptBizer.Point2.Y * uu * (1 - uu) * (1 - uu);
					var y3 = ptBizer.Point3.Y * (1 - uu) * (1 - uu) * (1 - uu);

					var curveY = y0 + y1 + y2 + y3;
					//console.log(curveY)
					if (Math.abs(curveY - y) < minDis) {
						var y0 = ptBizer.Point0.Y * uu * uu * uu;
						var y1 = 3 * ptBizer.Point1.Y * uu * uu * (1 - uu);
						var y2 = 3 * ptBizer.Point2.Y * uu * (1 - uu) * (1 - uu);
						var y3 = ptBizer.Point3.Y * (1 - uu) * (1 - uu) * (1 - uu);

						var x0 = ptBizer.Point0.X * uu * uu * uu;
						var x1 = 3 * ptBizer.Point1.X * uu * uu * (1 - uu);
						var x2 = 3 * ptBizer.Point2.X * uu * (1 - uu) * (1 - uu);
						var x3 = ptBizer.Point3.X * (1 - uu) * (1 - uu) * (1 - uu);

						minDis = Math.abs(curveY - y);
						sectX = x0 + x1 + x2 + x3;
						sectY = curveY;
					}
				}
				return {
					x: sectX,
					y: sectY,
				};
			} catch (ex) {
				alert(ex.message);
			}
		}
	}
}

/**
 * 根据流量算扬程
 * @param {*} curve 贝塞尔曲线
 * @param {*} x 流量
 * @returns '{x: 0,y: 0,}'
 */
export function getSectPointHbyFlow(curve, x) {
	if (curve == null) return null;
	var iPtCount = curve.length;
	if (x < curve[0].Point0.X) {
		return null;
	}
	if (x > curve[iPtCount - 1].Point3.X) {
		return null;
	}

	for (var i = 0; i < iPtCount; i++) {
		if (x > curve[i].Point0.X && x < curve[i].Point3.X) {
			var ptBizer = curve[i];
			//
			try {
				//alert(i);
				var minDis = Math.abs(ptBizer.Point3.X - ptBizer.Point0.X);
				//alert(x + "   " + curve[i].Point0.X + "    " + curve[i].Point3.X);
				var sectY = 0;
				var sectX = 0;
				for (var uu = 0; uu <= 1; uu = uu + 0.01) {
					var x0 = ptBizer.Point0.X * uu * uu * uu;
					var x1 = 3 * ptBizer.Point1.X * uu * uu * (1 - uu);
					var x2 = 3 * ptBizer.Point2.X * uu * (1 - uu) * (1 - uu);
					var x3 = ptBizer.Point3.X * (1 - uu) * (1 - uu) * (1 - uu);

					var curveX = x0 + x1 + x2 + x3;
					if (Math.abs(curveX - x) < minDis) {
						var y0 = ptBizer.Point0.Y * uu * uu * uu;
						var y1 = 3 * ptBizer.Point1.Y * uu * uu * (1 - uu);
						var y2 = 3 * ptBizer.Point2.Y * uu * (1 - uu) * (1 - uu);
						var y3 = ptBizer.Point3.Y * (1 - uu) * (1 - uu) * (1 - uu);
						minDis = Math.abs(curveX - x);
						sectY = y0 + y1 + y2 + y3;
						sectX = curveX;
					}
				}
				return {
					x: sectX,
					y: sectY,
				};
			} catch (ex) {
				alert(ex.message);
			}
		}
	}
}

/**
 * 转成Bezier曲线模型
 * @param {*} pixelPoints
 * @returns
 */
export function transBezierCurveModel(pixelPoints) {
	if (pixelPoints == null || pixelPoints.length < 4) return null;
	//console.log(pixelPoints);
	var iPointCout = pixelPoints.length;
	var a = 0.09;
	var b = 0.09;
	var controlPoint = [];

	for (var i = 0; i < iPointCout - 1; i++) {
		var bezier = {};
		bezier.Point0 = { X: pixelPoints[i][0], Y: pixelPoints[i][1] };

		if (i == 0) {
			var x1 = pixelPoints[i][0] + a * (pixelPoints[i + 1][0] - pixelPoints[i][0]);
			var y1 = pixelPoints[i][1] + a * (pixelPoints[i + 1][1] - pixelPoints[i][1]);
			bezier.Point1 = {
				X: x1,
				Y: y1,
			};
		} else {
			var x1 = pixelPoints[i][0] + a * (pixelPoints[i + 1][0] - pixelPoints[i - 1][0]);
			var y1 = pixelPoints[i][1] + a * (pixelPoints[i + 1][1] - pixelPoints[i - 1][1]);
			bezier.Point1 = {
				X: x1,
				Y: y1,
			};
		}

		if (i == iPointCout - 2) {
			var x2 = pixelPoints[i + 1][0] - b * (pixelPoints[i + 1][0] - pixelPoints[i][0]);
			var y2 = pixelPoints[i + 1][1] - b * (pixelPoints[i + 1][1] - pixelPoints[i][1]);
			bezier.Point2 = {
				X: x2,
				Y: y2,
			};
		} else {
			var x2 = pixelPoints[i + 1][0] - b * (pixelPoints[i + 2][0] - pixelPoints[i][0]);
			var y2 = pixelPoints[i + 1][1] - b * (pixelPoints[i + 2][1] - pixelPoints[i][1]);
			bezier.Point2 = {
				X: x2,
				Y: y2,
			};
		}
		bezier.Point3 = { X: pixelPoints[i + 1][0], Y: pixelPoints[i + 1][1] };
		//bezier.Point3 = pixelPoints[i + 1];
		controlPoint.push(bezier);
	}
	//console.log(controlPoint);
	return controlPoint;
}

/**
 * 格式化值，根据值的大小选择保留几位小数
 * @param {*} value
 * @returns
 */
export function numberFormat4RecordValue(value) {
	if (value == null || value == undefined) return 0;
	value = parseFloat(value);
	if (value > 100) return parseFloat(value.toFixed(1));
	else if (value > 10) return parseFloat(value.toFixed(2));
	else return parseFloat(value.toFixed(4));
}
export function numberFormat(value) {
	if (value == null || value == undefined) return 0;
	var v = value.toString();
	var result = v;
	var decimalIndex = v.indexOf('.');
	if (decimalIndex != -1) {
		result = v.substring(decimalIndex + 1, v.length);
		if (result.length > 5) {
			v = parseFloat(value).toFixed('5');
		}
		if (result.substr(result.length - 4, 4) == '0000') {
			v = parseFloat(value).toFixed(result.length - 4);
		} else if (result.substr(result.length - 3, 3) == '000') {
			v = parseFloat(value).toFixed(result.length - 3);
		} else if (result.substr(result.length - 2, 2) == '00') {
			v = parseFloat(value).toFixed(result.length - 2);
		} else if (result.substr(result.length - 1, 1) == '0') {
			v = parseFloat(value).toFixed(result.length - 1);
		}
	}
	return v;
}
/**
 * 数组求和
 * @param {Array} arr
 * @returns  sum
 */
export function sumInArray(arr) {
	return arr.reduce((pre, cur) => {
		return pre + cur;
	});
}

/**
 * 计算数组最大值
 * @param {*} arr
 * @returns max
 */
export function maxInArray(arr) {
	return Math.max.apply(null, arr);
}

/**
 * 计算数组 最小值
 * @param {*} arr
 * @returns min
 */
export function minInArray(arr) {
	return Math.min.apply(null, arr);
}

/**
 * 深拷贝
 * @param {*} data
 * @returns data
 */
export const deepCopy = (data) => {
	return JSON.parse(JSON.stringify(data));
};

/**
 * list数据转成 tree使用格式
 * @param {*} data  list结构数组  父子关系是ParentIds数组
 * @returns tree
 */
export const treeCorprationDataFormat = (data) => {
	if (!Array.isArray(data)) {
		return data;
	}
	let tree = [];
	const listToTree = (list, tree, parentId, length) => {
		list.forEach((org) => {
			org.value = org.ID;
			// 判断是否为父级菜单
			if (length == 0) {
				if (org.ParentIds.length == 0) {
					let child = org;
					child.Children = [];
					// 迭代 list， 找到当前菜单相符合的所有子菜单
					listToTree(list, child.Children, org.ID, org.ParentIds.length + 1);
					// 删掉不存在 children 值的属性
					if (child.Children.length <= 0) {
						delete child.Children;
					}
					// 加入到树中
					tree.push(child);
				}
			} else {
				if (org.ParentIds.length == length && org.ParentIds.indexOf(parentId) != -1) {
					let child = org;
					child.Children = [];
					// 迭代 list， 找到当前菜单相符合的所有子菜单
					listToTree(list, child.Children, org.ID, org.ParentIds.length + 1);
					// 删掉不存在 children 值的属性
					if (child.Children.length <= 0) {
						delete child.Children;
					}
					// 加入到树中
					tree.push(child);
				}
			}
		});
	};
	listToTree(data, tree, 0, 0);
	return tree;
};

/**
 * 在版本管理，用于将左侧故障树中的 item 项汇入 Children 中，
 * 方便树形数据展示
 */
export const formatTreeList = (responseTreeData) => {
	return responseTreeData.map((node) => {
		let formatItems = [];
		if (node.Items) {
			formatItems = node.Items.map((item) => {
				item.wysType = 'fault';
				item.isFaultTree = true;
				return item;
			});
		}
		// 如果有 Children 属性，确定不是故障
		if (node.Children) {
			node.Children = [...formatTreeList([...node.Children]), ...formatItems];
			// 无 Items 属性，确定一定是故障，而不是故障组
		} else if (!node.Items) {
			node.wysType = 'fault';
			node.isFaultTree = true;
		}
		return node;
	});
};

/**
 * list数据转成 treeTable使用格式 用于客户管理页面表格展示
 * @param {*} data  list结构数组  父子关系是ParentIds数组
 * @returns tree
 */
export const listFormatTreeTableCorpration = (data, pid, l) => {
	if (!Array.isArray(data)) {
		return data;
	}
	let tree = [];
	const listToTree = (list, tree, parentId, length) => {
		list.forEach((org) => {
			// 判断是否为父级菜单
			org.value = org.ID;
			if (org.ParentIds.length == length && org.ParentIds.indexOf(parentId) != -1) {
				let child = org;
				child.children = [];
				// 迭代 list， 找到当前菜单相符合的所有子菜单
				listToTree(list, child.children, org.ID, org.ParentIds.length + 1);
				// 删掉不存在 children 值的属性
				if (child.children.length <= 0) {
					delete child.children;
				}
				// 加入到树中
				tree.push(child);
			}
		});
	};

	listToTree(data, tree, pid, l);
	return tree;
};

/**
 * list数据转成 tree使用格式 用于左侧树结构显示登录客户及子客户
 * @param {*} data  list结构数组  父子关系是ParentIds数组
 * @returns tree
 */
export const listFormatTreeCorpration = (data, pid, l) => {
	if (!Array.isArray(data)) {
		return data;
	}
	let tree = [];
	const listToTree = (list, tree, parentId, length) => {
		list.forEach((org) => {
			org.value = org.ID;
			// 判断是否为父级菜单
			if (org.ParentIds.length == length && org.ID == parentId) {
				let child = org;
				child.Children = [];
				// 迭代 list， 找到当前菜单相符合的所有子菜单
				listToTree(list, child.Children, org.ID, org.ParentIds.length + 1);
				// 删掉不存在 Children 值的属性
				if (child.Children.length <= 0) {
					delete child.Children;
				}
				// 加入到树中
				tree.push(child);
			} else if (org.ParentIds.length == length && org.ParentIds.indexOf(parentId) != -1) {
				let child = org;
				child.Children = [];
				// 迭代 list， 找到当前菜单相符合的所有子菜单
				listToTree(list, child.Children, org.ID, org.ParentIds.length + 1);
				// 删掉不存在 Children 值的属性
				if (child.Children.length <= 0) {
					delete child.Children;
				}
				// 加入到树中
				tree.push(child);
			}
		});
	};

	listToTree(data, tree, pid, l);
	return tree;
};

/**
 * 根据id获取树id  用于获取默认选中高亮
 * @param {*} list 原始数组
 * @param {*} ID  选中id
 * @returns obj 原始数组中item
 */
export const getTreeIdById = (list, ID) => {
	let obj = [];
	if (list.length === 0) {
		return obj;
	}
	const getDtreeId = (obj, list, ID) => {
		if (ID) {
			for (var i = 0; i < list.length; i++) {
				var item = list[i];
				if (!item.Children) {
					item.Children = [];
				}
				if (item.ID == ID) {
					obj.push(item);
					// break;
				}
				if (item.Children.length != 0) {
					getDtreeId(obj, item.Children, ID);
				}
			}
		} else {
			if (!list[0].Children) {
				list[0].Children = [];
			}
			if (list[0].Children.length == 0) {
				obj.push(list[0]);
			}
			if (list[0].Children.length != 0) {
				getDtreeId(obj, list[0].Children, ID);
			}
		}
	};
	getDtreeId(obj, list, ID);
	return obj;
};

export const formatTreeDataToElementPlusTreeSelect = (list, idstr, childrenstr) => {
	const addValue = (list, idstr, childrenstr) => {
		list.forEach((x) => {
			x.value = x[idstr];
			if (x[childrenstr] && x[childrenstr].length > 0) {
				addValue(x[childrenstr], idstr, childrenstr);
			}
		});
	};
	if (list && list.length > 0) {
		addValue(list, idstr, childrenstr);
	}
};

export const $ = (name) => document.querySelector(name);

export const getContainerSize = (dom) => ({ width: dom.getBoundingClientRect().width, height: dom.getBoundingClientRect().height });