import game_store from "../store/game";
import ble_store from "../store/bluetooth";
import Notify from "../../static/vant/notify/notify";
import {LogInDb} from "@/requests/log";


var $ff = "ff";
var $8f = "ffffffff"
var control_close = false
var current_device_sn = ""
//记录当前脑环的mac地址
var current_device_mac = "";
//记录教具连接状态
var connect_toy = true;
//记录教具连接的id
var current_toy_id = "00";
//记录教具的UUID
var current_toy_UUID = "";

//标记是否打开脑控
var FlagOpenControl = false;

var ToyPower = 0;

//Math.round(new Date() / 1000)
var logTime = "";

var current_hex = "";

var is_new = game_store.getters.getIsNew();

//2021年11月10日14:59:38
// 0为旧 1为新
var services = [
  "6e400001-b5a3-f393-e0a9-e50e24dcca9e".toUpperCase(),
  "0000fff0-0000-1000-8000-00805f9b34fb".toUpperCase()
]
var charateristics = [
  {
    notify: "6e400003-b5a3-f393-e0a9-e50e24dcca9e".toUpperCase(),
    write: "6e400002-b5a3-f393-e0a9-e50e24dcca9e".toUpperCase()
  },
  {
    notify: "0000fff1-0000-1000-8000-00805f9b34fb".toUpperCase(),
    write: "0000fff2-0000-1000-8000-00805f9b34fb".toUpperCase()
  },
]

function getServicesAndCharateristc() {
  //获取当前设备名称
  // let $brainSn = game_store.getters.getDeviceSn();
  let $deviceId = game_store.getters.getDeviceId();
  let $serviceId = game_store.getters.getServiceId();
  let $index = services.indexOf($serviceId.toUpperCase())
  // let $index = $brainSn.toUpperCase().indexOf("JELLYFISH") != -1 ? 0 : 1;
  return {
    deviceId: $deviceId,
    service: "6e400001-b5a3-f393-e0a9-e50e24dcca9e".toUpperCase(),
    charateristic: charateristics[0]
  }
}

var update_state = true;
//全局升级下标
var update_index = 0;
//序列下标1
var update_seq1_index = 0;
//序列下标2
var update_seq2_index = 0;
var totalBuffer = [];
// 脑环model
var model = "";
//脑环固件版本
var version = "";


