import {
	Base64
} from 'js-base64';
import {
	wxDecryptData
} from '@/common/WXBizDataCrypt.js'

import {

	login as loginOrg,
	loginWeChat,
	loginDingTalk,
	getDingToken,
	getWeChatToken,
	getFileSvrInfo

} from "./org.js"
import {
	httpRequest,
} from "./gungho/index.js"
import {
	token as tokenFeishu,
	accesstoken as accesstokenFeishu,
	getCode as getCodeFeishu,
	getUserInfo as getUserInfoFeishu,

} from "./request/feishu.js"
import {
	getAuthCode as getDingAuthCode,

} from "./request/ding.js"

import {
	getCode as getCodeWxQy,
	checkSession as checkSessionWxQy,
	getMobile as getMobileWxQy,

} from "./request/wxqy.js"

import {
	getUploadUrl,
	putFile,
	uploadTask,
	callback,
	getDownloadUrl

} from "./request/minio.js"


export const getDingAutoLoginInfo = () => {
	return new Promise(async (resolve, reject) => {
		try {
			const app = getApp()

			const code = await getDingAuthCode() || ""
			const tokenRes = await getDingToken()
			const access_token = tokenRes.token || ""
			if (!access_token) {
				return reject("服务端没有配置钉钉应用相关信息，请联系管理员配置！")
			}
			app.globalData.dingding = {
				access_token: access_token,
				authCode: code,
			}
			let sUrl =
				`https://oapi.dingtalk.com/topapi/v2/user/getuserinfo?access_token=${access_token}`
			let dataStr = `code=${code}`

			let res = await httpRequest(sUrl, "POST", dataStr)
			const userId = res.userid || ""

			dataStr = `userid=${userId}`
			sUrl = `https://oapi.dingtalk.com/topapi/v2/user/get?access_token=${access_token}`
			const user = await httpRequest(sUrl, "POST", dataStr) || {}
			if (user.mobile) {
				let sMobile = user.mobile
				let nFind = user.mobile.indexOf("+86");
				if (nFind == 0) {
					sMobile = user.mobile.substr(3)
				}
				resolve({
					user_id: user.userid,
					mobile: sMobile
				})

			} else {
				reject("你没有获取用户ID和手机号权限，请联系管理员开通！")
			}

		} catch (ex) {
			reject(ex)
		}
	})
}

/**
 * 钉钉用户自动登录
 * @returns 
 */

export const autoLoginDing = () => {
	return new Promise(async (resolve, reject) => {
		try {
			let info = await getDingAutoLoginInfo()
			let res = await loginDingTalk(info.user_id, info.mobile)
			res.mobile = info.mobile
			res.user_id = info.user_id
			resolve(res)
		} catch (ex) {
			reject(ex)
		}
	})
}
/**
 * 飞书用户自动登录
 * @returns 
 */
export const autoLoginFeiShu = () => {
	return new Promise(async (resolve, reject) => {
		try {
			const app = getApp()
			const code = await getCodeFeishu()
			const token = await tokenFeishu()
			if (!token) {
				return reject("访问飞书失败，请联系小程序开发商！")
			}
			const access_token = await accesstokenFeishu(code, token) || ""
			if (!access_token) {
				return reject("访问飞书失败，请联系小程序开发商！")
			}
			const user = await getUserInfoFeishu(access_token)
			if (user.mobile) {
				let sMobile = user.mobile
				let nFind = user.mobile.indexOf("+86");
				if (nFind == 0) {
					sMobile = user.mobile.substr(3)
				}
				const res3 = await loginWeChat(user.user_id, sMobile)
				res3.mobile = sMobile
				res3.user_id = user.user_id
				resolve(res3)
			} else {
				return reject("你没有获取用户ID和手机号权限，请联系管理员开通！")
			}

		} catch (ex) {
			reject(ex)
		}
	})
}

/**
 * 企业微信用户自动登录
 * @returns 
 */
export const loginWxQy = () => {
	return new Promise(async (resolve, reject) => {
		try {
			const app = getApp()
			const code = await getCodeWxQy()
			const tokenRes = await getWeChatToken()
			const token = tokenRes.token || ""
			if (!token) {
				return reject("服务端没有配置企业微信应用相关信息，请联系管理员配置！")
			}
			let sUrl =
				'https://qyapi.weixin.qq.com/cgi-bin/miniprogram/jscode2session?access_token=' +
				token + '&js_code=' + code + '&grant_type=authorization_code'
			let dataStr = `code=${code}`
			const resWx = await httpRequest(sUrl) || {}
			app.globalData.qyWx.userid = resWx.userid
			app.globalData.qyWx.session_key = resWx.session_key
			resolve(resWx)
		} catch (ex) {
			reject(ex)
		}
	})
}


/**
 * 企业微信用户自动登录
 * @returns 
 */
