import 'dart:async';

import 'package:flutter/cupertino.dart';
import 'package:flutter/scheduler.dart';
import 'package:flutter_blue_plus/flutter_blue_plus.dart';
import 'package:get/get.dart';
import 'package:star_lock/blue/io_type.dart';
import 'package:star_lock/tools/baseGetXController.dart';

import '../../../blue/blue_manage.dart';
import '../../../blue/io_protocol/io_factoryDataReset.dart';
import '../../../blue/io_reply.dart';
import '../../../blue/io_tool/io_tool.dart';
import '../../../blue/io_tool/manager_event_bus.dart';
import '../../../blue/sender_manage.dart';
import '../../../common/XSConstantMacro/XSConstantMacro.dart';
import '../../../network/api_repository.dart';
import '../../../tools/dateTool.dart';
import '../../../tools/eventBusEventManage.dart';
import '../../../tools/showTipView.dart';
import '../../../tools/storage.dart';
import '../../../translations/trans_lib.dart';
import '../entity/lockListInfo_entity.dart';
import 'lockList_state.dart';

class LockListLogic extends BaseGetXController{
  LockListState state = LockListState();

  // 监听蓝牙协议返回结果
  late StreamSubscription<Reply> _replySubscription;
  void _initReplySubscription() {
    _replySubscription = EventBusManager().eventBus!.on<Reply>().listen((reply) async {
      // 恢复出厂设置
      if ((reply is FactoryDataResetReply) && (state.ifCurrentScreen.value == true)) {
        _replyFactoryDataResetKey(reply);
      }
    });
  }

  Future<void> _replyFactoryDataResetKey(Reply reply) async {
    var token = reply.data.sublist(2, 6);
    var saveStrList = changeIntListToStringList(token);
    Storage.setStringList(saveBlueToken, saveStrList);

    int status = reply.data[6];
    switch (status) {
      case 0x00:
        //成功
        dismissEasyLoading();
        cancelBlueConnetctToastTimer();
        deletLockInfoData();
        break;
      case 0x06:
        //无权限
        var token = await Storage.getStringList(saveBlueToken);
        List<int> getTokenList = changeStringListToIntList(token!);

        IoSenderManage.senderFactoryDataReset(
            lockID: BlueManage().connectDeviceName,
            userID: await Storage.getUid(),
            keyID: "1",
            needAuthor: 1,
            publicKey: state.lockListInfoItemEntity.bluetooth!.publicKey!.cast<int>(),
            privateKey: state.lockListInfoItemEntity.bluetooth!.privateKey!.cast<int>(),
            token: getTokenList);
        break;
      case 0x07:
        //无权限
        dismissEasyLoading();
        showToast("用户无权限");
        break;
      case 0x09:
        // 权限校验错误
        dismissEasyLoading();
        // showToast("权限校验错误");
        break;
      default:
        //失败
        dismissEasyLoading();
        // showToast("权限校验错误");
        break;
    }
  }

  String showElectricIcon (int electricnumber){
    if(electricnumber >= 100){
      return 'images/main/icon_lockElectricLevel_5.png';
    }else if((electricnumber > 50) && (electricnumber < 100)){
      return 'images/main/icon_lockElectricLevel_4.png';
    }else if((electricnumber > 25) && (electricnumber <= 50)){
      return 'images/main/icon_lockElectricLevel_3.png';
    }else if((electricnumber > 5) && (electricnumber <= 25)){
      return 'images/main/icon_lockElectricLevel_2.png';
    }else if(electricnumber <= 5){
      return 'images/main/icon_lockElectricLevel_1.png';
    }
    return 'images/main/icon_lockElectricLevel_5.png';
  }

  String getKeyEffective(LockListInfoItemEntity keyInfo){
    // 当是限时、循环的时候
    if(keyInfo.keyType == XSConstantMacro.keyTypeTime || keyInfo.keyType == XSConstantMacro.keyTypeLoop){
      // 当是正常使用跟待接收状态的时候
      if(keyInfo.keyStatus == XSConstantMacro.keyStatusNormalUse || keyInfo.keyStatus == XSConstantMacro.keyStatusWaitReceive) {
        return "${"余".tr}${DateTool().compareTimeGetDaysFromNow(keyInfo.endDate!)}${"天".tr}";
      } else {
        return XSConstantMacro.getKeyStatusStr(keyInfo.keyStatus!);
      }
    }
    return "";
  }

/// 以下为删除逻辑
  deleyLockLogicOfRoles(){
    if (state.lockListInfoItemEntity.isLockOwner == 1) {
      // 超级管理员必须通过连接蓝牙删除
      ShowTipView().showIosTipWithContentDialog("删除锁后，所有信息都会一起删除，确定删除锁吗？".tr, (){
        // 删除锁
        ShowTipView().showTFViewAlertDialog(state.passwordTF, "请输入登录密码".tr, "请输入登录密码".tr, (){
          checkLoginPassword();
        });
      });
    } else if (state.lockListInfoItemEntity.keyRight == 1){
      // 授权管理员弹框提示
      ShowTipView().showDeleteAdministratorIsHaveAllDataDialog("同时删除其发送的所有钥匙，钥匙删除后不能恢复".tr, (a){
        // 授权管理员删除
        state.deleteAdministratorIsHaveAllData.value = a;
        deletKeyData();
      });
    } else{
      // 普通用户直接删除
      ShowTipView().showIosTipWithContentDialog("是否删除钥匙？".tr, (){
        deletKeyData();
      });
    }
  }

