import 'dart:async';
import 'dart:io';

import 'package:flutter_easyloading/flutter_easyloading.dart';
// import 'package:flutter_reactive_ble/flutter_reactive_ble.dart';
import 'package:get/get.dart';

import 'io_tool/io_model.dart';
import 'io_tool/io_tool.dart';
import 'io_tool/manager_event_bus.dart';
import 'reciver_data.dart';
import 'package:flutter_blue_plus/flutter_blue_plus.dart';

//连接状态回调
typedef ConnectStateCallBack = Function(BluetoothConnectionState connectionState);
typedef ScanDevicesCallBack = Function(List<ScanResult>);

class BlueManage {
  final List<ScanResult> scanDevices = [];

  // 用来写入的服务id
  final Guid _serviceIdConnect = Guid("fff0");
  // 用来写入的服务id
  final Guid _serviceIdWrite = Guid('0000FFF0-0000-1000-8000-00805F9B34FB');
  // 用来订阅的特征id
  final Guid _characteristicIdSubscription = Guid("fff1");
  // 用来写入的特征id
  final Guid _characteristicIdWrite = Guid("fff2");

  // 监听发送事件
  StreamSubscription<EventSendModel>? _sendStreamSubscription;
  // 监听蓝牙扫描的事件
  // StreamSubscription? _scanSubscription;
  // 监听蓝牙连接的事件
  // StreamSubscription<dynamic>? _currentConnectionStream;

  // StreamSubscription<List<ScanResult>>? _scanResultsSubscription;
  StreamSubscription<BluetoothConnectionState>? _connectionStateSubscription;

  StreamSubscription<int>? _mtuSubscription;
  int? _mtuSize = 20;

  // 当前连接设备的名字
  String connectDeviceName = "";
  // 当前连接设备的mac地址
  String connectDeviceMacAddress = "";
  // 当前连接的设备
  BluetoothDevice? bluetoothConnectDevice;
  // 当前扫描到结果要连接设备
  ScanResult? scanResult;
  // 监听蓝牙连接状态
  BluetoothConnectionState? bluetoothConnectionState = BluetoothConnectionState.disconnected;

  BluetoothAdapterState? _adapterState = BluetoothAdapterState.unknown;
  StreamSubscription<BluetoothAdapterState>? _adapterStateStateSubscription;

  static BlueManage? _manager;
  BlueManage._init(){
    _initBlue();
  }

  static BlueManage? shareManager() {
    _manager ??= BlueManage._init();
    // _manager!._initBlue();
    return _manager;
  }

  factory BlueManage() => shareManager()!;
  BlueManage? get manager => shareManager();

  void _initBlue(){
    print("蓝牙功能初始化监听");
    _initSendStreamSubscription();
    _initAdapterStateStateSubscription();
    // _initListenscanResults();
    // _initListenConnectionState();
  }

  void _initGetMtuSubscription() {
    _mtuSubscription ??= bluetoothConnectDevice!.mtu.listen((value) {
      _mtuSize = value - 3;
      print('mtuSize:$_mtuSize');
    });
  }

  void _initAdapterStateStateSubscription() {
    _adapterStateStateSubscription ??= FlutterBluePlus.adapterState.listen((state) {
      _adapterState = state;
    });
  }

  // void _initListenscanResults() {
    // var subscription = FlutterBluePlus.scanResults.listen((results) {
    //   scanDevices.clear();
    //   for (var scanResult in results) {
    //     // 判断名字为空的直接剔除
    //     // if (scanResult.device.advName.isEmpty) {
    //     //   return;
    //     // }
    //     print("scanResult.device.advName:${scanResult.device.advName}"
    //         " scanResult.advertisementData.serviceUuids:${scanResult.advertisementData.serviceUuids}"
    //         " rssi:${scanResult.rssi}");
    //     if (((scanResult.advertisementData.serviceUuids.isNotEmpty ? scanResult.advertisementData.serviceUuids[0] : "").toString().contains("758824")) && (scanResult.rssi >= -100)) {
    //       // 查询id相同的元素
    //       final knownDeviceIndex = scanDevices.indexWhere((d) => d.advertisementData.advName == scanResult.advertisementData.advName);
    //       // 不存在的时候返回-1
    //       if (knownDeviceIndex >= 0) {
    //         scanDevices[knownDeviceIndex] = scanResult;
    //       } else {
    //         scanDevices.add(scanResult);
    //       }
    //     }
    //   }
    //   EventBusManager().eventBusFir(scanDevices);
    //   // FlutterBluePlus.stopScan();
    // }, onError: (e) {
    //   print("Scan Error:$e", );
    // });
    //
    // FlutterBluePlus.cancelWhenScanComplete(subscription);

