import 'dart:convert';
import 'dart:typed_data';

import 'package:common_utils/common_utils.dart';
import 'package:get/get.dart';
import 'package:flutter_cache_manager/flutter_cache_manager.dart';

import 'package:pj_supermarket_cloud/common/index.dart';

abstract class AppSettingTool {
  static const String _tag = "app配置工具";

  static const String _settingKey = "setting";
  static const String _terminalMenuOrderKey = "terminalMenuOrder";
  static const String _hiddenTerminalMenusKey = "hiddenTerminalMenus";
  static const String _payTypeOrderKey = "payTypeOrder";
  static const String _cashierShowHoldActionKey = "cashierShowHoldAction";
  static const String _cashierShowMoreActionKey = "cashierShowMoreAction";
  static const String _reservationQueryMethodOrderKey =
      "reservationQueryMethodOrder";
  static const String _reservationQueryDefaultMethodKey =
      "reservationQueryDefaultMethod";
  static const String _reservationQueryNameMaskEnabledKey =
      "reservationQueryNameMaskEnabled";
  static const String _reservationQueryVerificationEnabledKey =
      "reservationQueryVerificationEnabled";
  static const String _reservationQueryVerificationDateScopeKey =
      "reservationQueryVerificationDateScope";
  static const String _serialCardConfigKey = "serialCardConfig";

  /// v8 之前短暂保存定时任务配置的旧 sysJson 键，仅供一次性迁移读取。
  static const String _scheduledTaskConfigsKey = "scheduledTaskConfigs";

  /// v8 之前短暂保存任务最近执行结果的旧 sysJson 键，仅供一次性迁移读取。
  static const String _scheduledTaskRecordsKey = "scheduledTaskRecords";

  /// v8 之前保存日志文件成功上传状态的旧 sysJson 键，仅供一次性迁移读取。
  static const String _terminalLogUploadStatesKey = "terminalLogUploadStates";

  /// v8 之前保存最近日志上传汇总的旧 sysJson 键，仅供一次性迁移清理。
  static const String _terminalLogUploadSummaryKey = "terminalLogUploadSummary";

  /// 人工硬件输入历史在现有 sysJson 扩展配置中的存储键。
  static const String _hardwareInputHistoryKey = "hardwareInputHistory";

  // 自定义缓存管理器
  static final CacheManager _settingCache = CacheManager(
    Config(
      'setting_cache',
      stalePeriod: const Duration(days: 7),
      maxNrOfCacheObjects: 10,
    ),
  );

  /// sysJson 扩展数据的进程内写入队列，避免迁移清理与设置保存相互覆盖。
  static Future<void> _extensionWriteQueue = Future.value();

  static Future<void> removeSettingCache() async {
    await _settingCache.emptyCache();
  }

  static Future<SettingEntity> _getSetting() async {
    // 尝试从缓存获取
    final fileInfo = await _settingCache.getFileFromCache(_settingKey);
    if (fileInfo != null) {
      final content = await fileInfo.file.readAsString();
      if (ObjectUtil.isNotEmpty(content)) {
        return SettingEntity.fromJson(json.decode(content));
      }
    }
    final app = Get.find<AppControl>();
    final settingDao = app.dataBase.getSettingDao;
    final setting = await settingDao.get();
    if (setting == null) {
      final initSysInfo = SysSetting(
        sysType: SysType.CANTEEN,
        androidId: await AppSysTool.getAndroidId(),
        sqlAddress: "",
      );
      final initUserInfo = UserSetting(
        username: "",
        password: "",
      );
      SettingEntity addObj = SettingEntity(
        userJson: json.encode(initUserInfo.toJson()),
        sysJson: json.encode(initSysInfo.toJson()),
      );
      final addId = await settingDao.save(addObj);
      if (ObjectUtil.isEmpty(addId)) {
        throw Exception("|$_tag|_getSetting新增错误");
      }
      addObj.id = addId;
      return addObj;
    }
    return setting;
  }

