// 连接模式蓝牙
var util = require('util.js')
var data = {
  bioland_device_uuid: '00001000-0000-1000-8000-00805f9b34fb',  // 血压uuid
                       list:[],
                deviceIdStr: ''
}


var  characteristic_write_uuid = '00001001-0000-1000-8000-00805F9B34FB' // 数据写入接口特征值
var  service_write_uuid =  '00001000-0000-1000-8000-00805F9B34FB' // 数据写入接口服务服务值
var  characteristic_notify_uuid = '00001002-0000-1000-8000-00805F9B34FB' // 数据读取接口特征值
var  service_notify_uuid = '00001000-0000-1000-8000-00805F9B34FB' // 数据读取接口服务值

var responseData = {
  code: '',
  status: '',
  data: {}
}
var notOpenBle = false
var callBack;
var notification;

// 401蓝牙设备中断连接   201连接设备  200蓝牙状态成功  402连接失败

function openBluetooth(data, callBackFun){
  var self = this
  callBack = callBackFun
  var system = wx.getSystemInfoSync()
  if (system.platform == 'android'){
    toLower()
  }
  responseData = {
    code: '',
    status: '',
    data: {}
  }
  getBLEData()
  wx.onBluetoothAdapterStateChange(function (res) {
    // callback
    if (res.available == false) {
      notOpenBle = true
      responseData.status = '设备蓝牙未开启'
      responseData.code = '404'
      callBack(responseData)
    } else {
      
      if (notOpenBle) {
        responseData.code = '200'
        getBLEData()
      }
    }
  })
}

function getBLEData() {
  console.log('获取蓝牙适配器')
  wx.openBluetoothAdapter({
    success: function (res) {
      // success
      notOpenBle = false
      wx.getBluetoothAdapterState({
        success: function (res) {
          console.log('蓝牙适配器状态', res)
          if (res.discovering == true) {
            console.log('正在搜索')
            foundDevice()
          } else {
            console.log('开始获取连接设备')
            getConnectedDevice()
          }
        },
        fail: function (res) {
          responseData.status = '未能成功获取到蓝牙信息'
          callBack(responseData)
          console.log(res)
        }
      })
    },
    fail: function (res) {
      console.log(res)
      if (res.errMsg.indexOf("already opened") != -1) {
        notOpenBle = false
        wx.getBluetoothAdapterState({
          success: function (res) {
            if (res.discovering == true) {
              console.log('正在搜索')
              foundDevice()
            } else {
              console.log('开始获取连接设备')
              getConnectedDevice()
            }
          }
        })
        console.log('初始化蓝牙适配器')
        return
      }
      notOpenBle = true
      responseData.status = '请检查蓝牙是否打开'
      callBack(responseData)
    }
  })
}

// 获取已经连接的设备
function getConnectedDevice() {
  var self = this
  responseData.code = '200'
  wx.getConnectedBluetoothDevices({
    services: [data.bioland_device_uuid],
    success: function (res) {
      // success
      console.log('获取之前已经连接的蓝牙', res)
      if (res.devices.length == 0) {
        console.log('之前没有设备连接，开始搜索')
        searchDevices()
      } else {
        var currentDev;
        if (res.deviceId) { // android
          currentDev = res
        } else if (res.devices) { // ios
          currentDev = res.devices[0]
        }
        wx.closeBLEConnection({
          deviceId: res.devices[0].deviceId,
          success: function (res) {
            console.log('断开之前已经连接的设备,开始搜索')
            searchDevices()
          },
        })
      }
    },
    fail: function (res) {
      // fail
      console.log('获取已经连接蓝牙失败', res)
      searchDevices()
    },
    complete: function (res) {
      // complete
    }
  })
}

// 搜索设备
function searchDevices(){
  var self = this
  wx.startBluetoothDevicesDiscovery({
    services: [data.bioland_device_uuid],
    success: function (res) {
      // success
      console.log(`开始搜索设备`, res)
      foundDevice()
    },
    fail: function (res) {
      // fail
      responseData.status = '未能搜索到设备'
      callBack(responseData)
      console.log('搜索失败', res)
    }
  })
}

// 找到设备
function foundDevice(){
  var self = this
  responseData.status = '搜索设备中...'
  responseData.code = '200'
  callBack(responseData)
  wx.onBluetoothDeviceFound(function (res) {
    console.log('搜索到',res)
    var same = false
    var currentDev;
    if (res.deviceId) { // android
      currentDev = res
    } else if (res.devices) { // ios
      currentDev = res.devices[0]
    }
    for (var i = 0; i < data.list.length; i++) {
      var item = data.list[i]
      if (item.deviceId == currentDev.deviceId) {
        same = true
      }
    }
    if (!same) {
      // var list = data.list
      // list.push(currentDev)
      responseData.data.currentDev = currentDev
      callBack(responseData)
    }
  })
}

function addNotification(notificationFun){
  notification = notificationFun
}

// 选择设备
function connectionDevice(deviceId, callbackFun){
  var self = this
  data.deviceIdStr = deviceId
  wx.stopBluetoothDevicesDiscovery({
    success: function (res) {
      console.log('成功停止搜索')
    },
    fail: function (res) {
      console.log('未能成功停止搜索')
    }
  })
  responseData.status = '开始连接设备'
  callbackFun(responseData)
  wx.createBLEConnection({
    deviceId: data.deviceIdStr,
    success: function (res) {
      // success
      console.log('成功连接')
      getDeviceService()
    },
    fail: function (res) {
      // fail
      console.log('连接失败',res)
      responseData.status = '未能连接到设备'
      responseData.code = '402'
      callbackFun(responseData)
    }
  }) 
}