    // FlutterBluePlus.isScanning.listen((state) {
    //   if (state) {
    //     print('Scanning');
    //   } else {
    //     print('Not scanning');
    //   }
    // });
  // }

  void _initListenConnectionState() {
    _connectionStateSubscription?.cancel();
    _connectionStateSubscription = null;

    _connectionStateSubscription = bluetoothConnectDevice!.connectionState.listen((state) async {
      bluetoothConnectionState = state;
      Get.log("蓝牙连接状态:$state");
    });
  }

  void _initSendStreamSubscription() {
    _sendStreamSubscription ??= EventBusManager().eventBus!.on<EventSendModel>().listen((EventSendModel model) {
      if (model.sendChannel == DataChannel.ble) {
        FlutterBluePlus.isSupported.then((isAvailable) async {
          if (isAvailable) {
            if (_adapterState == BluetoothAdapterState.on) {
              // 蓝牙已开启，可以进行蓝牙操作
              writeCharacteristicWithResponse(model.data);
            } else {
              try {
                if (Platform.isAndroid) {
                  await FlutterBluePlus.turnOn();
                }
              } catch (e) {
                Get.log("Error Turning On:");
              }
            }
          } else {
            Get.log("写入数据 蓝牙不可用，不能进行蓝牙操作");
          }
        });
      }
    });
  }

  /// 开始扫描蓝牙设备
  Future<void> startScan(int timeout, ScanDevicesCallBack scanDevicesCallBack, {List<Guid>? idList}) async {
    FlutterBluePlus.isSupported.then((isAvailable) async {
      if (isAvailable) {
          if (_adapterState == BluetoothAdapterState.on) {
            try {
              FlutterBluePlus.startScan(timeout: Duration(seconds: timeout));

              var subscription = FlutterBluePlus.scanResults.listen((results) {
                scanDevices.clear();
                for (var scanResult in results) {
                  // 判断名字为空的直接剔除
                  // if (scanResult.device.advName.isEmpty) {
                  //   return;
                  // }
                  Get.log("scanResult.device.advName:${scanResult.device.advName}"
                      " scanResult.advertisementData.serviceUuids:${scanResult.advertisementData.serviceUuids}"
                      " rssi:${scanResult.rssi}");
                  if (((scanResult.advertisementData.serviceUuids.isNotEmpty ? scanResult.advertisementData.serviceUuids[0] : "").toString().contains("758824")) && (scanResult.rssi >= -100)) {
                    // 查询id相同的元素
                    final knownDeviceIndex = scanDevices.indexWhere((d) => d.advertisementData.advName == scanResult.advertisementData.advName);
                    // 不存在的时候返回-1
                    if (knownDeviceIndex >= 0) {
                      scanDevices[knownDeviceIndex] = scanResult;
                    } else {
                      scanDevices.add(scanResult);
                    }
                  }
                }
                scanDevicesCallBack(scanDevices);
                // EventBusManager().eventBusFir(scanDevices);
                // FlutterBluePlus.stopScan();
              }, onError: (e) {
                print("Scan Error:$e", );
              });

              FlutterBluePlus.cancelWhenScanComplete(subscription);
            } catch (e) {
              Get.log("扫描失败");
            }
          } else {
            try {
              if (Platform.isAndroid) {
                await FlutterBluePlus.turnOn();
              }
            } catch (e) {
              Get.log("Error Turning On:");
            }
          };
      } else {
        Get.log("开始扫描 蓝牙不可用，不能进行蓝牙操作");
      }
    });
  }

  /// 调用发送数据
  Future<void> bludSendData(String deviceName, ConnectStateCallBack stateCallBack, {bool isAddEquipment = false}) async {
    FlutterBluePlus.isSupported.then((isAvailable) async {
      if (isAvailable) {
        if (_adapterState == BluetoothAdapterState.on) {
          // 蓝牙已开启，可以进行蓝牙操作
          if(bluetoothConnectionState != BluetoothConnectionState.connected){
            _connect(deviceName, (state){
              // if(bluetoothConnectionState != BluetoothConnectionState.connected){
              //   stateCallBack(bluetoothConnectionState!);
              // }else{
              //   stateCallBack(bluetoothConnectionState!);
              // }
              stateCallBack(bluetoothConnectionState!);
            }, isAddEquipment: isAddEquipment);
          }else{
            stateCallBack(bluetoothConnectionState!);
          }
        } else {
          try {
            if (Platform.isAndroid) {
              await FlutterBluePlus.turnOn();
            }
          } catch (e) {
            Get.log("Error Turning On:");
          }
        };
      } else {
        Get.log("开始扫描 蓝牙不可用，不能进行蓝牙操作");
      }
    });
  }