  static Future<bool> _setSetting({
    SysSetting? sysJson,
    UserSetting? userJson,
    CanteenExtraPriceSetting? canteenExtraPriceConfig,
  }) async {
    if (ObjectUtil.isEmpty(sysJson) &&
        ObjectUtil.isEmpty(userJson) &&
        ObjectUtil.isEmpty(canteenExtraPriceConfig)) {
      return false;
    }
    final app = Get.find<AppControl>();
    final settingDao = app.dataBase.getSettingDao;
    SettingEntity? setting = await settingDao.get();
    if (setting == null) {
      logger.e("|$_tag|_setSetting新增错误settingDao.get()方法返回为null");
      return false;
    }
    if (sysJson != null) {
      final current = Map<String, dynamic>.from(json.decode(setting.sysJson));
      // sysJson 允许保存不涉及数据库结构的终端 UI 扩展配置，更新业务设置时必须保留这些键。
      setting.sysJson = json.encode({...current, ...sysJson.toJson()});
    }
    if (userJson != null) {
      setting.userJson = json.encode(userJson.toJson());
    }
    if (canteenExtraPriceConfig != null) {
      setting.canteenExtraPriceConfigJson = json.encode(
        canteenExtraPriceConfig.toJson(),
      );
    }
    await settingDao.edit(setting);
    await _settingCache.putFile(
      _settingKey,
      Uint8List.fromList(utf8.encode(json.encode(setting.toJson()))),
      fileExtension: 'json',
    );
    return true;
  }

  static Future<SysSetting> getSysSetting() async {
    final setting = await _getSetting();
    return SysSetting.fromJson(json.decode(setting.sysJson));
  }

  static Future<UserSetting> getUserSetting() async {
    final setting = await _getSetting();
    return UserSetting.fromJson(json.decode(setting.userJson));
  }

  static Future<CanteenExtraPriceSetting?> getCanteenExtraPriceConfig() async {
    final setting = await _getSetting();
    if (ObjectUtil.isEmpty(setting.canteenExtraPriceConfigJson)) {
      return null;
    }
    return CanteenExtraPriceSetting.fromJson(
      json.decode(setting.canteenExtraPriceConfigJson!),
    );
  }

  static Future<void> setSysSetting(SysSetting sysInfo) async {
    await _setSetting(sysJson: sysInfo);
  }

  /// 读取完整 sysJson 为可修改映射，仅供旧结构化数据迁移方法使用。
  static Future<Map<String, dynamic>> _getSysExtensionJson() async {
    final setting = await _getSetting();
    return Map<String, dynamic>.from(json.decode(setting.sysJson));
  }

  /// 仅用于把 v8 之前短暂写入 sysJson 的任务配置导入结构化表，不再提供 JSON 写入口。
  static Future<List<ScheduledTaskConfig>> getScheduledTaskConfigs() async {
    final sysJson = await _getSysExtensionJson();
    final raw = sysJson[_scheduledTaskConfigsKey];
    if (raw is! List) return const [];
    return raw
        .whereType<Map>()
        .map((item) => ScheduledTaskConfig.fromJson(
              Map<String, dynamic>.from(item),
            ))
        .toList(growable: false);
  }

  /// 读取 v8 之前的任务执行快照并按当前枚举过滤未知任务，仅用于迁移。
  static Future<Map<ScheduledTaskType, ScheduledTaskRecord>>
      getScheduledTaskRecords() async {
    final sysJson = await _getSysExtensionJson();
    final raw = sysJson[_scheduledTaskRecordsKey];
    if (raw is! Map) return const {};
    final result = <ScheduledTaskType, ScheduledTaskRecord>{};
    for (final entry in raw.entries) {
      ScheduledTaskType? type;
      for (final item in ScheduledTaskType.values) {
        if (item.name == entry.key.toString()) {
          type = item;
          break;
        }
      }
      if (type == null || entry.value is! Map) continue;
      result[type] = ScheduledTaskRecord.fromJson(
        Map<String, dynamic>.from(entry.value as Map),
      );
    }
    return result;
  }

