import {
	api
} from './api.js';

import {
	jihua
} from './jihua.js';

// 成功
const responseOK = (response) => {
	const {
		data
	} = response;
	return data;
}

// 响应失败的依赖性
const responseFailedDependency = () => {
	uni.showToast({
		title: '登录状态过期,即将返回登录！',
		icon: 'error',
		position: 'top',
		duration: 2000
	});
	setTimeout(() => {
		try {
			uni.clearStorageSync();
			// 重定向登录
			uni.redirectTo({
				url: '/pages/login/login'
			})
		} catch (e) {
			// error
			console.log(e)
		}
	}, 2000);
	return false;
}

const responseError = (response, http = false) => {
	http && uni.showToast({
		title: '服务器异常,请稍后重试!',
		icon: 'error',
		position: 'top',
		duration: 2000
	});

	return false;
}

const responseNotResources = (response, http = false) => {
	http && uni.showToast({
		title: '没有找到服务资源!',
		icon: 'error',
		position: 'top',
		duration: 1000
	});
	return false;
}

const badRequest = (response, http = false) => {
	http && uni.showToast({
		title: '请求异常!',
		icon: 'error',
		position: 'top',
		duration: 1000
	});
	return response;
}

const responseUpgradeRequired = (response, http = false) => {
	http && uni.showToast({
		title: response.data.msg,
		icon: 'error',
		position: 'top',
		duration: 2000
	})
	return false;
}

const handlerCode = {
	200: responseOK,
	400: badRequest,
	404: responseNotResources,
	424: responseFailedDependency,
	426: responseUpgradeRequired,
	500: responseError
}


// 请求拦截
const fetch = (url, opt ,urlParam) => {
	let baseUrl = 'http://192.168.3.159:9999';
	let urls = (api[opt.url]?.url || api[url]?.url || jihua[opt.url]?.url || jihua[url]?.url);
	let params = opt.params ? ('?' + Object.keys(opt.params).map(key => key + '=' + opt.params[key]).join('&')) :
	'';
	opt.url = urlParam ? baseUrl + urls + `/${urlParam}` + params : baseUrl + urls + params
	opt.method = opt.method || "GET";
	var header = {}
	if (uni.getStorageSync('access_token')) {
		header = {
			"TENANT-ID": 5,
			Authorization: 'Bearer ' + uni.getStorageSync('access_token'),
			VERSION: "zzl",
			Accept:'application/json, text/plain, */*' // 客户端所能接受的数据类型
		}
	}

	opt.header = {
		...opt.header,
		...header
	}

	opt.data = opt.data || {};

	return new Promise((resolve, reject) => {

		let options = {}

		Object.keys(opt).map(key => {
			if (key !== "params") {
				return options[key] = opt[key]
			}
		})

		uni.request(options)
			.then(res => interceptorsRes(res, resolve, reject))
			.catch(err => interceptorsErr(err, reject))
	})
}



// 响应拦截
const interceptorsRes = ([err, resp], resolve, reject) => {
	const {
		statusCode,
		data
	} = resp;
	// 验证http状态码
	const handlerHTTPStatus = handlerCode[statusCode];

	// 没有找到相应状态操作直接返回
	if (!handlerHTTPStatus) return resolve(resp);
	if (!handlerHTTPStatus(resp, true)) return reject(false);
	resolve(resp.data)
}

// 异常处理
const interceptorsErr = (err, reject) => {
	console.log("网络异常", err)
	reject(err)
}


export {
	fetch
}