  /// 连接
  Future<void> _connect(String deviceName, ConnectStateCallBack connectStateCallBack, {bool isAddEquipment = false}) async {
    connectDeviceName = deviceName;
    List<ScanResult> devicesList = scanDevices;
    if(isAddEquipment == false){
      startScan(10, (List<ScanResult> scanDevices){
        print("扫描到的设备:$scanDevices");
        devicesList = scanDevices;
        _connectDevice(devicesList, deviceName, connectStateCallBack, isAddEquipment: isAddEquipment);
      });
    }else{
      _connectDevice(devicesList, deviceName, connectStateCallBack, isAddEquipment: isAddEquipment);
    }
  }

  Future<void> _connectDevice( List<ScanResult> devicesList, String deviceName, ConnectStateCallBack connectStateCallBack, {bool isAddEquipment = false}) async {
    // 判断数组列表里面是否有这个设备
    print("devicesList:$devicesList");
    final knownDeviceIndex = devicesList.indexWhere((d) => d.advertisementData.advName == deviceName);
    if (knownDeviceIndex >= 0) {
      // 存在的时候赋值
      connectDeviceMacAddress = devicesList[knownDeviceIndex].advertisementData.advName;

      bluetoothConnectDevice = devicesList[knownDeviceIndex].device;
      print('bluetoothConnectDevice: $bluetoothConnectDevice');
      scanResult = devicesList[knownDeviceIndex];

      _initGetMtuSubscription();
      _initListenConnectionState();
    }
    print("1 connectDeviceId:$connectDeviceMacAddress  connectDeviceName:$connectDeviceName");
    // stopScan();
    if (connectDeviceMacAddress.isEmpty) {
      // connectStateCallBack(BluetoothConnectionState.disconnected!);
      return;
    }

    Get.log("调用了停止扫描的方法");
    await stopScan();

    if ((scanResult!.advertisementData.serviceUuids[0].toString()[31] == "0") && isAddEquipment == false) {
      connectStateCallBack(BluetoothConnectionState.disconnected!);
      EasyLoading.showToast("该锁已被重置", duration: 2000.milliseconds);
      return;
    }

    // 重连三次
    int maxAttempts = 3;
    int attempt = 0;
    while (attempt < maxAttempts) {
      try {
        await bluetoothConnectDevice!.connect(timeout: 5.seconds);
        break; // If the connection is successful, break the loop
      } catch (e) {
        Get.log('Failed to connect: $e');
        attempt++; // Increase the attempt count
        if (attempt < maxAttempts) {
          Get.log('Retrying connection...');
        }
      }
    }

    if (attempt >= maxAttempts) {
      Get.log('Failed to connect after $maxAttempts attempts.');
      connectStateCallBack(BluetoothConnectionState.disconnected!);
    }

    // await bluetoothConnectDevice!.connect();
    print("5555555:回调状态:$bluetoothConnectionState");
    if (bluetoothConnectionState == BluetoothConnectionState.connected) {
      try {
        bluetoothConnectDevice!.discoverServices().then((services) {
          print("333333333");
          for (BluetoothService service in services) {
            // print("11111service.remoteId:${service.remoteId}"
            //     " service.uuid:${service.uuid}"
            //     " service.characteristics:${service.characteristics}"
            //     " service.includedServices:${service.includedServices}");
            if(service.uuid == _serviceIdConnect){
              for (BluetoothCharacteristic characteristic in service.characteristics) {
                // print("22222characteristic.remoteId:${characteristic.remoteId}"
                //     " characteristic.uuid:${characteristic.uuid}"
                //     " characteristic.secondaryServiceUuid:${characteristic.secondaryServiceUuid}"
                //     " characteristic.characteristicUuid:${characteristic.characteristicUuid}");
                if (characteristic.characteristicUuid == _characteristicIdSubscription) {
                  print("44444444");
                  _subScribeToCharacteristic(characteristic);
                  print('Discovering services finished');
                  bluetoothConnectionState = BluetoothConnectionState.connected;
                  connectStateCallBack(bluetoothConnectionState!);
                }
              }
            }
          }
        });
      } on Exception catch (e) {
        bluetoothConnectionState = BluetoothConnectionState.disconnected;
        Get.log("5555 回调状态:$bluetoothConnectionState");
        connectStateCallBack(bluetoothConnectionState!);
        print('Error occurred when discovering services: $e');
        rethrow;
      }
    }
  }