  /// 读取 v8 之前按相对路径保存的成功上传状态，仅用于导入文件上传记录表。
  static Future<Map<String, TerminalLogUploadState>>
      getTerminalLogUploadStates() async {
    final sysJson = await _getSysExtensionJson();
    final raw = sysJson[_terminalLogUploadStatesKey];
    if (raw is! Map) return const {};
    return raw.map(
      (key, value) => MapEntry(
        key.toString(),
        TerminalLogUploadState.fromJson(
          Map<String, dynamic>.from(value as Map),
        ),
      ),
    );
  }

  /// 读取 v8 之前的最近上传汇总；仅保留兼容能力，不再作为运行时数据源。
  static Future<TerminalLogUploadSummary> getTerminalLogUploadSummary() async {
    final sysJson = await _getSysExtensionJson();
    final raw = sysJson[_terminalLogUploadSummaryKey];
    if (raw is! Map) return const TerminalLogUploadSummary();
    return TerminalLogUploadSummary.fromJson(Map<String, dynamic>.from(raw));
  }

  /// v8 已将任务与上传状态迁入独立表，导入成功后移除旧 JSON，避免形成双写数据源。
  static Future<void> clearLegacyScheduledTaskState({
    required bool includeUploadState,
  }) async {
    final operation = _extensionWriteQueue.catchError((_) {}).then((_) async {
      final app = Get.find<AppControl>();
      final settingDao = app.dataBase.getSettingDao;
      final setting = await settingDao.get();
      if (setting == null) throw StateError('终端设置尚未初始化');
      final sysJson = Map<String, dynamic>.from(json.decode(setting.sysJson));
      sysJson.remove(_scheduledTaskConfigsKey);
      sysJson.remove(_scheduledTaskRecordsKey);
      if (includeUploadState) {
        sysJson.remove(_terminalLogUploadStatesKey);
        sysJson.remove(_terminalLogUploadSummaryKey);
      }
      setting.sysJson = json.encode(sysJson);
      await settingDao.edit(setting);
      await _settingCache.putFile(
        _settingKey,
        Uint8List.fromList(utf8.encode(json.encode(setting.toJson()))),
        fileExtension: 'json',
      );
    });
    _extensionWriteQueue = operation;
    await operation;
  }

  static Future<void> setUserSetting(UserSetting userInfo) async {
    final globalUserInfo = await getUserSetting();
    if (globalUserInfo == userInfo) return;
    if (ObjectUtil.isEmpty(userInfo.tenantId) &&
        ObjectUtil.isNotEmpty(globalUserInfo.tenantId)) {
      userInfo.tenantId = globalUserInfo.tenantId;
    }
    await _setSetting(userJson: userInfo);
  }

  static Future<void> setCanteenExtraPriceConfig(
    CanteenExtraPriceSetting canteenExtraPriceConfig,
  ) async {
    final config = await getCanteenExtraPriceConfig();
    if (config == canteenExtraPriceConfig) return;
    await _setSetting(canteenExtraPriceConfig: canteenExtraPriceConfig);
  }

  /// 读取左侧菜单的顺序和隐藏状态，未知或缺失项由控制器按默认菜单补齐。
  static Future<({List<String> order, Set<String> hidden})>
      getTerminalMenuPreferences() async {
    final setting = await _getSetting();
    final sysJson = Map<String, dynamic>.from(json.decode(setting.sysJson));
    final order = (sysJson[_terminalMenuOrderKey] as List<dynamic>?)
            ?.whereType<String>()
            .toList() ??
        const <String>[];
    final hidden = (sysJson[_hiddenTerminalMenusKey] as List<dynamic>?)
            ?.whereType<String>()
            .toSet() ??
        const <String>{};
    return (order: order, hidden: hidden);
  }