  // 查询账户密码
  void checkLoginPassword() async {
    var entity = await ApiRepository.to.checkLoginPassword(
      password: state.passwordTF.text,
    );
    if (entity.errorCode!.codeIsSuccessful) {
      Get.back();
      factoryDataResetAction();
    }
  }

  // 当是锁拥有者的时候，删除锁
  void deletLockInfoData() async {
    var entity = await ApiRepository.to.deletOwnerLockData(
      lockId: state.lockListInfoItemEntity.lockId!,
    );
    if (entity.errorCode!.codeIsSuccessful) {
      BlueManage().connectDeviceMacAddress = "";
      SchedulerBinding.instance.addPostFrameCallback((_) {
        eventBus.fire(RefreshLockListInfoDataEvent());
      });
    }
  }

  // 普通用户或者授权管理员删除钥匙
  void deletKeyData() async {
    var entity = await ApiRepository.to.deletOwnerKeyData(
        lockId: state.lockListInfoItemEntity.lockId.toString(),
        keyId: state.lockListInfoItemEntity.keyId.toString(),
        includeUnderlings: state.deleteAdministratorIsHaveAllData.value == true ? 1 : 0
    );
    if (entity.errorCode!.codeIsSuccessful) {
      BlueManage().connectDeviceMacAddress = "";
      SchedulerBinding.instance.addPostFrameCallback((_) {
        eventBus.fire(RefreshLockListInfoDataEvent());
      });
    }
  }

  // 恢复出厂设置
  Future<void> factoryDataResetAction() async {
    showEasyLoading();
    showBlueConnetctToastTimer(isShowBlueConnetctToast: false, action: (){
      dismissEasyLoading();
      showDeletAlertTipDialog();
    });
    BlueManage().blueSendData(state.lockListInfoItemEntity.lockName!, (BluetoothConnectionState connectionState) async {
      if (connectionState == BluetoothConnectionState.connected) {
        List<int> publicKeyData = state.lockListInfoItemEntity.bluetooth!.publicKey!.cast<int>();
        var saveStrList = changeIntListToStringList(publicKeyData);
        Storage.setStringList(saveBluePublicKey, saveStrList);

        // 私钥
        List<int> privateKeyData = state.lockListInfoItemEntity.bluetooth!.privateKey!.cast<int>();
        var savePrivateKeyList = changeIntListToStringList(privateKeyData);
        Storage.setStringList(saveBluePrivateKey, savePrivateKeyList);

        // signKey
        List<int> signKeyData = state.lockListInfoItemEntity.bluetooth!.signKey!.cast<int>();
        var saveSignKeyList = changeIntListToStringList(signKeyData);
        Storage.setStringList(saveBlueSignKey, saveSignKeyList);

        var saveTokenList = changeIntListToStringList([0, 0, 0, 0]);
        Storage.setStringList(saveBlueToken, saveTokenList);

        IoSenderManage.senderFactoryDataReset(
            lockID: BlueManage().connectDeviceName,
            userID: await Storage.getUid(),
            keyID: "1",
            needAuthor: 1,
            publicKey: state.lockListInfoItemEntity.bluetooth!.publicKey!.cast<int>(),
            privateKey: state.lockListInfoItemEntity.bluetooth!.privateKey!.cast<int>(),
            token: [0,0,0,0]);
      } else if (connectionState == BluetoothConnectionState.disconnected) {
        dismissEasyLoading();
        cancelBlueConnetctToastTimer();
        if(state.ifCurrentScreen.value == true){
          showDeletAlertTipDialog();
        }
      }
    });
  }

  void showDeletAlertTipDialog({String? showContent = ""}) {
    // bool isContains = BlueManage().connectDeviceName!.contains("T9A");
    var content = showContent!.isEmpty ? "${"删除设备失败，请确保在设备附近，设备未被连接，设备已打开".tr}${BlueManage().connectDeviceName!.contains("T9A") == true ? "。如果是全自动锁，请使屏幕变亮".tr : ""}" : showContent;
    showCupertinoDialog(
      context: Get.context!,
      builder: (context) {
        return CupertinoAlertDialog(
          title: Text("提示".tr),
          content: Text(content),
          actions: [
            CupertinoDialogAction(
              child: Text(TranslationLoader.lanKeys!.sure!.tr),
              onPressed: () {
                Get.back();
              },
            ),
          ],
        );
      },
    );
  }

  @override
  void onReady() {
    // TODO: implement onReady
    super.onReady();

    _initReplySubscription();
  }

  @override
  void onInit() {
    // TODO: implement onInit
    super.onInit();
  }

  @override
  void onClose() {
    // TODO: implement onClose

    _replySubscription.cancel();
  }

}