  // 听上报来的数据,参数来自前面扫描到的结果
  var allData = <int>[];
  // 保存上一次的数据，用来判断是否收到重复的数据
  var lastTimeData = <int>[];
  int? dataLen;
  _subScribeToCharacteristic(BluetoothCharacteristic characteristic) async {
    final subscription = characteristic.onValueReceived.listen((data) {
      print("启动对特性的通知。当特性的值发生变化时，设备会发送一个通知");
      print("订阅获取的数据：$data");
      if(data == lastTimeData || data.isEmpty){
        return;
      }else{
        lastTimeData = data;
      }
      // code to handle incoming data
      // print("subscribeToCharacteristic: deviceId = ${characteristic.deviceId} characteristicId =${characteristic.characteristicId}---上报来的数据data = $data");
      if ((data[0] == 0xEF) && (data[1] == 0x01) && (data[2] == 0xEE) && (data[3] == 0x02)) {
        // 当包有头时
        // 判断是否需要分包
        dataLen = data[8] * 256 + data[9]; // 高16位用来指示后面数据块内容的长度
        // print("dataLen1111:$dataLen getDataLength:${data.length}");
        if (dataLen! + 12 > data.length) {
          // 当前包的长度小于实际的包时 分包添加 不解析
          allData.addAll(data);
        } else {
          // 当前包的长度小于实际的包时 不分包 解析
          allData.addAll(data);
          // print("dataLen2222:$dataLen getDataLength:${data.length}");
          CommandReciverManager.appDataReceive(allData);
          // 发送完解析初始化数组
          allData = <int>[];
        }
      } else {
        // 当包没有头时 是分包的包 直接添加
        allData.addAll(data);
        // var len = allData[8] * 256 + allData[9];
        // print("dataLen3333:$dataLen");
        if ((dataLen! + 14) <= allData.length) {
          // print("44444数据被解析了");
          // 当长度小于等于当前包的数据时 直接解析数据
          CommandReciverManager.appDataReceive(allData);
          // 发送完解析初始化数组
          allData = <int>[];
        }
      }
    });

// cleanup: cancel subscription when disconnected
    bluetoothConnectDevice!.cancelWhenDisconnected(subscription);

// enable notifications
    await characteristic.setNotifyValue(true);

    // characteristic.setNotifyValue(true).then((_) {
    //   print("启动对特性的通知。当特性的值发生变化时，设备会发送一个通知");
    //   characteristic.lastValueStream.listen((data) {
    //     print("订阅获取的数据：$data");
    //     // do something with new value
    //     if(data == lastTimeData || data.isEmpty){
    //       return;
    //     }else{
    //       lastTimeData = data;
    //     }
    //     // code to handle incoming data
    //     // print("subscribeToCharacteristic: deviceId = ${characteristic.deviceId} characteristicId =${characteristic.characteristicId}---上报来的数据data = $data");
    //     if ((data[0] == 0xEF) && (data[1] == 0x01) && (data[2] == 0xEE) && (data[3] == 0x02)) {
    //       // 当包有头时
    //       // 判断是否需要分包
    //       dataLen = data[8] * 256 + data[9]; // 高16位用来指示后面数据块内容的长度
    //       // print("dataLen1111:$dataLen getDataLength:${data.length}");
    //       if (dataLen! + 12 > data.length) {
    //         // 当前包的长度小于实际的包时 分包添加 不解析
    //         allData.addAll(data);
    //       } else {
    //         // 当前包的长度小于实际的包时 不分包 解析
    //         allData.addAll(data);
    //         // print("dataLen2222:$dataLen getDataLength:${data.length}");
    //         CommandReciverManager.appDataReceive(allData);
    //         // 发送完解析初始化数组
    //         allData = <int>[];
    //       }
    //     } else {
    //       // 当包没有头时 是分包的包 直接添加
    //       allData.addAll(data);
    //       // var len = allData[8] * 256 + allData[9];
    //       // print("dataLen3333:$dataLen");
    //       if ((dataLen! + 14) <= allData.length) {
    //         // print("44444数据被解析了");
    //         // 当长度小于等于当前包的数据时 直接解析数据
    //         CommandReciverManager.appDataReceive(allData);
    //         // 发送完解析初始化数组
    //         allData = <int>[];
    //       }
    //     }
    //   });
    // });
  }