  /// 菜单布局属于设备级 UI 设置，直接复用 setting 表中的 sysJson，避免增加数据库字段和迁移。
  static Future<void> setTerminalMenuPreferences({
    required List<String> order,
    required Set<String> hidden,
  }) async {
    final app = Get.find<AppControl>();
    final settingDao = app.dataBase.getSettingDao;
    final setting = await settingDao.get();
    if (setting == null) {
      throw StateError('终端设置尚未初始化');
    }
    final sysJson = Map<String, dynamic>.from(json.decode(setting.sysJson));
    sysJson[_terminalMenuOrderKey] = order;
    sysJson[_hiddenTerminalMenusKey] = hidden.toList();
    setting.sysJson = json.encode(sysJson);
    await settingDao.edit(setting);
    await _settingCache.putFile(
      _settingKey,
      Uint8List.fromList(utf8.encode(json.encode(setting.toJson()))),
      fileExtension: 'json',
    );
  }

  /// 读取支付方式的完整顺序；显隐仍由 SysSetting.usePayDisplayType 维护。
  static Future<List<String>> getPayTypeOrder() async {
    final setting = await _getSetting();
    final sysJson = Map<String, dynamic>.from(json.decode(setting.sysJson));
    return (sysJson[_payTypeOrderKey] as List<dynamic>?)
            ?.whereType<String>()
            .toList() ??
        const <String>[];
  }

  /// 支付排序属于终端 UI 扩展配置，与现有支付显隐和默认方式一起原子保存。
  static Future<void> setPayTypePreferences({
    required SysSetting sysInfo,
    required List<OrderPayDisplayType> order,
  }) async {
    // 在首次异步等待前生成快照，避免连续拖动时后一次修改污染本次落盘内容。
    final nextSysJson = sysInfo.toJson();
    final visiblePayTypes = nextSysJson['usePayDisplayType'];
    final defaultPayType = nextSysJson['defaultPayDisplayType'];
    final orderCodes = order.map((item) => item.code).toList();
    final app = Get.find<AppControl>();
    final settingDao = app.dataBase.getSettingDao;
    final setting = await settingDao.get();
    if (setting == null) {
      throw StateError('终端设置尚未初始化');
    }
    final current = Map<String, dynamic>.from(json.decode(setting.sysJson));
    current['usePayDisplayType'] = visiblePayTypes;
    current['defaultPayDisplayType'] = defaultPayType;
    current[_payTypeOrderKey] = orderCodes;
    setting.sysJson = json.encode(current);
    await settingDao.edit(setting);
    await _settingCache.putFile(
      _settingKey,
      Uint8List.fromList(utf8.encode(json.encode(setting.toJson()))),
      fileExtension: 'json',
    );
  }

  /// 读取收银页底部快捷操作显隐；旧终端没有配置时保持两个入口都显示。
  static Future<({bool showHoldAction, bool showMoreAction})>
      getCashierPagePreferences() async {
    final setting = await _getSetting();
    final sysJson = Map<String, dynamic>.from(json.decode(setting.sysJson));
    return (
      showHoldAction: sysJson[_cashierShowHoldActionKey] != false,
      showMoreAction: sysJson[_cashierShowMoreActionKey] != false,
    );
  }

  /// 收银快捷操作属于本机页面布局配置，继续复用 sysJson，避免增加数据库字段。
  static Future<void> setCashierPagePreferences({
    required bool showHoldAction,
    required bool showMoreAction,
  }) async {
    final app = Get.find<AppControl>();
    final settingDao = app.dataBase.getSettingDao;
    final setting = await settingDao.get();
    if (setting == null) throw StateError('终端设置尚未初始化');
    final sysJson = Map<String, dynamic>.from(json.decode(setting.sysJson));
    sysJson[_cashierShowHoldActionKey] = showHoldAction;
    sysJson[_cashierShowMoreActionKey] = showMoreAction;
    setting.sysJson = json.encode(sysJson);
    await settingDao.edit(setting);
    await _settingCache.putFile(
      _settingKey,
      Uint8List.fromList(utf8.encode(json.encode(setting.toJson()))),
      fileExtension: 'json',
    );
  }

