import Request from './request.js';
import errorCode from './errorCode.js';
import {Base64} from "js-base64";
// let protocol = 'https'; //协议
// let baseUrl = 'app.xiaokang88.com/service/v1/'; // 域名
let protocol = 'http'; //协议
let baseUrl = 'www.xk888.com/service/v1/'; // 域名
export const config = {
	baseUrl: `${protocol}://${baseUrl}`
}

const arr = [
	'mobile',
	'express_mobile',
	'doctor',
	'accept_tel',
	'patient_mobile',
	'id_card',
	'idcard',
	'password'
]

// 敏感数据
const sensitiveData = [
	'id_card',
	'idcard'
]
/**
 * 请求拦截器
 * @param {*} options
 */
const reqInterceptor = async (options) => {
	// 加密
	if (options.data != null) {
		options.data = getRes(options.data, false)
	}
	options.header = {
		...options.header
	}
    const isToken = (options.header || {}).isToken === false
	if (uni.getStorageSync('token') && !isToken) {
		options.header['authorization'] = `Bearer ${uni.getStorageSync('token')}`// 让每个请求携带自定义token 请根据实际情况自行修改
	}
	return options;
}

/**
 * 响应拦截器
 */
const resInterceptor = (response, conf = {}) => {
	// 网络状态码
	const statusCode = response.statusCode|| response.errcode;
	// 响应拦截器
	if (statusCode >= 200 && statusCode < 300) {
		_responseLog(response, conf, "response 200-299")
		// 解密
		let res = response.data
		if (res.data != null) {
			res.data = getRes(res.data)
		}
		return res
	} else if (statusCode === 500) {
		uni.showToast({
			icon: 'error',
			title: response['msg'] || errorCode[statusCode]
		})
		_responseLog(response, conf, "response 500")
		// 增加一个控制字段wakaryReqToReject 使 reject的内容更加可控
		return {
			// 根据当前字段来判断是否reject
			wakaryReqToReject: true,
			// 下面可以配置其他返回信息，方便统一处理reject
			// 以下内容作为reject的返回，根据需求处理，返回具体错误信息
			msg: "服务器错误",
			res: response
		}
	} else if (statusCode === 401) {
		uni.showToast({
			icon: 'error',
			title: response['msg'] || errorCode[statusCode]
		})
		uni.removeStorageSync()
		setTimeout(()=>{
			uni.navigateTo({
				url:'/pages/login/index'
			})
		},1000)
		_responseLog(response, conf, "response 401")
		// 增加一个控制字段wakaryReqToReject 使 reject的内容更加可控
		return {
			// 根据当前字段来判断是否reject
			wakaryReqToReject: true,
			// 下面可以配置其他返回信息，方便统一处理reject
			// 以下内容作为reject的返回，根据需求处理，返回具体错误信息
			msg: response['msg'] || errorCode[statusCode],
			res: response
		}
	} else {
		uni.showToast({
			icon: 'error',
			title: response['msg'] || errorCode[statusCode]
		})
		_responseLog(response, conf, "response 300-499");
		// 增加一个控制字段wakaryReqToReject 使 reject的内容更加可控
		return {
			// 根据当前字段来判断是否reject
			wakaryReqToReject: true,
			// 下面可以配置其他返回信息，方便统一处理reject
			// 以下内容作为reject的返回，根据需求处理，返回具体错误信息
			msg: "response 300-499",
			res: response
		}
	}
}

/**
 * request log
 */
function _requestLog(req, describe = null) {
	if (process.env.NODE_ENV === 'development') {}
}

/**
 * response log
 */
function _responseLog(res, conf = {}, describe = null) {
	let _statusCode = res.statusCode;
	if (process.env.NODE_ENV === 'development') {}

	if (_statusCode === 500) {
		// save log to server
	}
}

function getRes(obj, isDecode = true) {
	try {
		for (const key in obj) {
			if (Array.isArray(obj[key])) {
				obj[key] = getRes(obj[key])
			} else if (typeof obj[key] === 'object') {
				obj[key] = getRes(obj[key])
			} else {
				// 判断obj[key]是否在arr中
				if (arr.indexOf(key) !== -1) {
					let aseFile = ''
					if (isDecode === true) {
						aseFile = customBase64Decode(obj[key])
					} else {
						aseFile = customBase64Encode(obj[key])
					}
					const isGarbled = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\xFF]|[\u{E000}-\u{F8FF}]/u.test(
						typeof aseFile === 'string' ? aseFile : ''
					)
					if (isGarbled) {
						aseFile = obj[key]
					}
					if (isDecode === true) {
						if (sensitiveData.indexOf(key) !== -1) {
							// 数据脱敏，自动匹配姓名、手机号、身份证
							switch (key) {
								case 'express_name':
								case 'express_region':
								case 'accept_name':
								case 'patient':
									// 保留前两个字符，其余用星号代替
									aseFile = aseFile.slice(0, 1).padEnd(aseFile.length, '*');
									break;
								case 'mobile':
								case 'express_mobile':
									// 保留前三位和后四位，中间用星号代替
									aseFile = aseFile.slice(0, 3).padEnd(aseFile.length - 4, '*') + aseFile.slice(-4);
									break;
								case 'id_card':
								case 'idcard':
									// 保留前六位和后四位，中间用星号代替
									aseFile = aseFile.slice(0, 6).padEnd(aseFile.length - 4, '*') + aseFile.slice(-4);
									break;
								default:
									// 默认情况下，全部用星号代替
									break;
							}
						}
					}
					obj[key] = aseFile
				}
			}
		}
		return obj
	} catch (error) {
		console.error('错误', error)
		return obj
	}
}

function customBase64Decode(data) {
	// return data
	try {
		// 第一次Base64解码
		const decodedFirst = Base64.decode(data)
		// 截取从第30个字符开始往后的内容
		const subStr = decodedFirst.slice(30)
		// 第二次Base64解码
		return Base64.decode(subStr) != ''? Base64.decode(subStr): data
	} catch (error) {
		console.error(`解码Base64字符串【${data}】时发生错误`, error)
		return data
	}
}

// 加密
function customBase64Encode(data) {
	if (data == null || data === '') return data
	// return data
	try {
		// 和加密方法差不多但是是要生成30个随机字符
		let randomString = ''
		for (let i = 0; i < 30; i++) {
			const randomChar = String.fromCharCode(Math.floor(Math.random() * (126 - 32 + 1)) + 32)
			randomString += randomChar
		}
		const encoded = Base64.encode(data)
		return Base64.encode(randomString + encoded)
	} catch (error) {
		console.error(`加密字符串【${data}】时发生错误`, error)
		return data
	}
}


/**
 * 请求方法封装
 */

export  const req = new Request(config, reqInterceptor, resInterceptor)