const preCacheKeyClearFetch = 'storage:clear:fetch:'

function requestrequest(options) {
	return new Promise((resolve, reject) => {
		uni.request({
			...options,
			success: res => {
				resolve(res.data) //异步操作执行成功
				// if (res.data.code == 1) {
				// 	resolve(res.data) //异步操作执行成功
				// } else {
				// 	console.log(res,'请求的接口没有找到');
				// 	resolve(res.data) //异步操作执行失败
				// }
			}
		})
	})
}

async function request(options) {
	let networkType = ''
	uni.getNetworkType({
		success: (res) => {
			networkType = res.networkType
		}
	});
	if (networkType == 'none') {
		uni.showToast({
			title: '网络异常，请检查网络',
			icon: 'none'
		})
		return false;
	}
	try {
		if (options.toast) {
			uni.showLoading({
				title: '加载中',
				mask: true
			})
		}
		if (options.type == 1) {
			options.header = {
				version: uni.conf.version,
				type: uni.getSystemInfoSync().platform,
				// #ifdef APP-PLUS
				environment: 'app',
				// #endif
				// #ifdef H5
				environment: 'H5',
				// #endif
				// #ifdef MP-WEIXIN
				environment: 'wx',
				// #endif
				// #ifdef MP-ALIPAY
				environment: 'alipay',
				// #endif
				token: uni.cache.get('token'),
				openId: uni.cache.get('miniAppOpenId'),
				id: uni.cache.get('userInfo').id,
			}
		} else {

		}
		options.url = uni.conf.baseUrl + options.url
		let res = await requestrequest(options);
		if (res.code != 0) {
			if (res.code == -4) {


			} else if (res.code == 482) {
				let nowTime = new Date() / 1000 | 0
				let offset = parseInt(res.data.message) - parseInt(nowTime);
				uni.cache.set('storage:offset-time', offset, -1)
				return await request(options)
			} else {
				uni.showToast({
					title: res.message || res.msg || res.error,
					icon: "none",
					success: () => {
						setTimeout(res => {
							if (options.toast) {

							}
						}, 2000)
					}
				})
				return res
			}
		} else {
			uni.hideLoading()
			return res
		}
	} catch (err) {
		uni.showToast({
			title: err.message || err.msg,
			icon: "none",
		})
		console.warn('uni.request fail [network]', options, err)
		throw err;
	} finally {
		if (options.toast) {
			setTimeout(res => {
				uni.hideLoading()
			}, 2000)
		}
	}
}

function isExpire(url) {
	return uni.cache.get(preCacheKeyClearFetch + url)
}
/**
 * 标记fetch过期，会重新请求
 * @author NanQi
 * @param {String} url 标记的URL 
 */
function markFetch(url) {
	uni.cache.set(preCacheKeyClearFetch + url, true)
}

/**
 * 拉取数据(get请求,带缓存)
 * @author NanQi
 * @param {String} url 请求的URL 
 * @param {Object} data 请求参数 
 * @param {Boolean} toast 是否显示toast
 * @param {Number} expire 缓存过期时间（秒）
 * @return {Promise} Promise对象
 */
async function fetch(url, data, toast = true, expire = uni.conf.default_expire) {
	let param = ''
	if (data) {
		param += ':' + uni.utils.md5(uni.utils.sortTransform(data));
	}
	const cacheKey = 'memory:fetch:' + url + param;
	const cacheVal = uni.cache.get(cacheKey);
	if (!isExpire(url) && cacheVal) {
		return Promise.resolve(cacheVal);
	} else {
		if (isExpire(url)) {
			uni.cache.remove(preCacheKeyClearFetch + url)
		}
		try {
			const res = await get(url, data, toast);
			uni.cache.remove(cacheKey);
			uni.cache.set(cacheKey, res, expire);
			return res;
		} catch (err) {
			const res = uni.cache.getStorageData(cacheKey);
			if (res) {
				return Promise.resolve(res);
			} else {
				throw err;
			}
		}
	}
}

/**
 * 获取数据(get请求,不带缓存)
 * @author NanQi
 * @param {String} url 请求的URL 
 * @param {Object} data 请求参数 
 * @param {Boolean} toast 是否显示toast
 * @return {Promise} Promise对象
 */
function get(url, data, toast = true, type = 1) {
	return request({
		url,
		data,
		toast,
		type
	})
}


/**
 * post请求
 * @author NanQi
 * @param {String} url 请求的URL 
 * @param {Object} data 请求参数 
 * @param {Boolean} toast 是否显示toast
 * @param {String} method 请求方式,默认POST 
 * @return {Promise} Promise对象
 */
function post(url, data, toast = true, method = 'POST', type = 1) {
	return request({
		url,
		method,
		data,
		toast,
		type
	})
}

uni.api = {
	request,
	markFetch,
	fetch,
	get,
	post
}