export default {
  //变量
  connect_toy, control_close, current_toy_id, current_toy_UUID, ToyPower, current_device_sn, is_new,

  /**
   *  todo:打开大包数据
   */
  sendOpenBigData() {
    this.SendOrder('ff')
  },
  /**
   *  todo:关闭大包数据
   */
  sendCloseBigData() {
    this.SendOrder('00')
  },
  /**
   *  todo:获取当前连接的教具类型
   */
  sendGetToyType() {
    this.SendOrder('06')
  },
  /**
   *  todo:开启脑控
   */
  sendControl() {
    let that = this;
    // 先发第一次
    that.SendOrder('07')
    wx.showLoading({
      title: "正在启动"
    })
    let $intv = setInterval(() => {
      if (FlagOpenControl) {
        //设置打开脑控为false
        FlagOpenControl = false;
        clearInterval($intv)
        wx.hideLoading()
      } else {
        that.SendOrder('07')
      }
    }, 3000)
  },
  /**
   *  todo:关闭脑控
   */
  sendControlClose() {
    let that = this
    control_close = false;
    let $intv = setInterval(() => {
      if (!control_close) {
        that.SendOrder('09')
        //如果是jellyfish则发送00教具
        if (!is_new) {
          that.sendConnectOneToMore('00')
        }

      } else {
        //设置打开脑控为false
        FlagOpenControl = false;
        clearInterval($intv)
        //清空当前数据
        that.clearLocalDatas()
      }
    }, 1000)
  },
  /**
   *  todo:发送一对多连接
   */
  sendConnectOneToMore(id) {
    this.WriteBufferInBle(`03 00 ${id} 00 0A`);
  },
  /**
   *  todo:发送一对一连接
   */
  sendConnectOneToOne(id) {
    current_toy_id = id;
    this.WriteBufferInBle(`03 00 ${id} 01 0A`)
  },

  /**
   *  todo:获取教具电量
   */
  sendToyPower() {
    let that = this;
    if (is_new) {
      let $connect_false_count = 0;
      let toy_intv = setInterval(() => {
        let $game_status = game_store.getters.getGameStatus();
        if (connect_toy) {
          that.SendOrder('8a')
        } else {
          if ($game_status != 1) {
            clearInterval(toy_intv)
          }
        }
      }, 3000)
    } else {
      console.log("旧脑环不支持获取教具电量")
    }
  },

  /**
   *  todo:获取大包数据进行绘制图表
   */
  get_big_data(hex) {
    if (hex.substr(0, 6) != "555520") {
      return false;
    }
    //当s1为 00时 数据有效
    // let hex_str = hex.substr(hex.indexOf("555520"))
    // let $s1 = hex_str.substr(8, 2);
    let $s1 = hex.substr(8, 2);
    if ($s1 != "00") {
      return false;
    }

    //专注度数据
    let $att = parseInt("0x" + hex.substr(12, 2));
    //放松度数据
    let $med = parseInt("0x" + hex.substr(16, 2));

    //Delta数据
    let $delta_1 = hex.substr(hex.indexOf("0418") + 4, 2);
    let $delta_2 = hex.substr(hex.indexOf("0418") + 6, 2);
    let $delta_3 = hex.substr(hex.indexOf("0418") + 8, 2);
    let $delta = parseInt($delta_1, 16) + parseInt($delta_2, 16) + parseInt($delta_3, 16);

    //Theta数据
    let $theta_1 = hex.substr(hex.indexOf("0418") + 10, 2);
    let $theta_2 = hex.substr(hex.indexOf("0418") + 12, 2);
    let $theta_3 = hex.substr(hex.indexOf("0418") + 14, 2);
    let $theta = parseInt($theta_1, 16) + parseInt($theta_2, 16) + parseInt($theta_3, 16);


    //low_Alpha
    let $low_alpha_1 = hex.substr(hex.indexOf("0418") + 16, 2);
    let $low_alpha_2 = hex.substr(hex.indexOf("0418") + 18, 2);
    let $low_alpha_3 = hex.substr(hex.indexOf("0418") + 20, 2);
    let $low_alpha = parseInt($low_alpha_1, 16) + parseInt($low_alpha_2, 16) + parseInt($low_alpha_3, 16);

    //high_Alpha
    let $high_alpha_1 = hex.substr(hex.indexOf("0418") + 22, 2);
    let $high_alpha_2 = hex.substr(hex.indexOf("0418") + 24, 2);
    let $high_alpha_3 = hex.substr(hex.indexOf("0418") + 26, 2);
    let $high_alpha = parseInt($high_alpha_1, 16) + parseInt($high_alpha_2, 16) + parseInt($high_alpha_3, 16);

    //low_beta
    let $low_beta_1 = hex.substr(hex.indexOf("0418") + 28, 2);
    let $low_beta_2 = hex.substr(hex.indexOf("0418") + 30, 2);
    let $low_beta_3 = hex.substr(hex.indexOf("0418") + 32, 2);
    let $low_beta = parseInt($low_beta_1, 16) + parseInt($low_beta_2, 16) + parseInt($low_beta_3, 16);

    //high_beta
    let $high_beta_1 = hex.substr(hex.indexOf("0418") + 34, 2);
    let $high_beta_2 = hex.substr(hex.indexOf("0418") + 36, 2);
    let $high_beta_3 = hex.substr(hex.indexOf("0418") + 38, 2);
    let $high_beta = parseInt($high_beta_1, 16) + parseInt($high_beta_2, 16) + parseInt($high_beta_3, 16);
    let $max_num = 30000;
    return {
      att: $att,
      med: $med,
      delta: $delta >= $max_num ? $max_num : $delta,
      theta: $theta >= $max_num ? $max_num : $theta,
      low_alpha: $low_alpha >= $max_num ? $max_num : $low_alpha,
      high_alpha: $high_alpha >= $max_num ? $max_num : $high_alpha,
      low_beta: $low_beta >= $max_num ? $max_num : $low_beta,
      high_beta: $high_beta >= $max_num ? $max_num : $high_beta
    };
  },
  /**
   *  todo:获取设备电量
   */
  get_device_elc(hex) {
    if (hex.substr(0, 8) != "55550203") {
      return false;
    }
    let $power = parseInt("0x" + hex.substr(8, 2));
    return $power;
  },

  /**
   *  todo:监听蓝牙连接状态
   */
  watch_bluetooth_status($this) {
    let that = this;
    // 微信自身监听低功耗蓝牙连接状态的改变事件
    wx.onBLEConnectionStateChange((res) => {
      // 该方法回调中可以用于处理连接意外断开等异常情况
      ble_store.setters.setBluetoothLinkStatus(res.connected);
      LogInDb(`${that.getNowTime()} 监听脑环断连`)
      if (res.connected == false) {
        //判断游戏是否游戏中
        let $game_status = game_store.getters.getGameStatus();
        if ($game_status == 1) {
          // $that.game_finished();
          Notify({
            type: 'danger',
            duration: 0,
            message: '智脑环已断开连接，正在尝试重新连接',
            onOpened() {
              that.reconnect(res.deviceId, $this)
            }
          });
          control_close = true
          // connect_toy = false;
        } else {
          //关闭脑控
          connect_toy = false;
          game_store.setters.setGameStatus(0);
          // 清空链接得设备 三值
          game_store.setters.clearDeviceToy();
          $this.connect_toy = 0;
          $this.connect_show = false;
          $this.device_bg = false;
          $this.change_toy_connect_status(0);
          $this.device_status = 0;
          $this.device = {}
          $this.toy_UUID = "";
          $this.$forceUpdate();
          wx.closeBluetoothAdapter();
        }
      }
    });
  },

  /**
   * todo:重新连接蓝牙
   */
  reconnect($deviceId, $this) {
    let that = this;
    let $deviceInfo = getServicesAndCharateristc();
    //重连的次数
    let $connect_count = 0;
    let $rec = setInterval(() => {
      let $game_status = game_store.getters.getGameStatus();
      if ($game_status == 1) {
        wx.createBLEConnection({
          deviceId: $deviceInfo.deviceId,
          success(res) {
            clearInterval($rec)
            Notify({type: 'success', message: `第${$connect_count}次重新连接成功`});
            LogInDb(`${that.getNowTime()} 第${$connect_count}次重新连接成功`)
            let $system = wx.getSystemInfoSync()
            if ($system.platform == 'ios') {
              that.getBLEDeviceServices($deviceInfo.deviceId)
              that.watchingDevice($this)
            } else {
              that.openNotify($this)
              that.watch_bluetooth_status($this);
            }
            // that.sendToyPower();

          },
          fail(res) {
            Notify({type: 'danger', message: `第${$connect_count}次重新连接失败`});
            game_store.setters.setGameCloseStatus(1);
          }
        })
        if ($connect_count >= 3) {
          $this.game_finished();
          clearInterval($rec)
        }
        $connect_count += 1;
      } else {
        clearInterval($rec)
      }
    }, 7000)

  },

  /**
   * todo 获取蓝牙设备服务
   * @param deviceId
   */
  getBLEDeviceServices(deviceId) {
    const that = this;
    current_device_mac = deviceId
    wx.getBLEDeviceServices({
      deviceId,
      success: (res) => {
        for (let i = 0; i < res.services.length; i++) {
          console.log("serviceItem:" + res.services[i].uuid);
          if (res.services[i].uuid.indexOf('6E') != -1 || res.services[i].uuid.indexOf('0000FFF0') != -1) {
            console.log("SelectedServiceItem:" + res.services[i].uuid);
            that.getBLEDeviceCharacteristics(deviceId, res.services[i].uuid);
            game_store.setters.setServiceId(res.services[i].uuid)
            is_new = game_store.getters.getIsNew()
            return;
          }
        }
      },
      fail(res) {
        console.log("连接蓝牙成功,获取服务失败", res);
      },
    });
  },

  /**
   * todo 获取蓝牙设备某个服务中所有特征值
   */
  getBLEDeviceCharacteristics(deviceId, serviceId) {
    console.log(deviceId, serviceId);
    const $this = this;
    wx.getBLEDeviceCharacteristics({
      deviceId,
      serviceId,
      success: (res) => {
        console.log("getBLEDeviceCharacteristics success", res.characteristics);
        for (let i = 0; i < res.characteristics.length; i++) {
          let item = res.characteristics[i];
          let writeState = null;
          if (serviceId.indexOf("0001") != -1) {
            writeState = item.properties.write && item.uuid.indexOf("0002") != -1;
          } else {
            writeState = item.properties.write;
          }
          if (writeState) {
            // if (item.properties.write) {
            $this.deviceId = deviceId;
            $this.serviceId = serviceId;
            $this.cid = item.uuid;
            //打开数据帧
            $this.sendOpenBigData();
          }

          if (item.properties.notify || item.properties.indicate) {
            wx.notifyBLECharacteristicValueChange({
              deviceId,
              serviceId,
              characteristicId: item.uuid,
              state: true,
            });
          }
        }
      },
      fail(res) {
        console.error("getBLEDeviceCharacteristics", res);
      },
    });
  },

  openNotify($this) {
    let that = this;
    let $deviceInfo = getServicesAndCharateristc();
    console.log($deviceInfo)
    wx.notifyBLECharacteristicValueChange({
      deviceId: $deviceInfo.deviceId,
      serviceId: $deviceInfo.service,
      characteristicId: $deviceInfo.charateristic.notify,
      state: true,
      success() {
        that.watchingDevice($this)
      }
    });
  },

  /**
   * todo ArrayBuffer转16进度字符串示例
   * @param buffer
   * @returns {string}
   */
  ab2hex(buffer) {
    var hexArr = Array.prototype.map.call(
      new Uint8Array(buffer),
      function (bit) {
        return ("00" + bit.toString(16)).slice(-2);
      }
    );
    return hexArr.join("");
  },


  /**
   * todo 监听脑环数据
   * @param $this
   */
  watchingDevice($this) {
    const that = this;
    let DeviceId = game_store.getters.getDeviceId();
    wx.onBLECharacteristicValueChange((characteristic) => {

      // 获取脑环信号值
      wx.getBLEDeviceRSSI({
        deviceId: DeviceId,
        success(res) {
          if (game_store.getters.getGameStatus() == 1) {
            $this.rssi = res.RSSI;
          }
        }
      })

      let hexStr = that.ab2hex(characteristic.value);
      // console.log("数据", hexStr, "长度", hexStr.length / 2);

      if (hexStr.toUpperCase().indexOf("AADD") != -1 || hexStr.toUpperCase().indexOf("AAEE") != -1 && update_state == false) {
        let nowTime = Math.round(new Date() / 1000);
        console.log("应答", hexStr, '时间：' + that.getNowTime(), "长度", hexStr.length / 2);
        LogInDb(`${that.getNowTime()} 应答：${hexStr}`)
      }
      let $data = that.get_big_data(hexStr);
      let $game_status = game_store.getters.getGameStatus();

      // 教具断链
      if (hexStr.toUpperCase().indexOf("AAEE70") != -1) {
        connect_toy = false
        wx.showToast({
          title: "教具已断开",
          icon: "error"
        })
        LogInDb(`${that.getNowTime} 教具已断开`)
        //重连机制
        if ($game_status == 1) {
          $this.game_finished();
        }
      }


      if (hexStr.toUpperCase().indexOf("AAEE8A0000005A") != -1) {
        that.SendOrder("8a")
      }

      //防止在首页 连接的时候重复 选择教具 产生了发送多个教具电量
      // if(hexStr.toUpperCase().indexOf("AAEE8A000000FF76") != -1){
      //   that.connect_toy = false;
      // }

      if (hexStr.toUpperCase().indexOf("AAEE07") != -1) {
        that.sendControl();
      }
      // 2021年10月20日17:18:13 判断教具 连接
      if (hexStr.toUpperCase().indexOf("AADD0A") != -1) {
        //没连接上教具
        if (hexStr.toUpperCase().indexOf("AADD0A0000") != -1) {
          if (is_new) {
            $this.change_toy_connect_status(3);
          }
          return false;
        }
        let $mHexStrIndex = hexStr.toUpperCase().indexOf("AADD0A");
        let $hex_index = hexStr.substr($mHexStrIndex + 28, 2)
        let $toy_id = hexStr.substr($mHexStrIndex + 8, 2)
        console.log("连接", $hex_index)
        console.log("玩具", $toy_id)
        // 连接上教具
        if (new RegExp("00").test($hex_index) == true) {
          if (is_new) {
            that.sendConnectOneToOne($toy_id)
            $this.current_hex = `03 00 ${$toy_id} 01 0A`
            console.log("一对多")
          } else {
            $this.current_hex = "";
            wx.showToast({
              title: "已连接到" + $this.toy_item.name
            });
            $this.toy_connected = true;
            $this.change_toy_connect_status(2);
          }
        }
        if (new RegExp("01").test($hex_index) == true) {
          console.log("一对一")
          $this.current_hex = "";
          wx.showToast({
            title: "已连接到" + $this.toy_item.name
          });
          $this.toy_connected = true;
          connect_toy = true;

          $this.change_toy_connect_status(2);
          //连接成功后 获取一次教具名称


          //TODO 2022-5-25 08:51:15 延迟发送教具UUID
          //2022年5月25日17:21:57 从2秒更换到3秒
          setTimeout(() => {
            that.SendOrder('87')
          }, 3000)

          // 更改为不断获取教具电量
          setTimeout(() => {
            that.sendToyPower();
          }, 5000)
        }

        if (new RegExp("02").test($hex_index) == true) {
          //发送教具连接
          connect_toy = true
          wx.hideLoading()
          wx.showToast({
            title: "教具重连成功"
          })
          that.sendControl()
          // that.sendToyPower();
        }
      }

      //2021年11月23日10:39:49
      // 获取教具名称
      if (hexStr.toUpperCase().indexOf("AADD87") != -1) {
        let $mHexStr = hexStr.substr(hexStr.toUpperCase().indexOf("AADD87"))
        let $datas = that.DoAnalysis($mHexStr, 10)
        let $number = $datas.match(/\d+/)
        let toy_list_pre = {'01': "SW", '02': "KL", '04': "SC", '05': "PP", '06': "SU", '09': "UF"}
        let $sn = toy_list_pre[current_toy_id] + $number;
        $this.toy_sn = $sn;
        //获取教具电量
        // that.SendOrder('8a')
      }
      if (hexStr.toUpperCase().indexOf("AAEE87") != -1) {
        //获取教具电量
        that.SendOrder('87')
      }

      //2021年10月21日16:30:07
      // 获取教具电量
      if (hexStr.toUpperCase().indexOf("AADD8A") != -1) {//接收教具电量状态
        let $_hexStr = hexStr.substr(hexStr.toUpperCase().indexOf("AADD8A") + 6);
        let $power = parseInt($_hexStr.substr(0, 2), 16)
        let $voltage = parseInt($_hexStr.substr(2, 2), 16)
        connect_toy = true;
        // $this.toy_power = Math.round(that.CalBLEPower($voltage));
        if ($power > 0) {
          $this.toy_power = $power
          $this.toy_voltage = $voltage
          ToyPower = $power;
        }

        //连接上教具的标识
        //FF为无效
        // 2022年5月10日15:55:34 已无效
        // if ($power != 0) {
        //   connect_toy = true;
        // }
        // if (hexStr.toUpperCase().indexOf("FF") != -1) {
        //   connect_toy = false;
        // }


        if (current_toy_UUID == "") {
          //获取教具UUID
          that.SendOrder('84')
        }
      }

      //监听佩戴正确
      if (hexStr.substr(0, 6) == "555520") {
        //当s1为 00时 数据有效
        let $s1 = hexStr.substr(8, 2);
        // console.log("监听脑环是否带正：", $s1 == '00')

        $this.device_bg = $s1 == "00";
      }

      // 2021年10月25日09:15:50
      // 读取教具UUID
      if (hexStr.toUpperCase().indexOf("AADD84") != -1) {//接收UUID 5个字节
        let $hex_index = hexStr.toUpperCase().indexOf("AADD84") + 6;
        let $datas = hexStr.substr($hex_index, 10);
        if ($datas != "0000000000") {
          console.log("以获取UUID：" + $datas)
          current_toy_UUID = $datas;
          $this.toy_UUID = $datas;
        }
      }


      if (hexStr.toUpperCase().indexOf("AADD09") != -1) {
        control_close = true;
        connect_toy = false;
      }

      //收到发送UUID的应答立马发送连接教具的指令
      if (hexStr.toUpperCase().indexOf("AADD8E") != -1) {
        //发送教具连接
        that.WriteBufferInBle(`03 00 ${current_toy_id} 02 0A`)
      }


      // 2021年11月10日14:34:26
      // 处理打开脑控的应答
      if (hexStr.toUpperCase().indexOf("AADD07") != -1) {
        ble_store.setters.setBluetoothLinkStatus(true)
        FlagOpenControl = true;
      }

      //todo 监听脑环电量
      if (hexStr.substr(0, 8) == "55550203") {
        let $power = parseInt(hexStr.substr(8, 2), 16);
        let $voltage = parseInt(hexStr.substr(10, 2), 16);
        //监听是否插入USB
        $this.hasUsb = $voltage.toString().substr(0, 1) == 1
        //  监听脑环电量
        if ($power) {
          // console.log("当前脑环电量:", $power)
          $this.device_power = $power;
          $this.device_voltage = $voltage;
        }
        if ($power < 10 && $power > 0) {
          wx.showToast({
            title: "脑环电量不足",
            icon: "none",
            duration: 2000,
            success() {
              // $this.change_device_status(0);
            },
          });
        }
      }

      // todo 监听ota升级
      if (hexStr.toUpperCase().indexOf("AADD30") != -1 || hexStr.toUpperCase().indexOf("AADD31") != -1) {
        if (hexStr.toUpperCase().indexOf("AADD30") != -1) {
          update_index = 0;
          update_seq1_index = 0;
          update_seq2_index = 0;
          update_state = true;
          totalBuffer = [];
        }
        // 开始升级、
        console.log("升级中")
        let buffer_len = 224
        if (update_state) {
          let total_index = Math.round($this.payload_len / buffer_len)
          let another_buffer_len = $this.payload_len % buffer_len;
          if (update_index < total_index) {
            that.SendUpdateData($this.buffers, $this.dec_index * 16 + update_index * buffer_len, buffer_len)
          } else {
            console.log(`update_index：${update_index}`,`total_index：${total_index}`)
            console.log("余："+another_buffer_len)
            if (another_buffer_len > 0) {
              that.SendUpdateData($this.buffers, $this.dec_index * 16 + update_index * buffer_len, another_buffer_len)
            }
            update_state = false;
          }
          $this.progress = (update_index / total_index * 100).toFixed(2);
        } else {
          //更新结束
          that.FinishBleUpdate()
          console.log(`文件buffer长度：${$this.payload_len}，总共发送totalBuffer:${totalBuffer.length}`)
        }
      }


      if (hexStr.toUpperCase().indexOf("AAEE31") != -1) {
        let $hexStr = `03 32 00 00 00`;
        this.WriteBufferInBle($hexStr)
        $this.AddContent("更新停止")
      }


      //游戏中模块
      if ($game_status == 1 && $data) {
        $this.do_datas($data);
      }

      //todo 监听收到更新结束
      if (hexStr.toUpperCase().indexOf("AADD33") != -1) {
        //发送重启脑环指令
        let $hexStr = `03 00 00 00 26`;
        this.WriteBufferInBle($hexStr)
        $this.step_active += 1;
      }

      //todo 监听收到脑环型号
      if (hexStr.toUpperCase().indexOf("AADD02") != -1) {
        hexStr = hexStr.substr(10, 20)
        for (let i = 0; i < hexStr.length; i += 2) {
          model += String.fromCharCode(parseInt(hexStr.substr(i, 2), 16));
        }
        console.log(`model:${model}`)
        this.SendOrder("03");
      }

      //todo 获取固件信息
      if (hexStr.toUpperCase().indexOf("AADD03") != -1) {
        hexStr = hexStr.substr(6, 24)
        for (let i = 0; i < hexStr.length; i += 2) {
          version += String.fromCharCode(parseInt(hexStr.substr(i, 2), 16));
        }
        $this.software_version = version
        console.log(`version:${version}`)

        let firmware_info = JSON.parse(wx.getStorageSync("firmware_info"))

        //todo 与数据库匹对固件升级
        if (model == firmware_info.model) {
          //版本不一样
          if (firmware_info.version != version) {
            //硬更/软更
            $this.force_update = firmware_info.status == 1;
            $this.remote_version = `V${firmware_info.version}`;
            $this.update_show = true
          }
        }

      }


    });
  },

  /**
   * todo 游玩时间倒计时
   * @param value
   * @returns {string}
   */
  formatPlaySeconds(value) {
    // 字符串转数字
    var secondTime = parseInt(value); // 秒
    var minuteTime = 0; // 分
    if (secondTime > 60) {
      //如果秒数大于60，将秒数转换成整数
      //获取分钟，除以60取整数，得到整数分钟
      minuteTime = parseInt(secondTime / 60);
      //获取秒数，秒数取佘，得到整数秒数
      secondTime = parseInt(secondTime % 60);
      //如果分钟大于60，将分钟转换成小时
    }
    var result = "" + parseInt(secondTime);

    if (minuteTime > 0) {
      if (result.length == 1) {
        result = "0" + result;
      }
      if (parseInt(minuteTime).toString().length == 1) {
        minuteTime = "0" + parseInt(minuteTime);
      }
      result = "" + minuteTime + ":" + result;
    } else {
      result = "00:" + result;
    }
    return result;
  },

  /**
   * todo 根据错误代码返回字符串信息
   * @param errCode
   * @returns {string}
   * @constructor
   */
  GetopenBluetoothAdapterError(errCode) {

    let $errmsg = "";
    if (errCode == 10000) {
      $errmsg = "未初始化蓝牙适配器"
    }

    if (errCode == 10001) {
      $errmsg = "当前蓝牙适配器不可用"
    }

    if (errCode == 10002) {
      $errmsg = "没有找到指定设备"
    }

    if (errCode == 10003) {
      $errmsg = "连接失败"
    }

    if (errCode == 10006) {
      $errmsg = "当前连接已断开"
    }

    return $errmsg;
  },

  /**
   * todo 写入buffer
   * @param $hex
   * @param $buffer_len
   * @constructor
   */
  WriteBufferInBle($hex, $buffer_len = 8) {
    let that = this;
    let $deviceInfo = getServicesAndCharateristc();
    let $hex_header = "aa cc ";
    // let $hex = "03 00 01 00 0a";

    let $hex_sum = 0;
    let $hex_ary = $hex.split(" ");
    $hex_ary.forEach(($val, $index) => {
      $hex_sum += parseInt($val, 16);
    })

    let $checksum = ($hex_sum ^ parseInt($8f, 16)) & parseInt($ff, 16);

    $hex = $hex_header + $hex + " " + ("00" + $checksum.toString(16)).substr(-2, 2);
    let buffer = new ArrayBuffer($buffer_len);
    let dataView = new DataView(buffer);
    $hex_ary = $hex.split(" ");
    $hex_ary.forEach(($val, $index) => {
      dataView.setUint8($index, parseInt($val, 16))
    })


    if (!$deviceInfo.charateristic.write) {
      return false;
    }
    wx.writeBLECharacteristicValue({
      deviceId: $deviceInfo.deviceId,
      serviceId: $deviceInfo.service,
      characteristicId: $deviceInfo.charateristic.write,
      value: buffer,
      success: function (res) {
        if ($buffer_len <= 16) {
          console.log($hex + ',写入成功,时间：' + that.getNowTime())
        } else {
          console.log('写入成功,时间：' + that.getNowTime())
        }
        // LogInDb(`${that.getNowTime()} ${$hex}',写入成功`)
      },
      fail: function (err) {
        console.log($hex + "写入失败", err);
      },
    });
  },

  /**
   * todo写入8位指令
   * @param id 末尾id
   * @constructor
   */
  SendOrder(id) {
    let $hexStr = `03 00 00 00 ${id}`;
    this.WriteBufferInBle($hexStr)
  },

  /**
   * todo 写入16个字节的指令
   * @param val
   * @param id
   * @constructor
   */
  Send16Order(val, id) {
    let $str = val;
    let $str_ary = $str.split('');
    $str = "";
    $str_ary.forEach(($val, $index) => {
      $str += $val.charCodeAt().toString(16) + " "
    });
    $str = $str.substr(0, $str.length - 1)
    let $hexStr = "03 ff " + $str + ` ${id}`;

    this.WriteBufferInBle($hexStr, 16)
  },


  /**
   * todo 解析hex
   * @param hexStr
   * @param byte_count
   * @param sublen
   * @returns {string}
   * @constructor
   */
  DoAnalysis(hexStr, byte_count, sublen = 6) {
    //byte_count
    let $_str5 = hexStr.substr(sublen);
    let $datas = $_str5.substr(0, byte_count * 2);
    let $_data = "";
    for (let $i = 0; $i < $datas.length; $i += 2) {
      let $code = parseInt($datas.substr($i, 2), 16)
      $_data += String.fromCharCode($code)
    }
    return $_data;
  },

  /**
   * todo 重连教具
   * @constructor
   */
  ReconnectToy() {
    current_device_mac = game_store.getters.getDeviceId();
    let $game_status = game_store.getters.getGameStatus();

    let that = this;
    try {
      //发送UUID
      let $uuid_str = "";
      for (let $i = 0; $i < current_toy_UUID.length; $i += 2) {
        $uuid_str += current_toy_UUID.substr($i, 2) + " ";
      }

      let _deviceId = "";
      let deviceIds = current_device_mac.split(':');
      for (let i = 0; i < deviceIds.length; i++) {
        if (i != 2) {
          _deviceId += deviceIds[i] + " ";
        }
      }

      let sum = $uuid_str + _deviceId;
      sum = sum.substr(0, sum.length - 1);
      let $hexStr = `03 ff ${sum} 8e`;
      let loop_count = 0;
      if ($game_status == 1) {
        wx.showLoading({
          title: "重新连接教具中"
        })
      }
      LogInDb(`${that.getNowTime()} 重新连接教具中`)
      let connect_toy_intv = setInterval(() => {
        $game_status = game_store.getters.getGameStatus();
        if ($game_status == 1) {

          if (connect_toy == false) {
            if (loop_count == 3) {
              wx.hideLoading()
              wx.showToast("教具已无法连接")
              clearInterval(connect_toy_intv)
            }
            loop_count += 1;
            // that.WriteBufferInBle(`03 00 ${current_toy_id} 02 0A`)
            // 发送教具UUID
            that.WriteBufferInBle($hexStr, 16)
          } else {
            wx.hideLoading()
            loop_count = 0;
            clearInterval(connect_toy_intv)
          }
        } else {
          wx.hideLoading()
          clearInterval(connect_toy_intv)
        }
      }, 3000)


    } catch (e) {
      console.log("ReconnectToy:", e)
    }

  },

  /**
   * todo 清空当前脚本的变量值
   */
  clearLocalDatas() {
    control_close = false
    connect_toy = false;
    current_toy_id = "00";
    current_toy_UUID = "";
  },

  /**
   * todo 计算电量
   * @param $voltage
   * @returns {number}
   * @constructor
   */
  CalBLEPower($voltage) {
    let $max = 4100;
    let $min = 3500;

    //(当前电压值（mV）-最低电压值(mV)) / (最大电压值(mV)-最低电压值(mV)) *100%
    //当前电压
    let $_voltage = $voltage * 100;
    // console.log(`计算的当前电压:${$_voltage}`)

    let $percent = (($_voltage - $min) / ($max - $min)) * 100;
    // console.log(`计算的电量：${$percent}`);
    return $percent;
  },


  getNowTime() {
    var date = new Date();
    const year = date.getFullYear();
    const month = date.getMonth() + 1;
    const day = date.getDate();

    const hour = date.getHours();
    const minutes = date.getMinutes();
    const seconds = date.getSeconds();
    const millSeconds = date.getMilliseconds();

    return `${year}/${month}/${day} ${hour}:${minutes}:${seconds}.${millSeconds}`;
  },

  /**
   * 自动发送RF重连
   * @param  {Boolean} isOn    是否打开重连功能
   * @param  {[type]}  timeOut 有效时间
   * @return {[type]}          [description]
   * AA CC 03 00 01 0a d0 21
   */
  sendAutoConnectRf(isOn, timeOut) {
    let that = this;
    let onVal = isOn ? '01' : '00';
    let mTimeOut = timeOut.toString(16);

    if (mTimeOut.length == 1) {
      mTimeOut = `0${mTimeOut}`
    }

    let $hexStr = `03 00 ${onVal} ${mTimeOut} d0`;
    this.WriteBufferInBle($hexStr)
  },

  /**
   * todo 发送升级数据
   * @param buffers 数据包
   * @param start_index 开始下标
   * @param speed 发送速率
   * @constructor
   */
  SendUpdateData(buffers, start_index, speed = 248) {
    let buffer = new Uint8Array(buffers, start_index, speed)
    let $hexStr = [
      '03',
      '31',
      `00${update_seq1_index.toString(16)}`.substr(-2, 2),
      `00${update_seq2_index.toString(16)}`.substr(-2, 2),
      speed.toString(16),
    ]
    for (let j = 0; j < speed; j++) {
      let $hex = ('00' + buffer[j].toString(16)).substr(-2, 2)
      $hexStr.push($hex)
      totalBuffer.push($hex)
    }
    this.WriteBufferInBle($hexStr.join(' '), $hexStr.length + 3)
    update_seq1_index += 1;
    update_index += 1;
    if (update_seq1_index == 256) {
      update_seq1_index = 0;
      update_seq2_index += 1;
    }
  },

  /**
   * 更新结束
   * @constructor
   */
  FinishBleUpdate() {
    let $hexStr = `03 33 00 00 00`;
    this.WriteBufferInBle($hexStr)
  },
};