// [z-paging]工具类

import zLocalConfig from '../config/index'
import c from './z-paging-constant'

const storageKey = 'Z-PAGING-REFRESHER-TIME-STORAGE-KEY';
let config = null;
let configLoaded = false;
let cachedSystemInfo = null;
const timeoutMap = {};

// 获取默认配置信息
function gc(key, defaultValue) {
	// 这里return一个函数以解决在vue3+appvue中，props默认配置读取在main.js之前执行导致uni.$zp全局配置无效的问题。相当于props的default中传入一个带有返回值的函数
	return () => {
		// 处理z-paging全局配置
		_handleDefaultConfig();
		// 如果全局配置不存在，则返回默认值
		if (!config) return defaultValue;
		const value = config[key];
		// 如果全局配置存在但对应的配置项不存在，则返回默认值；反之返回配置项
		return value === undefined ? defaultValue : value;
	};
}

// 获取最终的touch位置
function getTouch(e) {
	let touch = null;
	if (e.touches && e.touches.length) {
		touch = e.touches[0];
	} else if (e.changedTouches && e.changedTouches.length) {
		touch = e.changedTouches[0];
	} else if (e.datail && e.datail != {}) {
		touch = e.datail;
	} else {
		return { touchX: 0, touchY: 0 }
	}
	return {
		touchX: touch.clientX,
		touchY: touch.clientY
	};
}

// 判断当前手势是否在z-paging内触发
function getTouchFromZPaging(target) {
	if (target && target.tagName && target.tagName !== 'BODY' && target.tagName !== 'UNI-PAGE-BODY') {
		const classList = target.classList;
		if (classList && classList.contains('z-paging-content')) {
			// 此处额外记录当前z-paging是否是页面滚动、是否滚动到了顶部、是否是聊天记录模式以传给renderjs。避免不同z-paging组件renderjs内部判断数据互相影响导致的各种问题
			return {
				isFromZp: true,
				isPageScroll: classList.contains('z-paging-content-page'),
				isReachedTop: classList.contains('z-paging-reached-top'),
				isUseChatRecordMode: classList.contains('z-paging-use-chat-record-mode')
			};
		} else {
			return getTouchFromZPaging(target.parentNode);
		}
	} else {
		return { isFromZp: false };
	}
}

// 递归获取z-paging所在的parent，如果查找不到则返回null
function getParent(parent) {
	if (!parent) return null;
	if (parent.$refs.paging) return parent;
	return getParent(parent.$parent);
}

// 打印错误信息
function consoleErr(err) {
	console.error(`[z-paging]${err}`);
}

// 延时操作，如果key存在，调用时清除对应key之前的延时操作
function delay(callback, ms = c.delayTime, key) {
	const timeout = setTimeout(callback, ms);;
	if (!!key) {
		timeoutMap[key] && clearTimeout(timeoutMap[key]);
		timeoutMap[key] = timeout;
	}
	return timeout;
}

// 设置下拉刷新时间
function setRefesrherTime(time, key) {
	const datas = getRefesrherTime() || {};
	datas[key] = time;
	uni.setStorageSync(storageKey, datas);
}

// 获取下拉刷新时间
function getRefesrherTime() {
	return uni.getStorageSync(storageKey);
}

// 通过下拉刷新标识key获取下拉刷新时间
function getRefesrherTimeByKey(key) {
	const datas = getRefesrherTime();
	return datas && datas[key] ? datas[key] : null;
}

// 通过下拉刷新标识key获取下拉刷新时间(格式化之后)
function getRefesrherFormatTimeByKey(key, textMap) {
	const time = getRefesrherTimeByKey(key);
	const timeText = time ? _timeFormat(time, textMap) : textMap.none;
	return `${textMap.title}${timeText}`;
}

// 将文本的px或者rpx转为px的值
function convertToPx(text) {
	const dataType = Object.prototype.toString.call(text);
	if (dataType === '[object Number]') return text;
	let isRpx = false;
	if (text.indexOf('rpx') !== -1 || text.indexOf('upx') !== -1) {
		text = text.replace('rpx', '').replace('upx', '');
		isRpx = true;
	} else if (text.indexOf('px') !== -1) {
		text = text.replace('px', '');
	}
	if (!isNaN(text)) {
		if (isRpx) return Number(rpx2px(text));
		return Number(text);
	}
	return 0;
}

// rpx => px，预留的兼容处理
function rpx2px(rpx) {
	return uni.upx2px(rpx);
}

// 同步获取系统信息，兼容不同平台
function getSystemInfoSync(useCache = false) {
	if (useCache && cachedSystemInfo) {
		return cachedSystemInfo;
	}
	// 目前只用到了deviceInfo、appBaseInfo和windowInfo中的信息，因此仅整合这两个信息数据
	const infoTypes = ['DeviceInfo', 'AppBaseInfo', 'WindowInfo'];
	const { deviceInfo, appBaseInfo, windowInfo } = infoTypes.reduce((acc, key) => {
		const method = `get${key}`;
		if (uni[method] && uni.canIUse(method)) {
			acc[key.charAt(0).toLowerCase() + key.slice(1)] = uni[method]();
		}
		return acc;
	}, {});
	// 如果deviceInfo、appBaseInfo和windowInfo都可以从各自专属的api中获取，则整合它们的数据
	if (deviceInfo && appBaseInfo && windowInfo) {
		cachedSystemInfo = { ...deviceInfo, ...appBaseInfo, ...windowInfo };
	} else {
		// 使用uni.getSystemInfoSync兜底，确保能获取到最终的系统信息
		cachedSystemInfo = uni.getSystemInfoSync();
	}
	return cachedSystemInfo;
}