export const autoLoginWxQy = () => {
	return new Promise(async (resolve, reject) => {
		try {
			const app = getApp()
			const bRet = await checkSessionWxQy()
			if (!bRet) {
				await loginWxQy()
			}
			const res = await getMobileWxQy()
			const res2 = await wxDecryptData(app.globalData.appid, app.globalData.qyWx
				.session_key, res
				.encryptedData, res.iv)
			const res3 = await loginWeChat(app.globalData.qyWx.userid, res2.mobile)
			res3.mobile = res2.mobile
			res3.user_id = user.user_id
			resolve(res3)
		} catch (ex) {
			reject(ex)
		}
	})
}


/**
 * 上传文件至minio
 * @param {*} file 
 */
export const uploadFile3 = (file) => {
	return new Promise(async (resolve, reject) => {
		try {
			// 准备用户信息
			const app = getApp()
			const userInfo = app.globalData.userdata
			// 得到文件服务器信息
			let fileSFlag = app.globalData.files_flag || userInfo.files_info?.flag
			const fileSvrInfo = await getFileSvrInfo(fileSFlag)
			// 准备文件信息
			let md5 = file.md5
			// 得到接口地址
			let ip = fileSvrInfo.exter_ip || fileSvrInfo?.inter_ip
			let port = fileSvrInfo.exter_port || fileSvrInfo?.inter_port
			let isSSL = fileSvrInfo?.is_ssl || false
			let svrUrl = `${isSSL?'https':'http'}://${ip}:${port}`

			if (!ip) throw new Error(`文件服务器“${fileSFlag}”配置不正确，exter_ip为空`)
			if (!port) throw new Error(`文件服务器“${fileSFlag}”配置不正确，exter_port为空`)
			// 得到文件上传地址


			let uploadUrlInfo = await getUploadUrl(svrUrl, Base64.encode(JSON.stringify(fileSvrInfo
					.minio)), file
				.name)
			// 上传文件

			await putFile(uploadUrlInfo.uldurl, file)

			let res = await callback(
				svrUrl,
				uploadUrlInfo.savepath,
				file.size,
				file.name,
				md5,
				userInfo.user_login,
				userInfo.user_name,
				fileSvrInfo.minio.access,
				fileSvrInfo.minio.secret
			)
			// 文件id
			let {
				id,
				createtime
			} = res
			let downloadUrlInfo = await getDownloadUrl(svrUrl, Base64.encode(JSON
					.stringify(fileSvrInfo.minio)),
				id, file.name)
			let url = downloadUrlInfo.dldurl
			resolve({
				id,
				filesflag: fileSFlag,
				name: file.name,
				url: url,
				size: file.size,
				md5,
				createtime
			})
		} catch (ex) {
			let tip = typeof ex == 'string' ? ex : ex.message
			console.log(ex)
			throw new Error(`上传文件至minio服务器失败：${tip}`)
		}
	})
}


export const uploadFile = async (file, cbSuccess, cbProgress, cbFail) => {
	try {
		// 准备用户信息
		const app = getApp()
		const userInfo = app.globalData.userdata

		// 得到文件服务器信息
		let fileSFlag = app.globalData.files_flag || userInfo.files_info?.flag
		if (!fileSFlag) {
			return cbFail({
				errMsg: `未设置文件服务标识`,
				path: file.path
			})
		}
		const fileSvrInfo = await getFileSvrInfo(fileSFlag)

		// 准备文件信息
		let md5 = file.md5
		// 得到接口地址
		let ip = fileSvrInfo.exter_ip || fileSvrInfo?.inter_ip
		let port = fileSvrInfo.exter_port || fileSvrInfo?.inter_port
	let isSSL = fileSvrInfo?.is_ssl || false
	let svrUrl = `${isSSL?'https':'http'}://${ip}:${port}`
		if (!ip) {
			return cbFail({
				errMsg: `文件服务器“${fileSFlag}”配置不正确，exter_ip为空`,
				path: file.path
			})
		}
		if (!port) {
			return cbFail({
				errMsg: `文件服务器“${fileSFlag}”配置不正确，exter_port为空`,
				path: file.path
			})
		}
		if (fileSvrInfo?.is_ssl)
			fileSvrInfo.minio.is_ssl = true
		// 得到文件上传地址
		let uploadUrlInfo = await getUploadUrl(svrUrl, Base64.encode(JSON.stringify(fileSvrInfo.minio)), file
			.name, file.public)

		// 上传文件
		const task = uploadTask(uploadUrlInfo.uldurl, file, uploadUrlInfo.formdata, async (param) => {
			// 写数据库
			let res = await callback(
				svrUrl,
				uploadUrlInfo.savepath,
				file.size,
				file.name,
				md5,
				userInfo.user_login,
				userInfo.user_name,
				fileSvrInfo.minio.access,
				fileSvrInfo.minio.secret
			)

			// 文件id
			let {
				id,
				createtime
			} = res

			// let downloadUrlInfo = await getDownloadUrl(svrUrl, Base64.encode(JSON.stringify(
			// 		fileSvrInfo.minio)),
			// 	id, file.name)
			let url = file.path // downloadUrlInfo.dldurl
			if (file.public) {
				url = `/${uploadUrlInfo.bucketname}/${uploadUrlInfo.savepath}`
			}

			if (typeof cbSuccess == "function") {
				console.log(url)
				cbSuccess({
					id,
					filesflag: fileSFlag,
					name: file.name,
					url,
					size: file.size,
					md5,
					createtime,
					savepath: uploadUrlInfo.savepath,
				})

			}

		}, (param1, param2) => {
			if (typeof cbProgress == "function") {
				cbProgress(param1, param2)
			}
		}, (param) => {
			console.log(cbFail)
			if (typeof cbFail == "function") {
				cbFail(param)
			}
		})
		return task

	} catch (ex) {
		let tip = typeof ex == 'string' ? ex : ex.message
		console.log(ex)
		cbFail({
			errMsg: `上传文件至minio服务器失败：${tip}`,
			path: file.path
		})
	}
}
/**
 * minio public文件访问地址
 * @returns 
 */