  /// 读写卡协议配置属于设备本地扩展设置，复用 sysJson 保存且不修改数据库结构。
  static Future<SerialCardConfig> getSerialCardConfig() async {
    final setting = await _getSetting();
    final sysJson = Map<String, dynamic>.from(json.decode(setting.sysJson));
    final source = sysJson[_serialCardConfigKey];
    if (source is! Map) return const SerialCardConfig();
    try {
      return SerialCardConfig.fromJson(Map<String, dynamic>.from(source));
    } on Object {
      // 旧版本或人工修改的异常配置不能阻断收银读卡，无法解析时回退设备默认参数。
      return const SerialCardConfig();
    }
  }

  /// 密钥只写入本机设置和串口模块，不记录到日志，也不随普通业务接口上传。
  static Future<void> setSerialCardConfig(SerialCardConfig config) async {
    final app = Get.find<AppControl>();
    final settingDao = app.dataBase.getSettingDao;
    final setting = await settingDao.get();
    if (setting == null) throw StateError('终端设置尚未初始化');
    final sysJson = Map<String, dynamic>.from(json.decode(setting.sysJson));
    sysJson[_serialCardConfigKey] = config.toJson();
    setting.sysJson = json.encode(sysJson);
    await settingDao.edit(setting);
    await _settingCache.putFile(
      _settingKey,
      Uint8List.fromList(utf8.encode(json.encode(setting.toJson()))),
      fileExtension: 'json',
    );
  }

  /// 查询方式顺序和默认项属于页面交互配置，继续保存在 sysJson 中，不增加数据库字段。
  static Future<ReservationQueryPagePreferences>
      getReservationQueryPagePreferences() async {
    final setting = await _getSetting();
    final sysJson = Map<String, dynamic>.from(json.decode(setting.sysJson));
    final byCode = {
      for (final method in ReservationRecognitionMethod.values)
        method.code: method,
    };
    final restored = <ReservationRecognitionMethod>[];
    final storedOrder =
        (sysJson[_reservationQueryMethodOrderKey] as List<dynamic>?)
                ?.whereType<String>() ??
            const <String>[];
    for (final code in storedOrder) {
      final method = byCode[code];
      if (method != null && !restored.contains(method)) restored.add(method);
    }
    for (final method in ReservationRecognitionMethod.values) {
      if (!restored.contains(method)) restored.add(method);
    }
    final storedDefault =
        byCode[sysJson[_reservationQueryDefaultMethodKey] as String?];
    final defaultMethod =
        storedDefault != null && restored.contains(storedDefault)
            ? storedDefault
            : restored.first;
    final verificationDateScope = ReservationVerificationDateScope.values
            .where(
              (scope) =>
                  scope.code ==
                  sysJson[_reservationQueryVerificationDateScopeKey],
            )
            .firstOrNull ??
        ReservationVerificationDateScope.today;
    return ReservationQueryPagePreferences(
      methodOrder: List.unmodifiable(restored),
      defaultMethod: defaultMethod,
      // 旧设置没有该键时继续脱敏，避免升级后意外展示完整姓名。
      nameMaskEnabled: sysJson[_reservationQueryNameMaskEnabledKey] != false,
      verificationEnabled:
          sysJson[_reservationQueryVerificationEnabledKey] == true,
      verificationDateScope: verificationDateScope,
    );
  }