  // 写入
  Future<void> writeCharacteristicWithResponse(List<int> value) async {
    bluetoothConnectDevice!.discoverServices().then((services) async {
      for (BluetoothService service in services) {
        // print("33333 service.remoteId:${service.remoteId}"
        //     " service.uuid:${service.uuid}\n\n"
        //     " service.characteristics:${service.characteristics}\n\n"
        //     " service.includedServices:${service.includedServices}");
        if (service.uuid == _serviceIdConnect) {
          for (BluetoothCharacteristic characteristic in service
              .characteristics) {
            // print("44444 characteristic.remoteId:${characteristic.remoteId}"
            //     " characteristic.uuid:${characteristic.uuid}\n\n"
            //     " characteristic.secondaryServiceUuid:${characteristic
            //     .secondaryServiceUuid}\n\n"
            //     " characteristic.characteristicUuid:${characteristic
            //     .characteristicUuid}");
            if (characteristic.characteristicUuid == _characteristicIdWrite) {
              try {
                List<int> valueList = value;
                List subData = splitList(valueList, _mtuSize!);
                print(
                    'writeCharacteristicWithResponse 得到的分割数据:$subData');

                for (int i = 0; i < subData.length; i++) {
                  await characteristic.write(subData[i]).then((value) async {
                    await Future.delayed(const Duration(milliseconds: 1)).then((
                        value) async {
                      print('分包发送成功了');
                    });
                  });
                }
              } on Exception catch (e, s) {
                print('Error occurred when writing: $e');
                print(s);
                rethrow;
              }
            }
          }
        }
      }
    });
    // List<BluetoothService> services = await bluetoothConnectDevice!.discoverServices();
    // BluetoothCharacteristic characteristic = services
    //     .firstWhere((service) => service.uuid == _serviceIdWrite)
    //     .characteristics
    //     .firstWhere((char) => char.uuid == _characteristicIdWrite);
    // try {
    //   List<int> valueList = value;
    //   List subData = splitList(valueList, _mtuSize!);
    //   print('writeCharacteristicWithResponse 得到的分割数据:$subData');
    //
    //   for (int i = 0; i < subData.length; i++) {
    //     await characteristic.write(subData[i]).then((value) async {
    //       await Future.delayed(const Duration(milliseconds: 1)).then((value) async {
    //         print('分包发送成功了');
    //       });
    //     });
    //   }
    // } on Exception catch (e, s) {
    //   print('Error occurred when writing: $e');
    //   print(s);
    //   rethrow;
    // }
  }

  // 读取
  // Future<List<int>> _readCharacteristic(QualifiedCharacteristic characteristic) async {
    // try {
    //   final result =
    //       await _flutterReactiveBle!.readCharacteristic(characteristic);
    //   print("readListresult$result");
    //   return result;
    // } on Exception catch (e, s) {
    //   print(
    //     'Error occurred when reading ${characteristic.characteristicId} : $e',
    //   );
    //   rethrow;
    // }
  // }

  // Future<void> writeCharacteristicWithoutResponse(
  //     QualifiedCharacteristic characteristic, List<int> value) async {
  //   try {
  //     await _flutterReactiveBle!
  //         .writeCharacteristicWithoutResponse(characteristic, value: value);
  //   } on Exception catch (e, s) {
  //     // ignore: avoid_print
  //     print(s);
  //     rethrow;
  //   }
  // }

  // 停止扫描蓝牙设备
  Future<void> stopScan() async {
    try {
      await FlutterBluePlus.stopScan();
    } catch (e) {
      Get.log("停止扫描失败");
    }
  }

  // 断开连接
  Future<void> disconnect() async {
    try {
      connectDeviceMacAddress = "";
      await bluetoothConnectDevice!.disconnect();
      Get.log("断开连接成功");
    } on Exception catch (e, _) {
      print("Error disconnecting from a device: $e");
    } finally {
      bluetoothConnectionState = BluetoothConnectionState.disconnected;
    }
  }

  disposed() {
    _sendStreamSubscription?.cancel();
    _mtuSubscription!.cancel();
    // _scanResultsSubscription!.cancel();
    _adapterStateStateSubscription!.cancel();
    _connectionStateSubscription!.cancel();
  }
}