function getDeviceService(){
  var self = this
  wx.getBLEDeviceServices({
    deviceId: data.deviceIdStr,
    success: function (res) {
      // success
      console.log('成功获取服务')
      res.services.map(function (item) {
        if (item.uuid == service_write_uuid || item.uuid.toLowerCase() == service_write_uuid) {
          // 如果是大写 就全部转换成大写
          if (util.checkIsContainCapital(item.uuid)) {
            toCapital()
          } else {
            toLower()
          }
          getDeviceServiceCharacteristics(item.uuid)
        }
      })
    },
    fail: function (res) {
      responseData.status = '未能连接到设备'
      callBack(responseData)
    }
  })
  wx.onBLEConnectionStateChanged(function (res) {
    // 该方法回调中可以用于处理连接意外断开等异常情况
    if (res.connected == false){
      responseData.status = '设备连接已断开'
      responseData.code = '401'
      callBack(responseData)
    }
    console.log(`device ${res.deviceId} state has changed, connected: ${res}`)
  })
}

function getDeviceServiceCharacteristics(serviceId){
  var self = this
  wx.getBLEDeviceCharacteristics({
    deviceId: data.deviceIdStr,
    serviceId: serviceId,
    success: function (res) {
      // success
      console.log('成功获取特征')
      res.characteristics.map(function (item) {
        if (item.uuid == characteristic_notify_uuid || item.uuid.toLowerCase() == characteristic_notify_uuid) {
          console.log('打开监听',item)
          openNotify()
        }
        responseData.code = '201'
        responseData.status = '成功连接设备'
        callBack(responseData)
      })
    }, fail: function (res) {
      console.log('失败获取特征',res)
    }
  })
}
// 获取设备特征值信息
function getDeviceServiceCharacteristicsValue(serviceId, characteristicsUuid){
  var self = this
  wx.readBLECharacteristicValue({
    deviceId: data.deviceIdStr,
    serviceId: service_notify_uuid,
    characteristicId: characteristic_notify_uuid,
    success: function (res) {
      // success
      console.log('成功duqu特征')
    },
    fail: function (res) {
      // fail
      responseData.status = '未能获取到设备信息'
      callBack(responseData)
    }
  })
  wx.onBLECharacteristicValueChange(function (res) {
    var dataStr = buf2hex(res.value)
    if (dataStr) {
      notification(dataStr)
    }
    // 55 0F 00 0A 00 01 00 00 64 00 00 00 00 00 D5
  })
}

// 开启监听
function openNotify(){
  var self = this
  console.log(service_notify_uuid)
  console.log(characteristic_notify_uuid)
  wx.notifyBLECharacteristicValueChanged({
    deviceId: data.deviceIdStr,
    serviceId: service_notify_uuid,
    characteristicId: characteristic_notify_uuid,
    state: true,
    success: function (res) {
    },
    fail: function (res) {
      // fail
      console.log('notifyBLECharacteristicValueChange fail --', res)
      // responseData.status = '未能获取到设备信息'
      callBack(responseData)
    }
  })
}

function writeDataWithStr(str){
  var self = this
  var typedArray = new Uint8Array(str.match(/[\da-f]{2}/gi).map(function (h) {
    return parseInt(h, 16)
  }))
  var buffer = typedArray.buffer

  wx.writeBLECharacteristicValue({
    deviceId: data.deviceIdStr,
    serviceId: service_write_uuid,
    characteristicId: characteristic_write_uuid,
    value: buffer,
    success: function (res) {
      // success
    },
    fail: function (res) {
      // fail
    },
    complete: function (res) {
      // complete
      getDeviceServiceCharacteristicsValue()
    }
  })
}

function closeBLE() {
  
  wx.stopBluetoothDevicesDiscovery({
    complete: function (res) {
      console.log('停止搜索', res)
    },
  })
  wx.closeBLEConnection({
    deviceId: data.deviceIdStr,
    complete: function(res) {
      console.log('断开该设备的蓝牙', res)
    }
  })
  wx.closeBluetoothAdapter({
    complete: function (res) {
      console.log('关闭蓝牙', res)
    },
  })
}

function buf2hex(buffer) { // buffer is an ArrayBuffer
  return Array.prototype.map.call(new Uint8Array(buffer), x => ('00' + x.toString(16)).slice(-2)).join('');
}

function toCapital() { 
  characteristic_write_uuid = characteristic_write_uuid.toUpperCase()
  service_write_uuid = service_write_uuid.toUpperCase()
  characteristic_notify_uuid = characteristic_notify_uuid.toUpperCase()
  service_notify_uuid = service_notify_uuid.toUpperCase()
}

function toLower() { 
  characteristic_write_uuid = characteristic_write_uuid.toLowerCase()
  service_write_uuid = service_write_uuid.toLowerCase()
  characteristic_notify_uuid = characteristic_notify_uuid.toLowerCase()
  service_notify_uuid = service_notify_uuid.toLowerCase()
}


module.exports = {
  writeDataWithStr: writeDataWithStr,
  openBluetooth: openBluetooth,
  connectionDevice: connectionDevice,
  closeBLE: closeBLE,
  addNotification: addNotification
}