  /// 顺序与默认项一起保存，避免连续操作后出现“默认项不在当前列表中”的矛盾状态。
  static Future<void> setReservationQueryPagePreferences({
    required List<ReservationRecognitionMethod> order,
    required ReservationRecognitionMethod defaultMethod,
    required bool nameMaskEnabled,
    required bool verificationEnabled,
    required ReservationVerificationDateScope verificationDateScope,
  }) async {
    final normalized = <ReservationRecognitionMethod>[];
    for (final method in order) {
      if (!normalized.contains(method)) normalized.add(method);
    }
    for (final method in ReservationRecognitionMethod.values) {
      if (!normalized.contains(method)) normalized.add(method);
    }
    final normalizedDefault =
        normalized.contains(defaultMethod) ? defaultMethod : normalized.first;
    final app = Get.find<AppControl>();
    final settingDao = app.dataBase.getSettingDao;
    final setting = await settingDao.get();
    if (setting == null) {
      throw StateError('终端设置尚未初始化');
    }
    final sysJson = Map<String, dynamic>.from(json.decode(setting.sysJson));
    sysJson[_reservationQueryMethodOrderKey] =
        normalized.map((method) => method.code).toList();
    sysJson[_reservationQueryDefaultMethodKey] = normalizedDefault.code;
    sysJson[_reservationQueryNameMaskEnabledKey] = nameMaskEnabled;
    sysJson[_reservationQueryVerificationEnabledKey] = verificationEnabled;
    sysJson[_reservationQueryVerificationDateScopeKey] =
        verificationDateScope.code;
    setting.sysJson = json.encode(sysJson);
    await settingDao.edit(setting);
    await _settingCache.putFile(
      _settingKey,
      Uint8List.fromList(utf8.encode(json.encode(setting.toJson()))),
      fileExtension: 'json',
    );
  }

  /// 读取指定“路由 + 功能键”场景最近使用的人工硬件输入，异常旧数据会被忽略。
  static Future<List<HardwareInputHistoryEntry>> getHardwareInputHistory(
    String sceneKey,
  ) async {
    final store = await _getHardwareInputHistoryStore();
    return List.unmodifiable(store.entriesFor(sceneKey));
  }

  /// 保存当前场景最近 5 条输入；相同输入只更新备注和时间并置顶，不产生重复记录。
  static Future<void> saveHardwareInputHistory({
    required String sceneKey,
    required String value,
    String? remark,
  }) async {
    final normalizedValue = value.trim();
    if (normalizedValue.isEmpty) return;
    final app = Get.find<AppControl>();
    final settingDao = app.dataBase.getSettingDao;
    final setting = await settingDao.get();
    if (setting == null) throw StateError('终端设置尚未初始化');
    final sysJson = Map<String, dynamic>.from(json.decode(setting.sysJson));
    final store = _decodeHardwareInputHistoryStore(
      sysJson[_hardwareInputHistoryKey],
    );
    final nextStore = store.save(
      sceneKey: sceneKey,
      value: normalizedValue,
      remark: remark ?? '',
      updatedAt: DateTime.now(),
    );
    sysJson[_hardwareInputHistoryKey] = nextStore.toJson();
    setting.sysJson = json.encode(sysJson);
    await settingDao.edit(setting);
    await _settingCache.putFile(
      _settingKey,
      Uint8List.fromList(utf8.encode(json.encode(setting.toJson()))),
      fileExtension: 'json',
    );
  }

  /// 从现有 sysJson 扩展配置读取强类型历史模型，单条异常数据不影响人工输入主流程。
  static Future<HardwareInputHistoryStore>
      _getHardwareInputHistoryStore() async {
    final setting = await _getSetting();
    final sysJson = Map<String, dynamic>.from(json.decode(setting.sysJson));
    return _decodeHardwareInputHistoryStore(sysJson[_hardwareInputHistoryKey]);
  }

  /// JSON Map 仅停留在设置存储边界，弹窗与去重逻辑统一操作强类型模型。
  static HardwareInputHistoryStore _decodeHardwareInputHistoryStore(
    Object? source,
  ) {
    if (source is! Map) return HardwareInputHistoryStore.empty;
    try {
      return HardwareInputHistoryStore.fromJson(
        Map<String, dynamic>.from(source),
      );
    } on Object {
      return HardwareInputHistoryStore.empty;
    }
  }

