import frceArr from './frce';

export default {
	//获取图片
	imgPreview(file, callback) {
		let self = this;
		let name = file.name.split('.')[0]
		//判断支不支持FileReader
		if (!file || !window.FileReader) return;
		if (/^image/.test(file.type)) {
			//创建一个reader
			let reader = new FileReader();
			//将图片转成base64格式
			reader.readAsDataURL(file);
			//读取成功后的回调
			reader.onloadend = function () {
				let result = this.result;
				let img = new Image();
				let formData = new FormData();
				img.src = result;
				img.onload = function () {
					let data = self.compress(img);
					let blob = self.dataURItoBlob(data);
					formData.append("file", blob, name + '.jpeg');
					//图片预览,配置文件,formData数据;
					callback && callback(data, formData);
				};
			};
		}
	},
	// 压缩图片
	compress(img) {
		let canvas = document.createElement("canvas");
		let ctx = canvas.getContext("2d");
		// let initSize = img.src.length;
		let width = img.width;
		let height = img.height;
		canvas.width = width;
		canvas.height = height;
		// 铺底色
		ctx.fillStyle = "#fff";
		ctx.fillRect(0, 0, canvas.width, canvas.height);
		ctx.drawImage(img, 0, 0, width, height);

		//进行压缩
		let ndata = canvas.toDataURL("image/jpeg", 0.4);
		// console.log("*******压缩后的图片大小*******");
		// console.log(ndata)
		return ndata;
	},

	// base64转成bolb对象
	dataURItoBlob(base64Data) {
		var byteString;
		if (base64Data.split(",")[0].indexOf("base64") >= 0)
			byteString = atob(base64Data.split(",")[1]);
		else byteString = unescape(base64Data.split(",")[1]);
		var mimeString = base64Data
			.split(",")[0]
			.split(":")[1]
			.split(";")[0];
		var ia = new Uint8Array(byteString.length);
		for (var i = 0; i < byteString.length; i++) {
			ia[i] = byteString.charCodeAt(i);
		}
		return new Blob([ia], {type: mimeString});
	},


	//
	setApiToken(name, controller, time, modules) {
		let str = name + 'customer-service' + controller + time + modules
		return str.toLocaleLowerCase()
	},

	/**
	 * 时间戳转日期自定义时间格式
	 * timeStamp:时间戳
	 * custom:转换日期时定义年月日用是什么符号隔开
	 * isDtae:0=月份、1=日期、3=时间
	 */
	customFormatDateTime(timeStamp, custom, isDtae) {
		var date = new Date();
		date.setTime(timeStamp * 1000);
		var y = date.getFullYear();
		var m = date.getMonth() + 1;
		m = m < 10 ? ('0' + m) : m;
		var d = date.getDate();
		d = d < 10 ? ('0' + d) : d;
		var h = date.getHours();
		h = h < 10 ? ('0' + h) : h;
		var minute = date.getMinutes();
		var second = date.getSeconds();
		minute = minute < 10 ? ('0' + minute) : minute;
		second = second < 10 ? ('0' + second) : second;
		if (isDtae == 0) {
			return y + custom + m //+'student';
		} else if (isDtae == 1) {
			return y + custom + m + custom + d;
		} else if (isDtae == 3) {
			return h + ':' + minute //+ ':' + second;
		} else {
			return y + '-' + m + '-' + d + ' ' + h + ':' + minute //+ ':' + second;
		}
	},

	/*****************提示关键字及记录次数******************/
	/**
	 *
	 * @param {*} data
	 * @param {*} sensitive
	 * @param {*}
	 */
	shieldingKeyword(data, sensitive) {
		//将敏感词组用|转换字符串
		let snstive = sensitive.join('|');
		let num = 0, text = '';
		//匹配出会话中的敏感词
		data.replace(eval('/' + snstive + '/g'), (res) => {
			text += ',' + res;
			num++;
		})
		return {
			text,
			num
		}
	},

	/*****************用户屏蔽关键字******************/
	/**
	 *
	 * @param {*} data
	 * @param {*} sensitive
	 * @param {*}
	 */
	userShieldingKeyword(data, sensitive) {
		//将敏感词组用|转换字符串
		let snstive = sensitive.join('|');
		let num = 0, text = '';
		//匹配出会话中的敏感词
		return data.replace(eval('/' + snstive + '/g'), (res) => {
			var str = '';
			for (var i = 0; i < res.length; i++) {
				str += '*';
			}
			return str;
		})
	},


	/******************访客接入*********************/
	/**
	 *
	 * @param {object} redata  接收消息源
	 * @param {Array} offlineList  访客离线列表
	 * @param {Array} sessionList  访客会话列表
	 * @param {int} sessionType 选择列表状态默认未1(1是会话中，2是离线)
	 * @param {int} dataIndex  定位当前会话，默认是0
	 * @param {Array} dataList 当前会话信息列表
	 * @param {string} user_name 当前会话访客名
	 * @param {function} callback   访客匹配离线列表处理后链接回调方法
	 * @param {function} callback1   访客正常链接回调方法
	 */
	visitorsConnect([redata, offlineList, sessionList, sessionType, dataIndex, dataList, user_name], callback, callback1) {
		// console.log('将会话工单写入访客信息',redata);
		// console.log('访客信息评价',evaluate);
		if (redata.evaluate_id > 0) {
			redata.user_info.isEva = 10;
		}
		//将会话工单写入访客信息
		redata.user_info.conversationId = redata.conversationId;
		//默认离线列表没有访客信息
		let isTrue = true;
		let name = '';
		let sessionInfo = '';

		//匹配是否是离线用户上线
		if (offlineList.length > 0) {
			for (let i = 0; i < offlineList.length; i++) {
				//匹配离线列表是否有这个用户
				if (offlineList[i].id == redata.user_info.id) {
					//查询离线列表是否有此用户会话工单未结束
					if (offlineList[i].conversationId == redata.conversationId) {
						// console.log(sessionType,offlineList);
						//工单号未结束的数据获取历史聊天消息和对象名字
						if (sessionType == 2 && i == dataIndex) {//客服选中离线重新链接访客
							dataList = [];
							dataList = offlineList[i].data;
							name = offlineList[i].nick_name ? offlineList[i].nick_name : offlineList[i].name;
							sessionType = 1;
							dataIndex = sessionList.length == 0 ? 0 : sessionList.length - 1;
						} else if (sessionType == 2 && i < dataIndex) {//客服选中离线列表重新链接访客后面的访客
							if (i > 0) {
								dataList = offlineList[i].data;
								name = offlineList[i].nick_name ? offlineList[i].nick_name : offlineList[i].name;
							}
						} else {
							name = redata.user_info.nick_name ? redata.user_info.nick_name : redata.user_info.name;
						}
						//将掉线前聊天消息写入到用户对象里面
						redata.user_info.data = offlineList[i].data;
					} else {
						//工单号已结束数据处理
						if (dataIndex == 0 && sessionList.length == 0) {
							name = redata.user_info.nick_name ? redata.user_info.nick_name : redata.user_info.name;
							dataList = [];
						}
						redata.user_info.data = [];
					}
					//获取离线列表数据
					sessionInfo = offlineList[i]
					//将离线状态用户删除
					offlineList.splice(i, 1);

					isTrue = false;
					//回调
					callback && callback(offlineList);
					break;
				}
			}
		}

		//新访客链接
		if (isTrue) {
			if (sessionList.length == 0) {
				//判断是否选离线用户列表
				if (offlineList.length > 0 && sessionType == 2) {
					//不做处理

				} else {
					dataIndex = 0;
					sessionType = 1;
					// console.log(redata.user_info.nick_name,redata.user_info.name);
					name = redata.user_info.nick_name ? redata.user_info.nick_name : redata.user_info.name;
					dataList = [];
				}
			} else {
				for (let i = 0; i < sessionList.length; i++) {
					//匹配离线列表是否有这个用户
					if (sessionList[i].id == redata.user_info.id) {
						sessionList.splice(i, 1);
						break;
					}
				}

				//判断接入用户是否有昵称展示
				redata.user_info.name = redata.user_info.nick_name ? redata.user_info.nick_name : redata.user_info.name;
			}
			//历史会话消息
			if (redata.history.length > 0) {
				let chatData = [];
				redata.history.forEach(e => {
					let content = JSON.parse(e.content);
					let obj = {
						text: this.turnFace(content.text, frceArr.frce),
						img: content.img,
						type: false,
					};
					if (e.from_id.startsWith("KF")) {
						//this.turnFace(redata.content.text,frceArr.frce);
						chatData.push({
							type: 'service',
							content: obj,
							time: this.customFormatDateTime(e.time_line, '', 3)
						})
					} else {
						chatData.push({type: 'user', content: obj, time: this.customFormatDateTime(e.time_line, '', 3)})
					}
				})
				redata.user_info.data = chatData;
				dataList = chatData;
			} else {
				redata.user_info.data = [];
			}
		} else {
			redata.user_info.data = sessionInfo.data
		}
		// console.log(name);
		//回调
		callback1 && callback1(redata, sessionList, offlineList, sessionType, dataIndex, dataList, name);
	},

	/*****************用户会话离线及相关数据*********************/
	/**
	 * @param {object} redata  接收消息源
	 * @param {Array} sessionList  访客会话列表
	 * @param {Array} offlineList  访客离线列表
	 * @param {int} sessionType 选择列表状态默认未1(1是会话中，2是离线)
	 * @param {int} dataIndex  定位当前会话，默认是0
	 * @param {string} user_name 当前会话访客名
	 * @param {Array} dataList 当前会话信息列表
	 * @param {*} callback  回调函数
	 */
	userOffline([redata, sessionList, offlineList, sessionType, dataIndex, user_name, dataList], callback) {
		let userInfo = [];
		for (let i = 0; i < sessionList.length; i++) {
			//匹配会话中离线用户
			if (sessionList[i].id == redata.id) {
				//把数据添加到离线列表
				offlineList.push(sessionList[i]);
				//用户选中状态会话中处理
				if (sessionType == 1) {
					//判断会话中列表长度
					if (sessionList.length > 1) {
						//判断是否离线用户是当前选中状态
						if (dataIndex == i) {
							dataIndex = 0;
							user_name = sessionList[0].name;
							dataList = sessionList[0].data;
							userInfo = sessionList;
						}
						//删除会话列表离线用户
						sessionList.splice(i, 1);
					} else {
						sessionType = 2;
						dataIndex = 0;
						user_name = offlineList[0].name;
						dataList = offlineList[0].data;
						userInfo = offlineList;
						sessionList.splice(i, 1);
					}
				}
				callback && callback(sessionList, offlineList, sessionType, dataIndex, user_name, dataList, userInfo);
				break;
			}
		}
	},

	/**************删除会话中离线用户及相关数据**************/
	/**
	 * @param {object} redata  接收消息源
	 * @param {Array} sessionList  访客会话列表
	 * @param {Array} offlineList  访客离线列表
	 * @param {int} sessionType 选择列表状态默认未1(1是会话中，2是离线)
	 * @param {int} dataIndex  定位当前会话，默认是0
	 * @param {string} user_name 当前会话访客名
	 * @param {Array} dataList 当前会话信息列表
	 * @param {*} callback  回调函数
	 */

	sessionEnd([redata, sessionList, offlineList, sessionType, dataIndex, user_name, dataList], callback) {
		let isTrue = true;
		let userInfo = [];
		// console.log('哈哈',sessionList);
		//会话中列表匹配
		if (sessionList.length > 0) {
			for (let i = 0; i < sessionList.length; i++) {
				//检测会话列表中是否有结束的会话对象
				if (sessionList[i].id == redata.id) {
					//删除会话列表中结束的会话对象用户信息
					sessionList.splice(i, 1);
					// this.$store.dispatch("SET_SESSION",sessionList);
					if (sessionType == 1) {
						if (sessionList.length > 1) {
							//处理会话显现状态
							if (dataIndex == i) {
								user_name = sessionList[0].name;
								dataList = sessionList[0].data;
								userInfo = sessionList;
							}
						} else {
							if (offlineList.length > 0) {
								sessionType = 2;
								dataIndex = 0;
								userInfo = offlineList;
							} else {
								user_name = '';
								dataList = [];
								userInfo = '';
							}
						}
					}
					isTrue = false;
					break;
				}
			}
		}
		//离线列表查询
		if (isTrue) {
			for (let i = 0; i < offlineList.length; i++) {
				//判断离线列表是否结束会话
				if (offlineList[i].id == redata.id) {
					//删除离线列表中结束会话的用户信息
					offlineList.splice(i, 1);
					// this.$store.dispatch("SET_OFFLINE",offlineList);
					if (sessionType == 2) {
						if (dataIndex == i) {
							if (offlineList.length > 1) {
								if (sessionList.length > 0) {
									dataList = sessionList[0].data;
									user_name = sessionList[0].name;
									userInfo = sessionList;
								} else {
									dataList = offlineList[0].data;
									user_name = offlineList[0].name;
									userInfo = offlineList;
								}
							} else {
								if (sessionList.length > 0) {
									dataList = sessionList[0].data;
									user_name = sessionList[0].name;
									userInfo = sessionList;
								} else {
									dataList = [];
									user_name = '';
									userInfo = '';
								}
							}
						}
					}
					break;
				}
			}
		}
		console.log('测试掉线', sessionList);
		//回调
		callback && callback(sessionList, offlineList, sessionType, dataIndex, user_name, dataList, userInfo);

	},


	/*****************接收用户会话消息***************/
	/**
	 *
	 * @param {*} redata 数据源
	 * @param {*} sessionList 会话列表
	 * @param {*} frce 表情数据源
	 * @param {*} callback  回调
	 */
	receivesMessage(redata, sessionList, frce, callback) {
		let dataIndex = 0;
		if(sessionList.length<1){
			return -2001;
		}
		//匹配是那个用户回的消息
		for (let i = 0; i < sessionList.length; i++) {
			if (sessionList[i].id == redata.id) {
				dataIndex = i;
				break;
			}
		}


		//获取当前回复消息对象
		let chatList = sessionList[dataIndex]

		redata.type = 'user';
		redata.content = JSON.parse(redata.content);
		//这个地方转
		redata.content.text = this.turnFace(redata.content.text, frce);
		//将消息添加对应的会话列表中
		chatList.data.push(redata);
		callback && callback(redata, chatList, dataIndex);
	},

	/******************文字信息转表情******************/
	/**
	 * @param {*} data
	 * @param {*} frce
	 */
	turnFace(data, frce) {
		let str = data.match(/\#\[.*?\]\//g);
		let arr = Array.from(new Set(str));
		arr.forEach(e => {
			let imgsrc = '';
			for (let i = 0; i < frce.length; i++) {
				let expText = e.slice(1, e.length - 1);
				if (expText == frce[i]) {
					imgsrc = '<img class="hover" src="' + require(`@/assets/img/${i}.gif`) + '"/>'
					break;
				}
			}
			data = data.replace(new RegExp(`\\#\\[${e.substring(2, e.length - 2)}\\]\\/`, 'g'), imgsrc);
		})
		return data;
	},

	getQueryString(name) {
		var href=window.location.href;
		var url='';
		
		if(href.indexOf('/#/')>-1){ //处理vue特有的带#号路径
			url=href.split('/#/');			
			url=url[1];
			if(url.indexOf('?')>-1){
				url=url.split('?');
				url=url[1];
			}
		}else{
			url=window.location.search.substr(1);
			
		}
		var reg = new RegExp('(^|&)' + name + '=([^&]*)(&|$)', 'i');
		var r = url.match(reg);
		if (r != null) {
			return unescape(r[2]);
		}
		return null;
	}
}