import 'dart:async';

import 'package:flutter_blue_plus/flutter_blue_plus.dart';
import 'package:get/get.dart';
import 'package:wifi_iot/wifi_iot.dart';

class MeetingConnectController extends GetxController {
  RxString stateStr = '搜索中...'.obs;
  RxBool isRescan = false.obs;
  RxBool isImportedFiles = false.obs;
  RxString importedFilesStr = ''.obs;

  late StreamSubscription<List<ScanResult>> _scanResultsSubscription;
  late StreamSubscription<bool> _isScanningSubscription;
  BluetoothDevice? _device;

  bool isScanFailed = false;

  late BluetoothCharacteristic? _writeCharacteristic;
  late StreamSubscription<List<int>>? _valueReceivedSubscription;

  String _wifiSSID = '';
  String _wifiPassword = '';
  String _ftpAddress = '';
  String _ftpPort = '';
  String _ftpAccount = '';
  String _ftpPassword = '';

  @override
  void onInit() {
    super.onInit();
    _scanResultsSubscription = FlutterBluePlus.scanResults.listen((results) {
      for (ScanResult item in results) {
        _handlerScanResult(item);
      }
    });
    _isScanningSubscription = FlutterBluePlus.isScanning.listen((state) {
      if (isScanFailed) {
        stateStr.value = '搜索失败，请检查蓝牙是否开启';
        isRescan.value = true;
        return;
      }
      if (!state && _device == null) {
        stateStr.value = '未搜索到 AI PEN 设备';
        isRescan.value = true;
      } else {
        stateStr.value = '搜索中...';
        isRescan.value = false;
      }
    });
    startScan();
  }

  @override
  void onClose() {
    _scanResultsSubscription.cancel();
    _isScanningSubscription.cancel();
    _valueReceivedSubscription?.cancel();
    _stopScan();
    _disconnect();
    super.onClose();
  }

  Future<void> startScan() async {
    try {
      isScanFailed = false;
      await FlutterBluePlus.startScan(
        timeout: const Duration(seconds: 15),
        withServices: [
          Guid('FFF0'),
        ],
        withNames: ['AI PEN'],
      );
    } catch (e) {
      isScanFailed = true;
    }
  }

  Future<void> _stopScan() async {
    await FlutterBluePlus.stopScan();
  }

  Future<void> _connect() async {
    await _device?.connect();
    await _discoverServices();
  }

  Future<void> _disconnect() async {
    await WiFiForIoTPlugin.disconnect();
    await _device?.disconnect();
  }

  void _handlerScanResult(ScanResult result) async {
    if (result.device.platformName == 'AI PEN') {
      _device = result.device;
      await _stopScan();
      await _connect();
      stateStr.value = '已连接到 AI PEN 设备';
    }
  }

  Future<void> _discoverServices() async {
    List<BluetoothService> services = await _device?.discoverServices() ?? [];
    if (services.isNotEmpty) {
      for (var element in services) {
        if (element.serviceUuid == Guid('FFF0')) {
          _readCharacteristics(element.characteristics);
        }
      }
    }
  }

  Future<void> _readCharacteristics(
      List<BluetoothCharacteristic> characteristics) async {
    for (var element in characteristics) {
      if (element.characteristicUuid == Guid('FFF1')) {
        _writeCharacteristic = element;
        stateStr.value = '检查是否有新文件需要导入';
        sendData([0x5a, 0x01, 0x0d]);
      } else if (element.characteristicUuid == Guid('FFF2')) {
        await element.setNotifyValue(true);
        _valueReceivedSubscription = element.onValueReceived.listen((value) {
          _listenData(value);
        });
      }
    }
  }

  Future<void> sendData(List<int> value) async {
    await _writeCharacteristic?.write(value, withoutResponse: true);
  }

  void _listenData(List<int> value) {
    print('----$value--------');
    int command = value[2];
    switch (command) {
      case 0x0d: // 是否有导入文件
        if (value[3] == 0x01) {
          isImportedFiles.value = true;
          importedFilesStr.value = '检查到有新文件，是否导入';
        } else {
          isImportedFiles.value = false;
          importedFilesStr.value = '没有新文件需要导入';
        }
        break;
      case 0x87: // Wi-Fi 开启/关闭
        if (value[3] == 0x01 && value[4] == 0x01) {
          _getWifi();
        }
        break;
      case 0x0b: // WiFi 热点 SSID
        _wifiSSID = String.fromCharCodes(value.sublist(3, value.length - 2));
        _connectWifi();
        break;
      case 0x0c: // WiFi 热点密码
        _wifiPassword = _decodePassword(value);
        _connectWifi();
        break;
      case 0x03: // FTP 地址
        _ftpAddress = String.fromCharCodes(value.sublist(3, value.length - 2));
        sendData([0x5a, 0x01, 0x04]);
        break;
      case 0x04: // FTP 端口
        _ftpPort = String.fromCharCodes(value.sublist(3, value.length - 2));
        sendData([0x5a, 0x01, 0x05]);
        break;
      case 0x05: // FTP 账号
        _ftpAccount = String.fromCharCodes(value.sublist(3, value.length - 2));
        sendData([0x5a, 0x01, 0x06]);
        break;
      case 0x06: // FTP 密码
        _ftpPassword = _decodePassword(value);
        _connectFtp();
        break;
      default:
    }
  }

  void _getWifi() async {
    await sendData([0x5a, 0x01, 0x0b]);
    await sendData([0x5a, 0x01, 0x0c]);
  }

  void _connectWifi() async {
    if (_wifiSSID.isNotEmpty && _wifiPassword.isNotEmpty) {
      stateStr.value = '正在连接 Wi-Fi...';
      await WiFiForIoTPlugin.connect(
        _wifiSSID,
        password: _wifiPassword,
        security: NetworkSecurity.WPA,
      );
      stateStr.value = 'Wi-Fi 连接成功';
      sendData([0x5a, 0x01, 0x03]);
    }
  }

  void _connectFtp() {
    if (_ftpAddress.isNotEmpty &&
        _ftpPort.isNotEmpty &&
        _ftpAccount.isNotEmpty &&
        _ftpPassword.isNotEmpty) {}
  }

  String _decodePassword(List<int> data) {
    final passwordData = data.sublist(3, data.length - 2);
    final decodedBytes = passwordData.map((byte) => byte ^ 0xFF).toList();
    return String.fromCharCodes(decodedBytes);
  }
}