export const publicFileUrl = async (fileSFlag, subUrl) => {
	try {

		if (!fileSFlag) return subUrl
		// 得到文件服务器信息
		const fileSvrInfo = await getFileSvrInfo(fileSFlag)
		 console.log("publicFileUrl",fileSvrInfo)
		// 得到接口地址
		let ip = fileSvrInfo?.minio?.exter_ip || fileSvrInfo?.minio?.inter_ip
		let port = fileSvrInfo?.minio?.exter_port || fileSvrInfo?.minio?.inter_port
		let isSSL = fileSvrInfo?.is_ssl || false
		let svrUrl = `${isSSL?'https':'http'}://${ip}:${port}`
		if (!ip) return subUrl
		if (!port) return subUrl
		let url = `${svrUrl}${subUrl}`
		return url
	} catch (ex) {
		return subUrl
	}
}
/**
 * minio下载文件
 * @param {*} fileId 
 * @param {*} fileName 
 * @param {*} fileServer 
 * @returns 
 */
export const downloadFileUrl = async (fileId, fileName, fileSFlag) => {
	try {
		if (!fileSFlag) throw new Error('未指定文件服务器标识')
		// 得到文件服务器信息
		const fileSvrInfo = await getFileSvrInfo(fileSFlag)
		 console.log("downloadFileUrl",fileSvrInfo)
		// 得到接口地址
		let ip = fileSvrInfo.exter_ip || fileSvrInfo?.inter_ip
		let port = fileSvrInfo.exter_port || fileSvrInfo?.inter_port
		let isSSL = fileSvrInfo?.is_ssl || false
		let svrUrl = `${isSSL?'https':'http'}://${ip}:${port}`
		if (!ip) throw new Error(`文件服务器“${fileSFlag}”配置不正确，exter_ip为空`)
		if (!port) throw new Error(`文件服务器“${fileSFlag}”配置不正确，exter_port为空`)
		if (fileSvrInfo?.is_ssl)
			fileSvrInfo.minio.is_ssl = true
		fileId = fileId.replace("{", "").replace("}", "");
		// 得到文件下载地址
		let downloadUrlInfo = await getDownloadUrl(svrUrl, Base64.encode(JSON.stringify(fileSvrInfo.minio)),
			fileId, fileName)
		let url = downloadUrlInfo.dldurl
		return url
	} catch (ex) {
		let tip = typeof ex === 'string' ? ex : ex.errMsg ||  ex.message  
		throw new Error(`minio下载文件失败：${tip}`)
	}
}

export const downloadFileTask = (url, cbSuccess, cbProgress, cbFail) => {
	const app = getApp()
	const downloadTask = uni.downloadFile({
		url,
		success: (result) => {
			//#ifdef MP-MP-WEIXIN || MP-LARK
			if (result.statusCode === 200) {
				console.log("downloadTaskFile success", result)
				var res = {}
				res.url = url;
				res.path = result.tempFilePath
				cbSuccess(res)
			} else {
				console.log("downloadTaskFile err", result)
				var res = {}
				res.errMsg = result.data || '下载未知错误!';
				res.url = url;
				cbFail(res);
			}
			return
			// #endif
			console.log("downloadTaskFile success", result)
			var res = {}
			res.url = url;
			res.path = result.tempFilePath
			cbSuccess(res)
		},
		fail: (result) => {
			console.log("downloadTaskFile fail", result)
			var res = {}
			res.url = url;
			res.errMsg = '下载文件失败!';
			cbFail(res);
		}
	})
	downloadTask.onProgressUpdate((res) => {
		if (res.progress != null) {
			console.log('下载进度', res.progress);
			console.log('已经下载的数据长度', res.totalBytesWritten);
			console.log('预期需要下载的数据总长度', res.totalBytesExpectedToWrite);
			res.url = url;
			cbProgress(res, downloadTask)
		}

	});
}