// 获取当前时间
function getTime() {
	return (new Date()).getTime();
}

// 获取z-paging实例id，随机生成10位数字+字母
function getInstanceId() {
	const s = [];
	const hexDigits = "0123456789abcdef";
	for (let i = 0; i < 10; i++) {
		s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
	}
	return s.join('') + getTime();
}

// 等待一段时间
function wait(ms) {
	return new Promise(resolve => {
		setTimeout(resolve, ms);
	});
}

// 是否是promise
function isPromise(func) {
	return Object.prototype.toString.call(func) === '[object Promise]';
}

// 添加单位
function addUnit(value, unit) {
	if (Object.prototype.toString.call(value) === '[object String]') {
		let tempValue = value;
		tempValue = tempValue.replace('rpx', '').replace('upx', '').replace('px', '');
		if (value.indexOf('rpx') === -1 && value.indexOf('upx') === -1 && value.indexOf('px') !== -1) {
			tempValue = parseFloat(tempValue) * 2;
		}
		value = tempValue;
	}
	return unit === 'rpx' ? value + 'rpx' : (value / 2) + 'px';
}

// 深拷贝
function deepCopy(obj) {
	if (typeof obj !== 'object' || obj === null) return obj;
	let newObj = Array.isArray(obj) ? [] : {};
	for (let key in obj) {
		if (obj.hasOwnProperty(key)) {
			newObj[key] = deepCopy(obj[key]);
		}
	}
	return newObj;
}

// ------------------ 私有方法 ------------------------
// 处理全局配置
function _handleDefaultConfig() {
	// 确保只加载一次全局配置
	if (configLoaded) return;
	// 优先从config.js中读取
	if (zLocalConfig && Object.keys(zLocalConfig).length) {
		config = zLocalConfig;
	}
	// 如果在config.js中读取不到，则尝试到uni.$zp读取
	if (!config && uni.$zp) {
		config = uni.$zp.config;
	}
	// 将config中的短横线写法全部转为驼峰写法，使得读取配置时可以直接通过key去匹配，而非读取每个配置时候再去转，减少不必要的性能开支
	config = config ? Object.keys(config).reduce((result, key) => {
		result[_toCamelCase(key)] = config[key];
		return result;
	}, {}) : null;
	configLoaded = true;
}

// 时间格式化
function _timeFormat(time, textMap) {
	const date = new Date(time);
	const currentDate = new Date();
	// 设置time对应的天，去除时分秒，使得可以直接比较日期
	const dateDay = new Date(time).setHours(0, 0, 0, 0);
	// 设置当前的天，去除时分秒，使得可以直接比较日期
	const currentDateDay = new Date().setHours(0, 0, 0, 0);
	const disTime = dateDay - currentDateDay;
	let dayStr = '';
	const timeStr = _dateTimeFormat(date);
	if (disTime === 0) {
		dayStr = textMap.today;
	} else if (disTime === -86400000) {
		dayStr = textMap.yesterday;
	} else {
		dayStr = _dateDayFormat(date, date.getFullYear() !== currentDate.getFullYear());
	}
	return `${dayStr} ${timeStr}`;
}

// date格式化为年月日
function _dateDayFormat(date, showYear = true) {
	const year = date.getFullYear();
	const month = date.getMonth() + 1;
	const day = date.getDate();
	return showYear ? `${year}-${_fullZeroToTwo(month)}-${_fullZeroToTwo(day)}` : `${_fullZeroToTwo(month)}-${_fullZeroToTwo(day)}`;
}

// data格式化为时分
function _dateTimeFormat(date) {
	const hour = date.getHours();
	const minute = date.getMinutes();
	return `${_fullZeroToTwo(hour)}:${_fullZeroToTwo(minute)}`;
}

// 不满2位在前面填充0
function _fullZeroToTwo(str) {
	str = str.toString();
	return str.length === 1 ? '0' + str : str;
}

// 驼峰转短横线
function _toKebab(value) {
	return value.replace(/([A-Z])/g, "-$1").toLowerCase();
}

// 短横线转驼峰
function _toCamelCase(value) {
	return value.replace(/-([a-z])/g, (_, group1) => group1.toUpperCase());
}


export default {
	gc,
	setRefesrherTime,
	getRefesrherFormatTimeByKey,
	getTouch,
	getTouchFromZPaging,
	getParent,
	convertToPx,
	getTime,
	getInstanceId,
	consoleErr,
	delay,
	wait,
	isPromise,
	addUnit,
	deepCopy,
	rpx2px,
	getSystemInfoSync
};