import printerUtil from '@/components/print/printerutil.js'
const PrinterJobs = require('@/components/print/printerjobs.js')
// import {
// 	getDate
// } from '@/utils/dateTime.js'
export default {
	data() {
		return {

			list: [],
			deviceId: '',
			serviceId: '',
			characteristics: [],
			characteristicId: '',
			deviceslist: []
		}
	},
	onShow() {
		this.list = []
		this.deviceslist = []

	},
	methods: {
		//初始化蓝牙设备
		openBluetoothAdapter() {
			let _this = this
			uni.openBluetoothAdapter({
				success: (res) => { //已打开
					uni.getBluetoothAdapterState({ //蓝牙的匹配状态
						success: (res1) => {
							console.log(res1, '本机设备的蓝牙已打开')
							// 开始搜索蓝牙设备

							_this.startBluetoothDeviceDiscovery()
							uni.setStorageSync('blueShow', true)
						},
						fail(error) {
							uni.showToast({
								icon: 'none',
								title: '查看手机蓝牙是否打开err'
							});
						}
					});

				},
				fail: err => { //未打开 
					uni.setStorageSync('blueShow', false)
					uni.showToast({
						icon: 'none',
						title: '查看手机蓝牙是否打开'
					});
				}
			})
		},
		// 开始搜索蓝牙设备
		startBluetoothDeviceDiscovery() {
			uni.startBluetoothDevicesDiscovery({
				success: (res) => {
					// 发现外围设备
					uni.showLoading({
						title: '加载中',
						mask: true
					});
					this.onBluetoothDeviceFound()
				},
				fail: err => {
					console.log(err, '错误信息')
				}
			})
		},
		// 发现外围设备
		onBluetoothDeviceFound() {
			uni.onBluetoothDeviceFound((res) => {
				this.deviceslist.length > 0 ? uni.hideLoading() : ''
				if (this.deviceslist.indexOf(res.devices[0].deviceId) == -1) {
					this.deviceslist.push(res.devices[0].deviceId)
					if (res.devices[0].name != "") {
						uni.hideLoading();
						this.list.push({
							name: res.devices[0].name,
							deviceId: res.devices[0].deviceId
						})
					}
				}
			})
		},
		//获取在蓝牙模块生效期间所有已发现的蓝牙设备。包括已经和本机处于连接状态的设备。
		getBluetoothDevices() {
			console.log("获取蓝牙设备");
			uni.getBluetoothDevices({
				success: res => {
					console.log('获取蓝牙设备成功:');
					console.log(res.devices);
				}
			});
		},
		//选择设备连接吧deviceId传进来
		createBLEConnection(deviceId) {
			//data里面建立一个deviceId，存储起来
			let _this = this
			uni.showLoading({
				title: '连接蓝牙中...',
				mask: true
			});
			this.stopBluetoothDevicesDiscovery()

			this.deviceId = deviceId,
				//连接蓝牙
				uni.createBLEConnection({
					// 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
					deviceId: deviceId,
					success(res) {
						uni.hideLoading();
						// uni.showToast({
						// 	icon: 'none',
						// 	title: '蓝牙连接成功'
						// });
						uni.setStorageSync("deviceId", deviceId) //把已经连接的蓝牙设备信息放入缓存

						setTimeout(() => {
							_this.getBLEDeviceServices(deviceId)
						}, 1000)

					},
					fail(res) {
						uni.showToast({
							icon: 'none',
							title: '蓝牙连接失败'
						});
					}
				})
		},
		// 停止搜寻蓝牙设备
		stopBluetoothDevicesDiscovery() {
			uni.stopBluetoothDevicesDiscovery({
				success: e => {
					this.loading = false
					console.log('停止搜索蓝牙设备:' + e.errMsg);
				},
				fail: e => {
					console.log('停止搜索蓝牙设备失败，错误码：' + e.errCode);
				}
			});
		},
		//获取蓝牙特征
		getBLEDeviceCharacteristics(deviceId, serviceId,callback) {
			console.log("进入特征");
			setTimeout(() => {
				uni.getBLEDeviceCharacteristics({
					// 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
					deviceId: deviceId,
					// 这里的 serviceId 需要在 getBLEDeviceServices 接口中获取
					serviceId: serviceId,
					success: (res) => {
						console.log(res, '特征getBLEDeviceCharacteristics')
						this.characteristics = res.characteristics
						
						let _noCharacteristics = true;
						console.log('characteristics长度：'+res.characteristics.length)
						for (let i=0;i<res.characteristics.length;i++) {
							console.log(`characteristics${i}的uuid：${res.characteristics[i].uuid}`)
							if (res.characteristics[i].uuid.indexOf("FF02") != -1) {
								this.characteristicId = res.characteristics[i].uuid
								uni.setStorageSync("characteristicId", res.characteristics[i].uuid) //把已经连接的蓝牙设备标识放入缓存
								uni.setStorageSync("serviceId",serviceId) //把已经连接的蓝牙设备ID放入缓存
								setTimeout(() => {
									uni.hideLoading();
									this.BottomShow = false
									this.DrawerModalL = false
								}, 1000)
								_noCharacteristics=false;
								callback && callback(true)
								break;
							}
						}
						if (_noCharacteristics) {
							callback && callback(false)
						}
					},
					fail: (res) => {
						console.log(res)
						callback && callback(false)
					}
				})
			}, 1000)
		},
		// 启用 notify 功能
		notifyBLECharacteristicValueChange(characteristicId) {
			let _this = this
			console.log('deviceId' + _this.deviceId)
			console.log('serviceId' + _this.serviceId)
			console.log('characteristicId' + characteristicId)
			// _this.fanhui()
			uni.notifyBLECharacteristicValueChange({
				state: true, // 启用 notify 功能
				// 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
				deviceId: this.deviceId,
				// 这里的 serviceId 需要在 getBLEDeviceServices 接口中获取
				serviceId: this.serviceId,
				// 这里的 characteristicId 需要在 getBLEDeviceCharacteristics 接口中获取
				characteristicId: characteristicId,
				success: (res) => {
					if (this.blueFlag == true) {
						this.writeBLECharacteristicValue()
					} else {
						uni.showLoading({
							title: '蓝牙服务获取成功，请打印',
							mask: true,
						});
					}

					setTimeout(() => {
						uni.hideLoading();
					}, 1000)
					// _this.fanhui()
					this.print = "打印"
					this.BottomShow = false

					console.log('notifyBLECharacteristicValueChange success', res.errMsg)
				},
				fail: (res) => {
					uni.showLoading({
						title: '蓝牙服务获取成功，请打印',
						mask: true,
					});
					setTimeout(() => {
						uni.hideLoading();
					}, 1000)
					_this.print = "打印"
					_this.BottomShow = false

					// _this.fanhui()
					console.log('notifyBLECharacteristicValueChange fail', res.errMsg)
				}
			})
		},
		//获取蓝牙的所有服务
		getBLEDeviceServices(deviceId) {
			uni.showLoading({
				title: '正在获取蓝牙服务...',
				mask: true,
			});
			setTimeout(() => {
				uni.getBLEDeviceServices({
					// 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
					deviceId: deviceId,
					success: (res) => {
						uni.showLoading({
							title: '获取中，请稍后...',
							mask: true,
						});
						let _noSer = true;
						console.log('services长度：'+res.services.length)
						for (let i=0;i<res.services.length;i++) {
							console.log(`services${i}的uuid：${res.services[i].uuid}`)
							if (res.services[i].uuid.indexOf("FF00") != -1) {
								_noSer = false;
								this.serviceId = res.services[i].uuid;
								//获取特征
								this.getBLEDeviceCharacteristics(deviceId, res.services[i].uuid,(fxx)=>{
									if (fxx) {
										uni.hideLoading()
										uni.showToast({
											title: '蓝牙连接成功！',
											icon: 'none',
											duration: 2000
										})
									} else {
										uni.hideLoading()
										uni.showToast({
											title: '取特征码失败',
											icon: 'error',
											duration: 2000
										})
									}
								})
								break;
							}
						}
						if (_noSer) {
							uni.hideLoading()
							uni.showToast({
								title: '取蓝牙服务失败',
								icon: 'error',
								duration: 2000
							})
						}
					},
					fail:()=>{
						 uni.hideLoading()
						uni.showToast({
							title: '获取蓝牙服务失败',
							icon: 'error',
							duration: 2000
						})
					}
				})
			}, 1000)
		},
		//写入蓝牙
		writeBLECharacteristicValue() {
			// this.printflag = false
			uni.showLoading({
				title: '打印中...',
				mask:true
			});
			
			
			let deviceId = uni.getStorageSync('deviceId')
			let serviceId = uni.getStorageSync('serviceId')
			let characteristicId = uni.getStorageSync('characteristicId')
			const printerJobs = new PrinterJobs();
			printerJobs
				.label_set_page(576, 400)
				//边框
				.drawLine(1, 0, 0, 570, 0)
				.drawLine(1, 0, 0, 0, 360)
				.drawLine(1, 570, 0, 570, 360)
				.drawLine(1, 0, 360, 570, 360)
				// 内部横线
				.drawLine(1, 0, 52, 400, 52) //第一行
				.drawLine(1, 0, 104, 400, 104) //第二行
				.drawLine(1, 0, 156, 570, 156) //第三行
				.drawLine(1, 0, 208, 570, 208) //第四行
				.drawLine(1, 0, 260, 570, 260) //第五行
				.drawLine(1, 0, 312, 570, 312) //第六行
				.drawLine(1, 120, 0, 120, 360) // 第一根竖线
				// .drawLine(1, 220, 208, 220, 312) // 第二根竖线
				// .drawLine(1, 300, 208, 300, 312) // 第三根竖线
				.drawLine(1, 400, 0, 400, 156) // 第四根竖线
				// 1 原始 是否粗体\字体大小\是否旋转角度\起始横坐标\起始纵坐标\字符串
				.drawText(10, 20, "制件状态", 24, 0, 0, false, false)
				.drawText(130, 20, this.stateText, 24, 0, 0, false, false)
				// 2
				.drawText(10, 72, "组盘单号", 24, 0, 0, false, false)
				.drawText(130, 72, this.cvi, 24, 0, 0, false, false)
				// 3
				.drawText(10, 124, "生产班线", 24, 0, 0, false, false)
				.drawText(130, 124, this.singlist.createLine, 24, 0, 0, false, false)
				// 4
				.drawText(10, 176, "零件1", 24, 0, 0, false, false)
				.drawText(130, 176, this.singlist.itemDes, 24, 0, 0, false, false)
				// 5
				.drawText(10, 225, "零件2", 24, 0, 0, false, false)
				.drawText(130, 225, this.singlist.itemName, 24, 0, 0, false, false)
				// 6
				.drawText(10, 280, "零件3", 24, 0, 0, false, false)
				.drawText(130, 280, this.singlist.itemNum, 24, 0, 0, false, false)
				// 7
				.drawText(10, 332, "生产日期", 24, 0, 0, false, false)
				.drawText(130, 332, this.singlist.updateTime, 24, 0, 0,
					false, false)
				// .drawText(440, 332, item.user, 24, 0, 0, false, false)
				// 二维码
				.drawQrCode(426, 14, this.containerCode, 0, 5, 1)
				// .drawText(434, 310, this.containerCode, 1, 0, 0, false, false)
				.label_print(0, 1);
			  let buffer = printerJobs.buffer();
				
				/* this._writeBLECharacteristicValue(deviceId, serviceId, characteristicId, buffer,(f)=>{
					uni.hideLoading();
					if (!f) {
						uni.showModal({
							title:'系统提示',
							content:'蓝牙传输错误！',
							showCancel:false
						})
					}
					
				}) */
				
				// 建议每次写入不超过20字节,分包处理
				/* let _i = 0,_length = buffer.byteLength,___continue = true;
				const maxChunk = 20;
				while (_i<_length) {
					if (!___continue) {
						uni.hideLoading();
						uni.showModal({
							title:'系统提示',
							content:'蓝牙传输错误！',
							showCancel:false
						})
						break;
					}
					
					
					if (!_writing) {
						_writing = true;
						let subPackage = buffer.slice(_i, (_i + maxChunk <= _length ? (_i + maxChunk) : _length));
						this._writeSubBLECharacteristicValue(deviceId, serviceId, characteristicId, subPackage,_i,(flagx)=>{
							if (!flagx) {
								___continue = false;
							} else {
								if (_i + maxChunk >= _length) {
									uni.hideLoading();
								} 
								_i = _i + maxChunk;
							}
							_writing = false;
						})
					}
				} */
				
				
				const maxChunk = 20;
				const delay = 15;
				let _writing = false;
				let length = buffer.byteLength;
				let pakageLen = Math.trunc(length/maxChunk);
				if (length%maxChunk!==0) pakageLen=pakageLen+1;
				console.log(`共${length}字节，分${pakageLen}包`)
				/* let i=0;
				let _errFlag = false;
				while (i<pakageLen) {
					if (_errFlag) {
						uni.hideLoading()
						uni.showToast({
							title: '打印出错',
							icon: 'error',
							duration: 2000
						})
						break;
					}
					
					if (!_writing) {
						_writing = true;
						let startI = i*maxChunk;
						console.log(`第${i}分包发送，开始字节${startI}`)
						let subPackage = buffer.slice(startI, startI + maxChunk <= length ? (startI + maxChunk) : length);
						this._writeBLECharacteristicValue(deviceId, serviceId, characteristicId, subPackage,(f)=>{
							console.log(`第${i}包返回${f}`)
							if (f) {
								if (i===pakageLen-1) {
									uni.hideLoading();
								}
								i++
							} else {
								_errFlag = true;
							}
							_writing = false;
						})
					}
				} */
				
				let successArr = [];
				for (let i = 0, j = 0; i < length; i += maxChunk, j++) {
					let subPackage = buffer.slice(i, i + maxChunk <= length ? (i + maxChunk) : length);
					//_count = j;
					setTimeout(() => {
						console.log(`第${j+1}分包发送，开始字节${i}`)
						this._writeBLECharacteristicValue(deviceId, serviceId, characteristicId, subPackage,(f)=>{
							console.log(`${j+1}返回${f}`)
							if (f) {
								successArr.push(j+1)
							}
							if (j===pakageLen-1) {
								uni.hideLoading();
								uni.showModal({
									title:'打印提示',
									content:`蓝牙传输分${pakageLen}包，成功传输${successArr.length}个包，依次为：${successArr.join(",")}。`,
									showCancel:false
								})
							}
						})
					},  j * delay);
				}
		},
		// 并行调用多次会存在写失败的可能性，延时调用
		_writeSubBLECharacteristicValue(deviceId, serviceId, characteristicId,subPackage,index,callback){
			this._writeBLECharacteristicValue(deviceId, serviceId, characteristicId, subPackage,callback)
			/* if (index===0) {
				this._writeBLECharacteristicValue(deviceId, serviceId, characteristicId, subPackage,callback)
			} else {
				setTimeout(()=>{
					this._writeBLECharacteristicValue(deviceId, serviceId, characteristicId, subPackage,callback)
				},50)
			} */
		},
		//写入蓝牙
		_writeBLECharacteristicValue(deviceId, serviceId, characteristicId, buffer,callback) {
			//console.log('start writeBLECharacteristicValue')
			uni.writeBLECharacteristicValue({
				deviceId: deviceId,
				serviceId: serviceId,
				characteristicId: characteristicId,
				value: buffer,
				success(res) {

					//console.log('writeBLECharacteristicValue success', res.errMsg)
					callback && callback(true)
				},
				fail(res) {
					//console.log('writeBLECharacteristicValue fail')
					//console.log(JSON.stringify(res))
					//console.log(JSON.stringify(buffer))
					callback && callback(false)
				}
			})
		},
		//长按事件
		longpress(item, index) {
			let _this = this
			if (uni.getStorageSync('deviceId')) {
				uni.showToast({
					title: '蓝牙已连接！',
					icon: 'none',
					duration: 2000
				})
				return
			}
			// uni.showModal({
			// 	title: '提示',
			// 	content: '是否连接蓝牙:' + item.name,
			// 	showCancel: true,
			// 	cancelColor: '#333333',
			// 	success: (res => {
			// 		if (res.confirm) {
			_this.stopBluetoothDevicesDiscovery()
			uni.setStorageSync('itemblue', item.name)
			this.itemblue = item.name
			_this.createBLEConnection(item.deviceId)

			// } else if (res.cancel) {
			// 	uni.showToast({
			// 		title: '已取消连接',
			// 		duration: 2000,
			// 		icon: 'none'
			// 	})
			// }
			// })
			// });
		},
		// 点击断开蓝牙连接
		tomy() {
			var _this = this

			uni.closeBluetoothAdapter({
				success(res) {
					uni.removeStorageSync('deviceId')
					uni.removeStorageSync("serviceId");
					uni.removeStorageSync("characteristicId");
					_this.openBluetoothAdapter()
				}
			})

		},
		//返回
		// fanhui() {
		// 	uni.navigateTo({
		// 		url: './printing'
		// 	})
		// },
	}
}