  // 根据后台返回的数据更新到缓存
  static Future<void> updateSysInfoByService(ServiceHardware data) async {
    if (ObjectUtil.isEmpty(data)) {
      final setting = SysSetting(
        sysType: SysType.CANTEEN,
        androidId: await AppSysTool.getAndroidId(),
        sqlAddress: await AppFileTool.getDatabaseBackupPath(),
      );
      await _setSetting(sysJson: setting);
      return;
    }
    final sysSetting = await AppSettingTool.getSysSetting();
    final id = data.id;
    if (ObjectUtil.isNotEmpty(id)) {
      sysSetting.serviceId = id;
    }
    final name = data.name;
    if (ObjectUtil.isNotEmpty(name)) {
      sysSetting.serviceName = name;
    }
    final type = data.type.toString();
    if (ObjectUtil.isNotEmpty(type)) {
      final t = SysType.values.fromCode(type);
      if (ObjectUtil.isNotEmpty(t)) {
        sysSetting.sysType = t!;
      }
    }
    final merchantId = data.merchantId;
    if (ObjectUtil.isNotEmpty(merchantId)) {
      sysSetting.serviceMerchantId = merchantId;
    }
    final hardGroupId = data.hardGroupId;
    if (ObjectUtil.isNotEmpty(hardGroupId)) {
      sysSetting.hardGroupId = hardGroupId;
    }
    final merchantDeptId = data.merchantDeptId;
    if (ObjectUtil.isNotEmpty(merchantDeptId)) {
      sysSetting.merchantDeptId = merchantDeptId;
    }
    final mqClientId = data.mqClientId;
    if (ObjectUtil.isNotEmpty(mqClientId)) {
      sysSetting.mqClientId = mqClientId;
    }
    final mainTopic = data.mainTopic;
    if (ObjectUtil.isNotEmpty(mainTopic)) {
      sysSetting.mainTopic = mainTopic;
    }
    final mqSocketAddress = data.mqSocketAddress;
    if (ObjectUtil.isNotEmpty(mqSocketAddress)) {
      sysSetting.mqSocketAddress = mqSocketAddress;
    }
    final mqSocketPort = data.mqSocketPort;
    if (ObjectUtil.isNotEmpty(mqSocketPort)) {
      sysSetting.mqSocketPort = mqSocketPort;
    }
    final mqUsername = data.mqUsername;
    if (ObjectUtil.isNotEmpty(mqUsername)) {
      sysSetting.mqUsername = mqUsername;
    }
    final mqPassword = data.mqPassword;
    if (ObjectUtil.isNotEmpty(mqPassword)) {
      sysSetting.mqPassword = mqPassword;
    }
    final faceAppId = data.faceAppId;
    if (ObjectUtil.isNotEmpty(faceAppId)) {
      sysSetting.faceAppId = faceAppId;
    }
    final faceSdkKey = data.faceSdkKey;
    if (ObjectUtil.isNotEmpty(faceSdkKey)) {
      sysSetting.faceSdkKey = faceSdkKey;
    }
    final faceActiveKey = data.faceActiveKey;
    if (ObjectUtil.isNotEmpty(faceActiveKey)) {
      sysSetting.faceActiveKey = faceActiveKey;
    }
    final android = data.uniqueCode;
    if (ObjectUtil.isNotEmpty(android)) {
      sysSetting.androidId = android;
    }
    sysSetting.syncTime = DateTime.now();
    await _setSetting(sysJson: sysSetting);
  }

  /// 绑定设备信息
  static Future<bool> bindSys(int serviceId) async {
    var androidId = await AppSysTool.getAndroidId();
    if (ObjectUtil.isEmpty(androidId)) return false;
    final pa = {"id": serviceId, "uniqueCode": androidId};
    try {
      final data = await HardApi.bind(pa);
      if (data == null) {
        logger.e("绑定设备信息pa:|${jsonEncode(pa)}|;res:$data;");
        return false;
      }
      await AppSettingTool.updateSysInfoByService(data);
      return true;
    } catch (e, stack) {
      logger.e("|$_tag|绑定信息错误error:|$e|stack:$stack");
    }
    return false;
  }
}