using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Shared;
using Shared.Common;
using Shared.Common.ResponseEntity;
using Shared.Phone.UserCenter;

namespace ZigBee.Device
{
    public class DoorLock : Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo
    {
        public DoorLock()
        {
            this.Type = DeviceType.DoorLock;
        }

        #region 门锁本地变量
        /// <summary>
        /// 本地门锁用户和账户列表
        /// key:门锁用户ID
        /// </summary>
        /// <returns></returns>
        public Dictionary<int, LocaDoorLockObj> localDoorLockUserList = new Dictionary<int, LocaDoorLockObj>();
        /// <summary>
        /// 本地门账户列表
        /// key:账户ID（主账户是GUID，子账户是分享过来的账户ID）
        /// </summary>
        /// <returns></returns>
        public Dictionary<string, LocaDoorLockObj> localDoorLockAccountList = new Dictionary<string, LocaDoorLockObj>();

        public string currentUserDisplayMethod = string.Empty;//当前用户显示方式
        //本地所有账户列表
        public List<Shared.Phone.UserCenter.MemberInfoRes> localAllAccountList = new List<Shared.Phone.UserCenter.MemberInfoRes> { };

        /// <summary>
        /// 是否常开模式 
        /// ture:常开； false:关闭
        /// </summary>
        public bool IsDoorLockNormallyMode = false;
        [Newtonsoft.Json.JsonIgnore]
        public string LocalTempPassword = string.Empty;//本地生成的临时密码
        public Dictionary<string, bool> IsFreezeAccount = new Dictionary<string, bool> { };//是否冻结子账户
        public Dictionary<string, bool> HasRemoteUnlockAccess = new Dictionary<string, bool> { };//是否给子账户拥有远程开锁的条件
        public Dictionary<string, bool> IsFailedToGetDoorLockInfo = new Dictionary<string, bool> { };//是否获取门锁数据失败
        [Newtonsoft.Json.JsonIgnore]
        public string RemoteUnlockPassword = string.Empty;//远程开锁密码

        public static int RemoteUnlockCount = 5;//远程开锁次数限制
        public static int failedCount = 3;//远程开锁失败次数
        public static DateTime minValue = DateTime.MinValue;

        #region 临时密码信息
        /// <summary>
        /// 用户管理发送数据回复
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public TempPasswordObject tempPasswordObject;
        /// <summary>
        /// 临时密码本地对象
        /// </summary>
        [System.Serializable]
        public class TempPasswordObject
        {
            /// <summary>
            ///  临时密码ID
            /// </summary>
            public int UserId;
            /// <summary>
            /// PrimaryId 门锁云端主 键(非更新字段,以下均为更新字段) -->键名 : PrimaryId默认值: null
            /// </summary>
            //public string PrimaryId;
            /// <summary>
            ///  6位有动态临时密码
            /// </summary>
            public string TempPassword;
            /// <summary>
            /// 门锁有效时间
            /// </summary>
            public DateTime ValidTime;
            /// <summary>
            /// 门锁失效时间
            /// </summary>
            public DateTime InValidTime;
        }
        #endregion

        #endregion

        #region 与云端通讯接口
        #region 门锁服务器发送基本信息
        /// <summary>
        ///  添加门锁
        /// </summary>
        public class BaseDoorLockServerData
        {
            /// <summary>
            /// RequestVersion
            /// </summary>
            public string RequestVersion = Shared.Common.CommonPage.RequestVersion;
            /// <summary>
            /// LoginAccessToken
            /// </summary>
            public string LoginAccessToken = Shared.Common.Config.Instance.Token;
            /// <summary>
            /// 住宅Id -->键名 : HomeId
            /// </summary>
            public string HomeId = Shared.Common.Config.Instance.HomeId;
            /// <summary>
            /// 门锁Id -->键名 : DoorLockId
            /// </summary>
            public string DoorLockId = "";
            /// <summary>
            /// 门锁本地用户Id -->键名 : DoorLockLocalUserId
            /// </summary>
            public string DoorLockLocalUserId = "";

            /// <summary>
            /// IsOtherAccountCtrl 是否为子帐号控制过来 -->键名 : IsOtherAccountCtrl
            /// </summary>
            public bool IsOtherAccountCtrl = false;
        }
        #endregion

        #region 添加门锁
        /// <summary>
        ///  添加门锁
        /// </summary>
        public class AddDoorLockData : BaseDoorLockServerData
        {
            /// <summary>
            /// 云端帐号Id -->键名 : CloudAccountId
            /// </summary>
            public string CloudAccountId = "";
            /// <summary>
            /// OpenLockMode 开锁方式(密码、指纹、IC卡) -->键名 : OpenLockMode (可选)
            /// </summary>
            public int OpenLockMode = 0;
            /// <summary>
            /// Data 相关内容(如:密码、指纹、IC卡 的二进制) -->键名 : Data (可选)
            public byte[] Data = null;
            /// <summary>
            /// 用户Id备注 -->键名 : UserIdRemarks
            /// </summary>
            public string UserIdRemarks = "";
            /// <summary>
            /// IsFreezeUser 是否冻结用户 -->键名 : IsFreezeUser (可选)
            /// </summary>
            public bool IsFreezeUser = false;
            /// <summary>
            /// IsTempUnlockAuthority 是否临时开锁权限 -->键名 : IsTempUnlockAuthority(可选)
            /// </summary>
            public bool IsTempUnlockAuthority = false;
            /// <summary>
            /// EntryTime 录入时间 -->键名 : EntryTime(可选)
            /// </summary>
            public DateTime EntryTime = System.DateTime.Now;
        }

        /// <summary>
        /// 添加门锁结果
        /// </summary>
        public class AddDoorLockDataRes
        {
            /// <summary>
            /// 响应的版本号,一般请求什么版本号，这里与之请求相同
            /// </summary>
            public string ResponseVersion = string.Empty;
            /// <summary>
            /// 响应状态码:
            ///<para>(1)Success 则[调用此接口操作成功], ResponseData则为null</para>
            ///<para>(2)ParameterOrEmpty,则响应字段中[ErrorInfo] 为错误信息, ResponseData则为null</para>
            ///(<para>3)NoLogin,则响应字段中[ErrorInfo] 为错误信息为[无效登录Token!]</para>
            ///<para>(4)NoRecord,则响应字段中[ErrorInfo] 为错误信息为[当前提交DoorLockId值在云端不存在，请确认值是否正确!]</para>
            ///<para>(5)DoorLockIdNoIsYou,则响应字段中[ErrorInfo] 为错误信息为[当前提交DoorLockId并不属于你当前帐号的，请确认值是否正确!]</para>
            /// </summary>
            public string StateCode = string.Empty;
        }
        #endregion

        #region 更新门锁
        /// <summary>
        ///   更新门锁
        /// </summary>
        public class RefreshDoorLockData : BaseDoorLockServerData
        {
            /// <summary>
            /// PrimaryId 门锁云端主 键(非更新字段,以下均为更新字段) -->键名 : PrimaryId默认值: null
            /// </summary>
            public string PrimaryId = "";
            /// <summary>
            /// OpenLockMode 开锁方式(密码、指纹、IC卡) -->键名 : OpenLockMode (可选)
            /// </summary>
            public int OpenLockMode = 0;

            /// <summary>
            /// 住宅Id (可选)
            /// </summary>
            public byte[] Data;
            /// <summary>
            /// 用户Id备注
            /// </summary>
            public string UserIdRemarks = "";
            /// <summary>
            /// 是否为管理员门锁
            /// </summary>
            public bool IsFreezeUser;
            /// <summary>
            /// 是否为管理员门锁
            /// </summary>
            public bool IsTempUnlockAuthority;
        }
        #endregion

        #region 删除门锁
        /// <summary>
        /// 删除门锁
        /// </summary>
        public class DeleteDoorLockData : BaseDoorLockServerData
        {
            /// <summary>
            /// PrimaryId 门锁云端主 键(非更新字段,以下均为更新字段) -->键名 : PrimaryId默认值: null
            /// </summary>
            public string PrimaryId = "";
            /// <summary>
            /// 门锁Id -->键名 : DoorLockId (可选)
            /// DelDoorLockDelType 门锁删除类型(0: 根椐门锁主键(云端主键)删除(单条删除)、1:根椐门锁Id批量删除(凡是与门锁Id相同都会删除)、2：根椐门锁Id及门锁本地用户Id批量删除(这个门锁Id这个门锁本地用户Id均会被删除)) -->键名 : DelDoorLockDelType 默认值: 0
            /// </summary>
            public int DelDoorLockDelType;
        }
        #endregion

        #region 添加门锁临时密码
        /// <summary>
        ///  添加门锁
        /// </summary>
        public class AddDoorLockTempPasswordData
        {
            /// <summary>
            /// RequestVersion
            /// </summary>
            public string RequestVersion = Shared.Common.CommonPage.RequestVersion;
            /// <summary>
            /// LoginAccessToken
            /// </summary>
            public string LoginAccessToken = Shared.Common.Config.Instance.Token;
            /// <summary>
            /// 住宅Id -->键名 : HomeId
            /// </summary>
            public string HomeId = Shared.Common.Config.Instance.HomeId;
            /// <summary>
            /// 门锁Id -->键名 : DoorLockId
            /// </summary>
            public string LocalDoorLockId = "";
            /// <summary>
            /// 临时密码Id -->键名 : TempPwdId
            /// </summary>
            public string TempPwdId = "";
            /// <summary>
            /// 临时密码 -->键名 : TempPwd
            /// </summary>
            public string TempPwd = "";
            /// <summary>
            /// 0:00:00] ValidBeginTime 有效开始时间 -->键名 : ValidBeginTime  默认值: 0001/1/1
            /// </summary>
            public DateTime ValidBeginTime;
            /// <summary>
            /// 0:00:00] ValidEndTime 有效结束时间 -->键名 : ValidEndTime
            /// </summary>
            public DateTime ValidEndTime;
            /// <summary>
            /// IsOtherAccountCtrl 是否为子帐号控制过来 -->键名 : IsOtherAccountCtrl
            /// </summary>
            public bool IsOtherAccountCtrl = false;
        }

        /// <summary>
        /// 添加门锁结果
        /// </summary>
        public class AddDoorLockTempPasswordDataRes : AddDoorLockDataRes
        {
        }
        #endregion

        #region 删除门锁临时密码
        /// <summary>
        ///  删除门锁
        /// </summary>
        public class DelDoorLockTempPasswordData
        {
            /// <summary>
            /// RequestVersion
            /// </summary>
            public string RequestVersion = Shared.Common.CommonPage.RequestVersion;
            /// <summary>
            /// LoginAccessToken
            /// </summary>
            public string LoginAccessToken = Shared.Common.Config.Instance.Token;
            /// <summary>
            /// 住宅Id -->键名 : HomeId
            /// </summary>
            public string HomeId = Shared.Common.Config.Instance.HomeId;
            /// <summary>
            /// LocalDoorLockId 搜索本地门锁Id -->键名 : LocalDoorLockId  默认值: null
            /// </summary>
            public string LocalDoorLockId = "";
            /// <summary>
            /// IsOtherAccountCtrl 是否为子帐号控制过来 -->键名 : IsOtherAccountCtrl
            /// </summary>
            public bool IsOtherAccountCtrl = false;
        }

        /// <summary>
        /// 删除门锁结果
        /// </summary>
        public class DelDoorLockTempPasswordDataRes : AddDoorLockDataRes
        {
        }
        #endregion

        #region 更新门锁临时密码
        /// <summary>
        ///  更新门锁
        /// </summary>
        public class ModifyDoorLockTempPasswordData
        {
            /// <summary>
            /// RequestVersion
            /// </summary>
            public string RequestVersion = Shared.Common.CommonPage.RequestVersion;
            /// <summary>
            /// LoginAccessToken
            /// </summary>
            public string LoginAccessToken = Shared.Common.Config.Instance.Token;
            /// <summary>
            /// 住宅Id -->键名 : HomeId
            /// </summary>
            public string HomeId = Shared.Common.Config.Instance.HomeId;
            /// <summary>
            /// 门锁密码主键(获取门锁密码分页中的Id) -->键名 : DoorLockPwdId
            /// </summary>
            public string DoorLockPwdId = "";
            /// <summary>
            /// 门锁Id -->键名 : DoorLockId
            /// </summary>
            public string LocalDoorLockId = "";
            /// <summary>
            /// 临时密码Id -->键名 : TempPwdId
            /// </summary>
            public string TempPwdId = "";
            /// <summary>
            /// 临时密码 -->键名 : TempPwd
            /// </summary>
            public string TempPwd = "";
            /// <summary>
            /// 0:00:00] ValidBeginTime 有效开始时间 -->键名 : ValidBeginTime  默认值: 0001/1/1
            /// </summary>
            public DateTime ValidBeginTime;
            /// <summary>
            /// 0:00:00] ValidEndTime 有效结束时间 -->键名 : ValidEndTime
            /// </summary>
            public DateTime ValidEndTime;
            /// <summary>
            /// IsOtherAccountCtrl 是否为子帐号控制过来 -->键名 : IsOtherAccountCtrl
            /// </summary>
            public bool IsOtherAccountCtrl = false;
        }

        /// <summary>
        /// 添加门锁结果
        /// </summary>
        public class ModigDoorLockTempPasswordDataRes : AddDoorLockDataRes
        {
        }
        #endregion

        #region 获取门锁临时密码
        /// <summary>
        ///  获取门锁
        /// </summary>
        public class GetDoorLockTempPasswordData
        {
            /// <summary>
            /// RequestVersion
            /// </summary>
            public string RequestVersion = Shared.Common.CommonPage.RequestVersion;
            /// <summary>
            /// LoginAccessToken
            /// </summary>
            public string LoginAccessToken = Shared.Common.Config.Instance.Token;
            /// <summary>
            /// 住宅Id -->键名 : HomeId
            /// </summary>
            public string HomeId = Shared.Common.Config.Instance.HomeId;
            /// <summary>
            /// 门锁Id -->键名 : DoorLockId
            /// </summary>
            public string LocalDoorLockId = "";
            /// <summary>
            /// 临时密码Id -->键名 : TempPwdId
            /// </summary>
            public string TempPwdId = "";
            /// <summary>
            /// 临时密码 -->键名 : TempPwd
            /// </summary>
            public string TempPwd = "";
            /// <summary>
            /// 0:00:00] ValidBeginTime 有效开始时间 -->键名 : ValidBeginTime  默认值: 0001/1/1
            /// </summary>
            public DateTime? ValidBeginTime;
            /// <summary>
            /// 0:00:00] ValidEndTime 有效结束时间 -->键名 : ValidEndTime
            /// </summary>
            public DateTime? ValidEndTime;
            /// <summary>
            /// IsOtherAccountCtrl 是否为子帐号控制过来 -->键名 : IsOtherAccountCtrl
            /// </summary>
            public bool IsOtherAccountCtrl = false;
        }

        /// <summary>
        /// 获取门锁临时密码结果
        /// </summary>
        [Serializable]
        public class GetDoorLockTempPasswordDataRes
        {
            public List<CloudDoorLockTempPasswordObj> PageData = new List<CloudDoorLockTempPasswordObj>();
            public int PageIndex;
            public int PageSize;
            public int TotalCount;
            public int TotalPages;
            public bool HasPreviousPage;
            public bool HasNextPage;
        }
        [Serializable]
        public class CloudDoorLockTempPasswordObj
        {
            /// <summary>
            /// 门锁Id -->键名 : DoorLockId
            /// </summary>
            public string LocalDoorLockId = "";
            /// <summary>
            /// 临时密码Id -->键名 : TempPwdId
            /// </summary>
            public string TempPwdId = "";
            /// <summary>
            /// 临时密码 -->键名 : TempPwd
            /// </summary>
            public string TempPwd = "";
            /// <summary>
            /// 0:00:00] ValidBeginTime 有效开始时间 -->键名 : ValidBeginTime  默认值: 0001/1/1
            /// </summary>
            public DateTime ValidBeginTime;
            /// <summary>
            /// 0:00:00] ValidEndTime 有效结束时间 -->键名 : ValidEndTime
            /// </summary>
            public DateTime ValidEndTime;
            /// <summary>
            /// 【门锁云端主键】,用于【添加门锁历史】接口中的DoorLockId参数及【删除门锁】接口中的PrimaryId参数,注意不是网关中的【门锁Id
            /// </summary>
            public string Id;
            /// <summary>
            /// 创建时间
            /// </summary>
            public DateTime CreatedOnUtc;
        }

        /// <summary>
        /// 从云服务器中获取门锁临时密码
        /// </summary>
        public static async System.Threading.Tasks.Task<GetDoorLockTempPasswordDataRes> GetDoorLockTempPasswordFromServer(string RequestName, GetDoorLockTempPasswordData getDoorLockTempPasswordData)
        {
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<GetDoorLockTempPasswordDataRes>>)(async () =>
            {
                GetDoorLockTempPasswordDataRes listInfo = null;
                var revertObj = await SendDoorLockToServer(RequestName, getDoorLockTempPasswordData);
                if (revertObj != null && revertObj.ResponseData != null)
                {
                    var result = revertObj.ResponseData.ToString();
                    if (result != null)
                    {
                        listInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<GetDoorLockTempPasswordDataRes>(result);
                    }
                }
                return listInfo;
            }));
        }
        #endregion

        #region 获取门锁
        /// <summary>
        ///  获取门锁
        /// </summary>
        public class GetDoorLockData : BaseDoorLockServerData
        {
            /// <summary>
            /// 云端帐号Id -->键名 : CloudAccountId (可选)
            /// </summary>
            public string CloudAccountId = "";
            /// <summary>
            /// 第几页
            /// </summary>
            public PageSetting pageSetting = new PageSetting();
        }

        /// <summary>
        ///  获取门锁
        /// </summary>
        public class PageSetting
        {
            /// <summary>
            /// 第几页
            /// </summary>
            public int Page = 1;
            /// <summary>
            /// 第几页
            /// </summary>
            public int PageSize = 10;
        }

        [Serializable]
        public class GetDoorLockDataRes
        {
            public List<CloudDoorLockObj> PageData = new List<CloudDoorLockObj>();
            public int PageIndex;
            public int PageSize;
            public int TotalCount;
            public int TotalPages;
            public bool HasPreviousPage;
            public bool HasNextPage;
        }
        [Serializable]
        public class CloudDoorLockObj
        {
            /// <summary>
            /// 门锁Id
            /// </summary>
            public string DoorLockId;
            /// <summary>
            /// 云端帐号Id
            /// </summary>
            public string CloudAccountId;
            /// <summary>
            /// OpenLockMode 开锁方式(密码、指纹、IC卡)
            /// </summary>
            public int OpenLockMode;
            /// <summary>
            /// 门锁本地用户Id
            /// </summary>
            public string DoorLockLocalUserId;
            /// <summary>
            /// 住宅Id
            /// </summary>
            public byte[] Data;
            /// <summary>
            /// 用户Id备注
            /// </summary>
            public string UserIdRemarks;
            /// <summary>
            /// 是否为管理员门锁
            /// </summary>
            public bool IsAdminDoorLock;
            /// <summary>
            /// 是否为管理员门锁
            /// </summary>
            public bool IsFreezeUser;
            /// <summary>
            /// 是否为管理员门锁
            /// </summary>
            public bool IsTempUnlockAuthority;
            /// <summary>
            /// 录入时间
            /// </summary>
            public DateTime EntryTime;
            /// <summary>
            /// 最后更新时间
            /// </summary>
            public string LastChangeTime;
            /// <summary>
            /// 【门锁云端主键】,用于【添加门锁历史】接口中的DoorLockId参数及【删除门锁】接口中的PrimaryId参数,注意不是网关中的【门锁Id
            /// </summary>
            public string Id;
            /// <summary>
            /// 创建时间
            /// </summary>
            public DateTime CreatedOnUtc;
        }

        /// <summary>
        /// 获取门锁云服务器
        /// </summary>
        public static async System.Threading.Tasks.Task<GetDoorLockDataRes> GetDoorLockInfoFromServer(string RequestName, GetDoorLockData getDoorLockData)
        {
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<GetDoorLockDataRes>>)(async () =>
            {
                GetDoorLockDataRes listInfo = null;
                var revertObj = await SendDoorLockToServer(RequestName, getDoorLockData);
                if (revertObj != null && revertObj.ResponseData != null)
                {
                    var result = revertObj.ResponseData.ToString();
                    if (result != null)
                    {
                        listInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<GetDoorLockDataRes>(result);
                    }
                }
                return listInfo;
            }));
        }
        #endregion

        /// <summary>
        /// 发送门锁数据到服务器，只回复状态，没有数据处理
        /// </summary>
        /// <returns>获取从接口那里取到的ResponsePack</returns>
        /// <param name="RequestName">访问地址</param>
        /// <param name="obj">一个类</param>
        public static async Task<ResponsePack> SendDoorLockToServer(string RequestName, object obj)
        {
            try
            {
                //序列化对象
                var requestJson = JsonConvert.SerializeObject(obj);
                var byteData = System.Text.Encoding.UTF8.GetBytes(requestJson);
                byte[] result1 = null;
                //访问接口
                if (UserCenterResourse.UserInfo.AuthorityNo == 1)
                {
                    result1 = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync(RequestName, byteData);
                }
                else
                {
                    result1 = CommonPage.Instance.RequestZigbeeHttpsByAdmin(RequestName, byteData);
                }
                if (result1 != null)
                {
                    var result2 = Encoding.UTF8.GetString(result1);
                    if (result2 != null)
                    {
                        var result = Newtonsoft.Json.JsonConvert.DeserializeObject<Shared.Common.ResponseEntity.ResponsePack>(result2);
                        return result;
                    }
                }
                return null;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return null;
            }
        }

        /// <summary>
        /// 获取子账户信息
        /// </summary>
        static List<Shared.Phone.UserCenter.MemberInfoRes> DoorLockAccountList = new List<Shared.Phone.UserCenter.MemberInfoRes> { };
        public static async System.Threading.Tasks.Task<List<Shared.Phone.UserCenter.MemberInfoRes>> GetSubAccountByDistributedMark()
        {
            DoorLockAccountList.Clear();
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<List<Shared.Phone.UserCenter.MemberInfoRes>>>)(async () =>
           {
               var pra = new Shared.Phone.UserCenter.MemberListInfoPra();
               string result = UserCenterLogic.GetResponseDataByRequestHttps("ZigbeeUsers/GetSubAccountByDistributedMark", false, pra);
               if (result == null)
               {
                   return null;
               }
               var listInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<List<Shared.Phone.UserCenter.MemberInfoRes>>(result);
               return listInfo;
           }));
        }

        /// <summary>
        /// 服务器获取数据失败提示
        /// </summary>
        public void FailureToServer()
        {
            Application.RunOnMainThread(() =>
            {
                var alert = new Alert(Language.StringByID(Shared.R.MyInternationalizationString.TIP), Language.StringByID(Shared.R.MyInternationalizationString.RequestServerFailed), Language.StringByID(Shared.R.MyInternationalizationString.Confrim));
                alert.Show();
            });
        }
        #endregion

        #region  与网关通讯接口
        #region 门锁操作事件通知
        /// <summary>
        /// 门锁操作事件通知
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public DoorLockOperatingEventNotificationCommand doorLockOperatingEventNotificationCommand;
        /// <summary>
        /// 门锁操作事件通知
        /// </summary>
        [System.Serializable]
        public class DoorLockOperatingEventNotificationCommand
        {
            /// <summary>
            /// 用户id
            ///门锁本地录入的密码、指纹、感应卡都有唯一对应的用户Id
            /// </summary>
            public int UserID;
            /// <summary>
            /// 事件触发源
            /// 常用：
            /// 0:Keypad(键盘/密码)；3:RFID(射频卡)；15:指纹
            ///不常用：
            /// 1:RF(Zigbee无线)；2:Manual(手动)；255:Indeterminate(不确定)
            /// </summary>
            public int OperationEventSoure;
            /// <summary>
            /// 事件码
            /// 常用：
            /// 键盘/密码，指纹、感应卡：1:Lock命令成功事件；2:Unlock命令成功事件
            ///不常用：
            /// 请查看枚举
            /// </summary>
            public int OperationEventCode;
            /// <summary>
            /// 保留，默认0
            /// </summary>
            public int PIN;
            /// <summary>
            /// 门锁本地当前时间的时间戳
            /// </summary>
            public int ZigbeeLocalTime;
        }

        public class AccountsObj
        {
            /// <summary>
            /// 关联app账号
            /// </summary>
            public string Account;
            /// <summary>
            /// 保留
            /// </summary>
            public int Type;
            /// <summary>
            ///  保留
            /// </summary>
            public int Status;
        }

        /// <summary>
        /// “OperationEventSoure”列表
        /// </summary>
        public enum OperationEventSoure
        {
            /// <summary>
            /// 键盘/密码
            /// </summary>
            Keypad = 0,
            /// <summary>
            /// Zigbee无线
            /// </summary>
            RF = 1,
            /// <summary>
            /// 手动
            /// </summary>
            Manual = 2,
            /// <summary>
            /// 射频卡
            /// </summary>
            RFID = 3,
            /// <summary>
            /// 指纹
            /// </summary>
            Fingerprint = 15,
            /// <summary>
            /// Indeterminate(不确定)
            /// </summary>
            Indeterminate = 255,
        }

        /// <summary>
        /// “OperationEventSoure”类型为“Keypad”即密码 的“OperationEventCode”事件
        /// </summary>
        public enum KeypadEventDescription
        {
            /// <summary>
            /// 未知事件
            /// </summary>
            UnknownEvent = 0,
            /// <summary>
            /// Lock命令成功事件
            /// </summary>
            LockSuccessEvent = 1,
            /// <summary>
            /// Unlock命令成功事件
            /// </summary>
            UnlockSuccessEvent = 2,
            /// <summary>
            /// Lock命令：error,invalid PIN事件
            /// </summary>
            LockInvalidPinEvent = 3,
            /// <summary>
            /// Lock命令：error,invalid schedule事件
            /// </summary>
            LockInvalidScheduleEvent = 4,
            /// <summary>
            /// Unlock命令：error,invalid PIN事件
            /// </summary>
            UnlockInvalidPinEvent = 5,
            /// <summary>
            /// Unlock命令：error,invalid schedule事件Unlock命令：error,invalid schedule事件
            /// </summary>
            UnlockInvalidScheduleEvent = 6,
            /// <summary>
            /// 非访问用户操作事件
            /// </summary>
            NonAccess = 15,
        }

        /// <summary>
        /// “OperationEventSoure”类型为“RF” 的“OperationEventCode”事件
        /// </summary>
        public enum RfEventDescription
        {
            /// <summary>
            /// 未知事件
            /// </summary>
            UnknownEvent = 0,
            /// <summary>
            /// Lock命令成功事件
            /// </summary>
            LockSuccessEvent = 1,
            /// <summary>
            /// Unlock命令成功事件
            /// </summary>
            UnlockSuccessEvent = 2,
            /// <summary>
            /// Lock命令：error,invalid code事件
            /// </summary>
            LockInvalidPinEvent = 3,
            /// <summary>
            /// Lock命令：error,invalid schedule事件
            /// </summary>
            LockInvalidScheduleEvent = 4,
            /// <summary>
            /// Unlock命令：error,invalid code事件
            /// </summary>
            UnlockInvalidPinEvent = 5,
            /// <summary>
            /// Unlock命令：error,invalid schedule事件
            /// </summary>
            UnlockInvalidScheduleEvent = 6,
        }

        /// <summary>
        /// “OperationEventSoure”类型为“Manual” 的“OperationEventCode”事件
        /// </summary>
        public enum ManualEventDescription
        {
            /// <summary>
            /// 未知事件
            /// </summary>
            UnknownEvent = 0,
            /// <summary>
            /// Thumbturn Lock；手动转动上锁
            /// </summary>
            ThumbturnLockEvent = 1,
            /// <summary>
            /// Thumbturn Unlock；手动转动解锁
            /// </summary>
            UnlockSuccessEvent = 2,
            /// <summary>
            /// One touch Lock；一键上锁
            /// </summary>
            LockInvalidPinEvent = 7,
            /// <summary>
            ///Key Lock；按键上锁
            /// </summary>
            LockInvalidScheduleEvent = 8,
            /// <summary>
            /// Key Unlock；按键解锁
            /// </summary>
            UnlockInvalidPinEvent = 9,
            /// <summary>
            /// Auto lock；自动上锁
            /// </summary>
            UnlockInvalidScheduleEvent = 10,
            /// <summary>
            /// Schedule Lock；时间表上锁
            /// </summary>
            ScheduleLockEvent = 11,
            /// <summary>
            /// Schedule Unlock；时间表解锁
            /// </summary>
            ScheduleUnlockEvent = 12,
            /// <summary>
            /// Manual Lock(Key or Thumbturn)；手动上锁
            /// </summary>
            ManualLockEvent = 13,
            /// <summary>
            ///anual Unlock(Key or Thumbturn)；手动解锁
            /// </summary>
            ManualUnlockEvent = 14,
        }

        /// <summary>
        /// “OperationEventSoure”类型为“RFID” 的“OperationEventCode”事件
        /// </summary>
        public enum RfidEventDescription
        {
            /// <summary>
            /// 未知事件
            /// </summary>
            UnknownEvent = 0,
            /// <summary>
            /// Lock命令成功事件
            /// </summary>
            LockSuccessEvent = 1,
            /// <summary>
            /// Unlock命令成功事件
            /// </summary>
            UnlockSuccessEvent = 2,
            /// <summary>
            /// Lock命令：error,invalid RFID ID事件
            /// </summary>
            LockInvalidRfidIdEvent = 3,
            /// <summary>
            /// Lock命令：error,invalid schedule事件
            /// </summary>
            LockInvalidScheduleEvent = 4,
            /// <summary>
            /// Unlock命令：error,invalid RFID ID事件
            /// </summary>
            UnlockInvalidRfidIdEvent = 5,
            /// <summary>
            /// Unlock命令：error,invalid schedule事件
            /// </summary>
            UnlockInvalidScheduleEvent = 6,
        }
        #endregion

        #region 门锁编程事件通知
        /// <summary>
        /// 门锁编程事件通知
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public DoorLockProgrammingEventNotificationCommand doorLockProgrammingEventNotificationCommand;
        /// <summary>
        /// 门锁编程事件通知
        /// </summary>
        [System.Serializable]
        public class DoorLockProgrammingEventNotificationCommand
        {
            /// <summary>
            /// 用户id
            ///门锁本地录入的密码、指纹、感应卡都有唯一对应的用户Id
            /// </summary>
            public int UserID;
            /// <summary>
            /// 保留
            /// </summary>
            public int UserType;
            /// <summary>
            ///  保留
            /// </summary>
            public int UserStatus;
            /// <summary>
            /// 编程事件触发源
            /// 常用：
            /// 0:Keypad(键盘/密码)；3:RFID(射频卡)；15:指纹
            ///不常用：
            /// 1:RF(Zigbee无线)；2:Manual(手动)；255:Indeterminate(不确定)
            /// </summary>
            public int ProgramEventSoure;
            /// <summary>
            /// 编程事件码
            /// 常用：
            /// 键盘/密码，指纹、感应卡：1:Lock命令成功事件；2:Unlock命令成功事件
            ///不常用：
            /// 请查看枚举
            /// </summary>
            public int ProgramEventCode;
            /// <summary>
            /// 保留，默认0
            /// </summary>
            public int PIN;
            /// <summary>
            /// 门锁本地当前时间的时间戳
            /// </summary>
            public int ZigbeeLocalTime;
        }
        #endregion

        #region 矫正门锁时间
        /// <summary>
        /// 矫正门锁时间
        /// </summary>
        /// <param name="timestamp"></param>
        /// <returns></returns>
        public async System.Threading.Tasks.Task<SetWritableValueResponAllData> RectifyDoorLockTimeAsync(int timestamp)
        {
            if (Gateway == null)
            {
                return null;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                SetWritableValueResponAllData d = null;
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            d = new SetWritableValueResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }
                        else
                        {
                            d = new SetWritableValueResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "SetWritableValue_Respon")
                    {
                        var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<SetWritableValueResponData>(jobject["Data"].ToString());

                        if (tempData == null)
                        {
                            d = new SetWritableValueResponAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            d = new SetWritableValueResponAllData { setWritableValueResponData = tempData };
                            DebugPrintLog($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                Gateway.Actions += action;
                DebugPrintLog("SetWritableValue_Actions 启动" + "_" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", DeviceEpoint }, { "Cluster_ID", 10 }, { "Command", 120 } };
                    var data = new JObject { { "Undivided", 0 }, { "AttributeId", 0 }, { "AttributeDataType", 226 }, { "AttributeData", timestamp } };
                    jObject.Add("Data", data);
                    Gateway.Send("SetWritableValue", jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (d != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
                {
                    d = new SetWritableValueResponAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("SetWritableValue_Actions 退出" + System.DateTime.Now.ToString());

                return d;
            });
        }

        #endregion
        #endregion

        #region 与设备通讯接口（私有命令）

        #region 用户管理控制
        ///<summary >
        ///用户管理控制
        /// <para>passData:透传数据</para>
        /// </summary>
        public async System.Threading.Tasks.Task<DefaultControlResponseAllData> DefaultControlAsync(string passData)
        {
            DefaultControlResponseAllData result = null;
            if (Gateway == null)
            {
                result = new DefaultControlResponseAllData { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            result = new DefaultControlResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            result = new DefaultControlResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }
                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (clientDataPassthroughResponseData == null)
                        {
                            result = new DefaultControlResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            if (clientDataPassthroughResponseData?.PassData != null)
                            {
                                var data = clientDataPassthroughResponseData.PassData;
                                if (data.Length == 16)
                                {
                                    var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();
                                    if (command == "0002")
                                    {
                                        var tempD = new DefaultControlResponseData();
                                        tempD.command = data[12].ToString() + data[13].ToString() + data[10].ToString() + data[11].ToString();
                                        tempD.status = Convert.ToInt32(data[14].ToString() + data[15].ToString(), 16);
                                        if (tempD.command == "0450")
                                        {
                                            result = new DefaultControlResponseAllData { defaultControlResponseData = tempD };
                                            DebugPrintLog($"UI收到通知后的主题_command:0450_{ topic}");
                                        }
                                    }
                                }
                            }
                        }
                    }
                };

                Gateway.Actions += action;
                DebugPrintLog("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 9000)// WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (result != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > 9000)
                {
                    result = new DefaultControlResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }

        /// <summary>
        /// 用户管理发送数据
        /// userIdList:个数不能超过10个
        /// </summary>
        public string FreezeAccountData(List<int> userIdList, AccessType accessType)
        {
            string data = "";
            string dataLength = "";
            string dataComand1 = "50";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "";
            string delUserTypeStr = "";
            string userIdStr = "";
            try
            {
                if (userIdList.Count == 0)
                {
                    return null;
                }
                if (userIdList.Count > 9)
                {
                    return null;
                }
                var tempLength = 5 + userIdList.Count * 2;
                string tempLength1 = Convert.ToString(tempLength, 16);
                switch (tempLength1.Length)
                {
                    case 1:
                        dataLength = "0" + tempLength1.ToUpper();
                        break;
                    case 2:
                        dataLength = tempLength1.ToUpper();
                        break;
                }

                var tempAddDataLength = 1 + userIdList.Count * 2;
                string tempAddDataLength1 = Convert.ToString(tempAddDataLength, 16);
                switch (tempAddDataLength1.Length)
                {
                    case 1:
                        addDataLength = "0" + tempAddDataLength1.ToUpper();
                        break;
                    case 2:
                        addDataLength = tempAddDataLength1.ToUpper();
                        break;
                }

                switch ((int)accessType)
                {
                    case 0:
                        delUserTypeStr = "00";
                        break;
                    case 1:
                        delUserTypeStr = "01";
                        break;
                    case 2:
                        delUserTypeStr = "20";
                        break;
                    case 3:
                        delUserTypeStr = "21";
                        break;
                    case 4:
                        delUserTypeStr = "10";
                        break;
                    case 5:
                        delUserTypeStr = "30";
                        break;
                    case 6:
                        delUserTypeStr = "31";
                        break;
                }

                var sbString = new System.Text.StringBuilder();
                foreach (var userId in userIdList)
                {
                    string temp = Convert.ToString(userId, 16);
                    switch (temp.Length)
                    {
                        case 1:
                            userIdStr = "0" + temp + "00";
                            break;
                        case 2:
                            userIdStr = temp + "00";
                            break;
                        case 3:
                            var thirdBit = temp.Substring(temp.Length - 2, 1);
                            userIdStr = temp + "0" + thirdBit;
                            break;
                        case 4:
                            userIdStr = temp;
                            break;
                    }
                    sbString.Append(userIdStr.ToString().ToUpper());
                }
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
                   delUserTypeStr + sbString;
            }
            catch { };

            return data;
        }

        /// <summary>
        /// 用户管理发送数据
        /// </summary>
        public string SetUserAccessData(int userId, AccessType accessType)
        {
            string data = "";
            string dataLength = "07";
            string dataComand1 = "50";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "03";
            string delUserTypeStr = "";
            string userIdStr = "";
            try
            {
                switch ((int)accessType)
                {
                    case 0:
                        delUserTypeStr = "00";
                        break;
                    case 1:
                        delUserTypeStr = "01";
                        break;
                    case 2:
                        delUserTypeStr = "20";
                        break;
                    case 3:
                        delUserTypeStr = "21";
                        break;
                }
                var sbString = new System.Text.StringBuilder();
                string temp = Convert.ToString(userId, 16);

                switch (temp.Length)
                {
                    case 1:
                        userIdStr = "0" + temp + "00";
                        break;
                    case 2:
                        userIdStr = temp + "00";
                        break;
                    case 3:
                        var thirdBit = temp.Substring(temp.Length - 2, 1);
                        userIdStr = temp + "0" + thirdBit;
                        break;
                    case 4:
                        userIdStr = temp;
                        break;
                }
                sbString.Append(userIdStr.ToString().ToUpper());
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
                   delUserTypeStr + sbString;
            }
            catch { };

            return data;
        }

        /// <summary>
        /// 用户管理发送数据回复
        /// </summary>
        [System.Serializable]
        public class DefaultControlResponseAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 用户管理数据回复
            /// </summary>
            public DefaultControlResponseData defaultControlResponseData;
        }

        /// <summary>
        /// 用户管理数据回复
        /// </summary>
        [System.Serializable]
        public class DefaultControlResponseData
        {
            /// <summary>
            ///响应操作码（0-ffff）
            /// </summary>
            public string command = "";
            /// <summary>
            /// 状态值
            /// <para>默认响应结果：
            ///<para>0 成功</para>
            ///<para>1 失败</para>
            ///<para>2 用户不存在</para>
            ///<para>32 冻结成功</para>
            ///<para>34 冻结失败</para>
            ///<para>33 解冻成功</para>
            ///<para>35 解冻失败</para>
            /// </summary>
            public int status = -1;
        }

        public enum AccessType
        {
            /// <summary>
            /// 0x00 删除全部临时用户
            /// </summary>
            DelAllUsers = 0,
            /// <summary>
            /// 0x01 删除指定用户(按编号)
            /// </summary>
            DelCurrentUser = 1,
            /// <summary>
            /// 0x20 冻结指定用户
            /// </summary>
            DisEnable = 2,
            /// <summary>
            /// 0x21 解冻指定用户
            /// </summary>
            Enable = 3,
            /// <summary>
            /// 0x10 多个指定用户删除
            /// </summary>
            DelMoreUsers = 4,
            /// <summary>
            /// 0x30 多个指定用户冻结
            /// </summary>
            DisEnableMoreUsers = 5,
            /// <summary>
            /// 0x31 多个指定用户解冻
            /// </summary>
            EnableMoreUsers = 6,
        }
        #endregion

        #region 验证门锁密码
        ///<summary >
        ///验证门锁密码
        ///<para>inputPassword:输入的门锁密码</para>
        /// </summary>
        public async System.Threading.Tasks.Task<VerifyPasswordResponseAllData> VerifyPasswordAsync(string inputPassword)
        {
            VerifyPasswordResponseAllData result = null;
            if (Gateway == null)
            {
                result = new VerifyPasswordResponseAllData { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            result = new VerifyPasswordResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            result = new VerifyPasswordResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }
                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (clientDataPassthroughResponseData == null)
                        {
                            result = new VerifyPasswordResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            if (clientDataPassthroughResponseData?.PassData != null)
                            {
                                var data = clientDataPassthroughResponseData.PassData;
                                if (data.Length == 12)
                                {
                                    var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();
                                    if (command == "0454")
                                    {
                                        var result1 = Convert.ToInt32(data[10].ToString() + data[11].ToString(), 16);
                                        result = new VerifyPasswordResponseAllData { result = result1 };
                                        DebugPrintLog($"UI收到通知后的主题_command:0454_{ topic}");
                                    }
                                }
                            }
                        }
                    }
                };

                Gateway.Actions += action;
                DebugPrintLog("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var getPw = await GetkeyPassword();
                    var passData = VerifyPasswordData(inputPassword, getPw);
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 9000)// WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (result != null && result.result == 0)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
                {
                    result = new VerifyPasswordResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }
        /// <summary>
        /// 验证门锁密码
        /// </summary>
        public string VerifyPasswordData(string keyPassword, int password, int fixedPassword = 0x190605)
        {
            string data = "";
            string dataLength = "08";
            string dataComand1 = "53";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "04";
            string passwordStr = "";
            try
            {
                int keyPasswordInt = System.Convert.ToInt32(keyPassword, 16);
                var pawStr = System.Convert.ToString((keyPasswordInt ^ password) + fixedPassword, 16);
                pawStr = pawStr.PadLeft(8, '0');
                for (int i = 6; i >= 0; i = i - 2)
                {
                    passwordStr += pawStr.Substring(i, 2);
                }
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
                 passwordStr;
            }
            catch { };
            return data;
        }

        /// <summary>
        /// 用户管理发送数据回复
        /// </summary>
        [System.Serializable]
        public class VerifyPasswordResponseAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 用户管理数据回复
            /// <para>0:成功</para>
            ///<para>1:失败</para>
            /// </summary>
            public int result = -1;
        }
        #endregion

        #region 远程开锁
        ///<summary >
        ///远程开锁
        ///<para>inputPassword: 输入密码/para>
        /// </summary>
        public async System.Threading.Tasks.Task<RemoteResponseAllData> RemoteControlAsync(string inputPassword)
        {
            RemoteResponseAllData result = null;
            if (Gateway == null)
            {
                result = new RemoteResponseAllData { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            result = new RemoteResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            result = new RemoteResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }
                    else if (topic == $"{gatewayID}/DoorLock/DoorLockOperatingEventNotificationCommand")
                    {
                        var OperatingEventNotificationDatad = Newtonsoft.Json.JsonConvert.DeserializeObject<ZigBee.Device.DoorLock.DoorLockOperatingEventNotificationCommand>(jobject["Data"].ToString());
                        if (OperatingEventNotificationDatad != null)
                        {
                            if (OperatingEventNotificationDatad.OperationEventSoure == 1 && OperatingEventNotificationDatad.OperationEventCode == 5)
                            {
                                result = new RemoteResponseAllData { IsPawDispear = true };
                            }
                        }
                    }
                    else if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (clientDataPassthroughResponseData == null)
                        {
                            result = new RemoteResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            if (clientDataPassthroughResponseData?.PassData != null)
                            {
                                var data = clientDataPassthroughResponseData.PassData;
                                if (data.Length == 16)
                                {
                                    var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();
                                    if (command == "0002")
                                    {
                                        var tempD = new RemoteResponseData();
                                        tempD.command = data[12].ToString() + data[13].ToString() + data[10].ToString() + data[11].ToString();
                                        tempD.status = Convert.ToInt32(data[14].ToString() + data[15].ToString(), 16);
                                        if (tempD.command == "0462")
                                        {
                                            result = new RemoteResponseAllData { responseData = tempD };
                                            DebugPrintLog($"UI收到通知后的主题_command:0462_{ topic}");
                                        }
                                    }
                                }
                            }
                        }
                    }
                };
                Gateway.Actions += action;
                DebugPrintLog("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var getPw = await GetkeyPassword();
                    var passData = RemoteData(inputPassword, getPw);
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 5000)// WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (result == null)
                    {
                        continue;
                    }
                    if (result.responseData != null && result.responseData.command == "0462")
                    {
                        break;
                    }
                    if (result.IsPawDispear == true)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
                {
                    result = new RemoteResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }
        /// <summary>
        /// 远程发送数据
        /// </summary>
        string RemoteData(string keyPassword, int password, int fixedPassword = 0x190605)
        {
            string data = "";
            string dataLength = "08";
            string dataComand1 = "62";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "04";
            string passwordStr = "";
            try
            {
                int keyPasswordInt = System.Convert.ToInt32(keyPassword, 16);
                var pawStr = System.Convert.ToString((keyPasswordInt ^ password) + fixedPassword, 16);
                pawStr = pawStr.PadLeft(8, '0');
                for (int i = 6; i >= 0; i = i - 2)
                {
                    passwordStr += pawStr.Substring(i, 2);
                }
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
                 passwordStr;
            }
            catch { };

            return data;
        }

        /// <summary>
        ///  远程回复数据
        /// </summary>
        [System.Serializable]
        public class RemoteResponseAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary> 
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 临时密码回复数据
            /// </summary>
            public RemoteResponseData responseData;
            /// <summary>
            /// 是否密码被删除
            /// </summary>
            public bool IsPawDispear = false;
        }

        /// <summary>
        /// 用户管理数据回复
        /// </summary>
        [System.Serializable]
        public class RemoteResponseData
        {
            /// <summary>
            ///响应操作码（0-ffff）
            /// </summary>
            public string command = "";
            /// <summary>
            /// 状态值
            /// <para>默认响应结果：
            ///<para>0 成功</para>
            ///<para>1 失败</para> 
            /// </summary>
            public int status = -1;
        }
        #endregion

        #region 临时密码发送数据
        ///<summary >
        ///临时密码
        ///<para>inputPassword: 输入密码/para>
        /// </summary>
        public async System.Threading.Tasks.Task<TempPasswordResponseAllData> TempPasswordAsync(string inputPassword, System.DateTime startTime, System.DateTime endTime, string fixedPassword = "190605")
        {
            TempPasswordResponseAllData result = null;
            if (Gateway == null)
            {
                result = new TempPasswordResponseAllData { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            result = new TempPasswordResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            result = new TempPasswordResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }
                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (clientDataPassthroughResponseData == null)
                        {
                            result = new TempPasswordResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            if (clientDataPassthroughResponseData?.PassData != null)
                            {
                                var data = clientDataPassthroughResponseData.PassData;
                                if (data.Length == 16)
                                {
                                    var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();
                                    if (command == "0002")
                                    {
                                        var tempD = new TempPasswordResponseData();
                                        tempD.command = data[12].ToString() + data[13].ToString() + data[10].ToString() + data[11].ToString();
                                        tempD.status = Convert.ToInt32(data[14].ToString() + data[15].ToString(), 16);
                                        if (tempD.command == "0463")
                                        {
                                            result = new TempPasswordResponseAllData { responseData = tempD };
                                            DebugPrintLog($"UI收到通知后的主题_command:0463_{ topic}");
                                        }
                                    }
                                }
                            }
                        }
                    }
                };

                Gateway.Actions += action;
                DebugPrintLog("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var getPw = await GetkeyPassword();
                    var passData = TempPasswordData(inputPassword, getPw, startTime, endTime);
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 9000)// WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (result != null && result.responseData != null && result.responseData.command == "0463")
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > 9000)
                {
                    result = new TempPasswordResponseAllData
                    { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }
        /// <summary>
        /// 临时密码发送数据
        /// </summary>
        public string TempPasswordData(string keyPassword, int password, System.DateTime startTime, System.DateTime endTime)
        {
            string data = "";
            string dataLength = "10";
            string dataComand1 = "63";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "0c";
            string passwordStr = "";
            string vaildTimeStr = "";
            string invalidTimeStr = "";
            try
            {
                int keyPasswordInt = System.Convert.ToInt32(keyPassword, 16);
                var pawStr = System.Convert.ToString((keyPasswordInt ^ password) + 0x190605, 16);
                pawStr = pawStr.PadLeft(8, '0');
                for (int i = 6; i >= 0; i = i - 2)
                {
                    passwordStr += pawStr.Substring(i, 2);
                }

                var startTimeStr = Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetUnixTimeStamp(startTime);
                var endTimeStr = Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetUnixTimeStamp(endTime);
                startTimeStr = string.Format("{0:X}", System.Convert.ToInt64(startTimeStr));
                endTimeStr = string.Format("{0:X}", System.Convert.ToInt64(endTimeStr));
                for (int i = 6; i >= 0; i = i - 2)
                {
                    vaildTimeStr += startTimeStr.Substring(i, 2);
                    invalidTimeStr += endTimeStr.Substring(i, 2);
                }

                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
                   passwordStr + vaildTimeStr + invalidTimeStr;
            }
            catch (Exception ex)
            {
                var mess = ex.Message;
            };
            return data;
        }

        /// <summary>
        /// 临时密码回复数据
        /// </summary>
        [System.Serializable]
        public class TempPasswordResponseAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary> 
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 临时密码回复数据
            /// </summary>
            public TempPasswordResponseData responseData;
        }

        /// <summary>
        /// 临时密码回复数据
        /// </summary>
        [System.Serializable]
        public class TempPasswordResponseData
        {
            /// <summary>
            ///响应操作码（0-ffff）
            /// </summary>
            public string command = "";
            /// <summary>
            /// 状态值
            /// <para>0--注册成功</para>
            /// <para>1--注册失败</para>
            /// <para>2--用户已存在(重复密码)</para>
            /// <para>3-- 用户已满(+已满类型回复)</para>
            /// <para>4--有效时间重叠</para>
            /// </summary>
            public int status = -1;
        }
        #endregion

        #region 获取门锁密钥
        /// <summary>
        /// 门锁随机密码
        /// <para>获取加密的随机密钥，返回的密钥经过一个简单的加法加密加上0x190605，因此获取的密钥需要减上0x190605</para>
        /// </summary>
        /// <returns></returns>
        async System.Threading.Tasks.Task<int> GetkeyPassword()
        {
            string passwordStr = "";
            var result = await GetKeyPassworAsync();
            //返回小端
            if (result == null || result.keyPassword == null)
            {
                return 0;
            }

            for (int i = 6; i >= 0; i = i - 2)
            {
                passwordStr += result.keyPassword.Substring(i, 2);
            }
            var keyPasswordInt = System.Convert.ToInt32(passwordStr, 16);
            return keyPasswordInt - 0x190605;
        }

        ///<summary >
        ///获取门锁密钥
        /// </summary>
        async System.Threading.Tasks.Task<KeyPasswordInfo> GetKeyPassworAsync(int keyType = 0)
        {
            KeyPasswordInfo result = null;
            if (Gateway == null)
            {
                result = new KeyPasswordInfo { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            result = new KeyPasswordInfo { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            result = new KeyPasswordInfo { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (clientDataPassthroughResponseData == null)
                        {
                            result = new KeyPasswordInfo { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            if (clientDataPassthroughResponseData?.PassData != null)
                            {
                                var data = clientDataPassthroughResponseData.PassData;
                                if (data.Length == 20)
                                {
                                    var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();

                                    if (command == "0461")
                                    {
                                        var kType = Convert.ToInt32(data[10].ToString() + data[11].ToString(), 16);
                                        var keyPassword = data[12].ToString() + data[13].ToString() + data[14].ToString() + data[15].ToString() + data[16].ToString() + data[17].ToString() + data[18].ToString() + data[19].ToString();
                                        result = new KeyPasswordInfo { keyType = kType, keyPassword = keyPassword };
                                        DebugPrintLog($"UI收到通知后的主题_command:0460_{ topic}");
                                    }
                                }
                            }
                        }
                    }
                };

                Gateway.Actions += action;
                DebugPrintLog("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var passData = KeyPasswordData(keyType);
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 9000)//WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (result != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
                {
                    result = new KeyPasswordInfo { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }

        /// <summary>
        /// 获取门锁密钥
        /// </summary>
        string KeyPasswordData(int keyType)
        {
            string data = "";
            string dataLength = "05";
            string dataComand1 = "60";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "01";
            string keyTypeData = "";

            try
            {
                var tempTypeString = new System.Text.StringBuilder();
                var temp = Convert.ToString(keyType, 16);
                switch (temp.Length)
                {
                    case 1:
                        keyTypeData = "0" + temp;
                        break;
                    case 2:
                        keyTypeData = temp;
                        break;
                }
                tempTypeString.Append(keyTypeData.ToString().ToUpper());
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
            tempTypeString;
            }
            catch { };

            return data;
        }

        /// <summary>
        /// 获取门锁密钥回复
        /// </summary>
        [System.Serializable]
        public class KeyPasswordInfo
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            ///密钥类型
            ///<apra></apra>
            /// </summary>
            public int keyType = -1;

            /// <summary>
            /// 密钥
            /// </summary>
            public string keyPassword;
        }
        #endregion

        #region 读取锁上信息
        ///<summary >
        ///读取锁上信息
        /// </summary>
        public async System.Threading.Tasks.Task<DoorlockUserInfo> GetDoorlockUserInfoAsync()
        {
            DoorlockUserInfo result = null;
            int totalNum = 0;
            int currentNum = -1;
            DoorLockUserDetailData doorLockUserDetailData = new DoorLockUserDetailData { };
            if (Gateway == null)
            {
                result = new DoorlockUserInfo { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                var dateTime = DateTime.Now;
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (clientDataPassthroughResponseData != null)
                        {
                            if (clientDataPassthroughResponseData.PassData != null)
                            {
                                var data = clientDataPassthroughResponseData.PassData;
                                var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();
                                if (command == "0452")
                                {
                                    dateTime = DateTime.Now;
                                    int returnAllLength = 2 + 2 * Convert.ToInt32(data[0].ToString() + data[1].ToString(), 16);
                                    int usefulLength = (returnAllLength - 16);
                                    int tempCount = 0;
                                    var listData = new List<string>();
                                    while (tempCount < usefulLength)
                                    {
                                        listData.Add(data[16 + tempCount].ToString());
                                        tempCount++;
                                    }
                                    for (int j = 0; j < listData.Count / 4; j++)
                                    {
                                        int curIndex = 4 * j;
                                        var userInfo = new UserObj();
                                        userInfo.UserType = Convert.ToInt32(listData[curIndex + 2].ToString(), 16);
                                        userInfo.UserId = Convert.ToInt32(listData[curIndex + 3].ToString() + listData[curIndex].ToString() + listData[curIndex + 1].ToString(), 16);
                                        doorLockUserDetailData.UserObjList.Add(userInfo);
                                    }
                                    doorLockUserDetailData.userType = Convert.ToInt32(data[10].ToString() + data[11].ToString(), 16);
                                    doorLockUserDetailData.totalNum = Convert.ToInt32(data[12].ToString() + data[13].ToString(), 16);
                                    doorLockUserDetailData.currentNum = Convert.ToInt32(data[14].ToString() + data[15].ToString(), 16);
                                    totalNum = doorLockUserDetailData.totalNum;
                                    currentNum = doorLockUserDetailData.currentNum;
                                    result = new DoorlockUserInfo { doorLockUserDetailData = doorLockUserDetailData };
                                    DebugPrintLog($"UI收到通知后的主题_command:0451_{ topic}");
                                }
                            }
                        }
                    }
                };

                Gateway.Actions += action;
                DebugPrintLog("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var passData = DoorlockUserData();
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                //接收一个包最多等3秒，没有收到就退出,单次数据包不超过30个用户
                while ((DateTime.Now - dateTime).TotalMilliseconds < 3000)
                {
                    await System.Threading.Tasks.Task.Delay(100);
                    if (totalNum == currentNum)
                    {
                        break;
                    }
                }
                //if ((DateTime.Now - dateTime).TotalMilliseconds > 3000)
                //{
                //    result = new DoorlockUserInfo { errorMessageBase = " 回复超时，请重新操作" };
                //}
                Gateway.Actions -= action;
                DebugPrintLog("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }

        /// <summary>
        /// 读取锁上信息
        /// </summary>
        string DoorlockUserData()
        {
            string data = "";
            string dataLength = "05";
            string dataComand1 = "51";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "01";
            string keyTypeData = "01";

            try
            {
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength + keyTypeData;
            }
            catch { };

            return data;
        }

        /// <summary>
        /// 读取锁上信息回复
        /// </summary>
        [System.Serializable]
        public class DoorlockUserInfo
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 门锁设备返回信息
            /// </summary>
            public DoorLockUserDetailData doorLockUserDetailData;
        }

        /// <summary>
        /// 门锁设备返回信息
        /// </summary>
        public class DoorLockUserDetailData
        {
            /// <summary>
            /// 类型(读取锁上已有用户)
            /// </summary>
            public int userType;
            /// <summary>
            /// 数据包总数
            /// </summary>
            public int totalNum;
            /// <summary>
            /// 数据包序号
            /// </summary>
            public int currentNum;

            /// <summary>
            /// 虚拟驱动信息
            /// </summary>
            public List<UserObj> UserObjList = new List<UserObj>();
        }

        public class UserObj
        {
            /// <summary>
            /// 门锁用户类型
            /// </summary>
            public int UserType;

            /// <summary>
            /// 门锁用户Id号
            /// </summary>
            public int UserId;
        }
        #endregion

        #region 音量
        ///<summary >
        ///获取音量
        /// </summary>
        public async System.Threading.Tasks.Task<VolumeResponseAllData> GetVolumeAsync()
        {
            VolumeResponseAllData result = null;
            if (Gateway == null)
            {
                result = new VolumeResponseAllData { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            result = new VolumeResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            result = new VolumeResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }
                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (clientDataPassthroughResponseData == null)
                        {
                            result = new VolumeResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            if (clientDataPassthroughResponseData?.PassData != null)
                            {
                                var data = clientDataPassthroughResponseData.PassData;
                                if (data.Length == 14)
                                {
                                    var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();
                                    if (command == "0456")
                                    {
                                        var tempD = new VolumeResponseData();
                                        tempD.command = data[10].ToString() + data[11].ToString();
                                        tempD.value = Convert.ToInt32(data[12].ToString() + data[13].ToString(), 16);
                                        result = new VolumeResponseAllData { volumeResponseData = tempD };
                                        DebugPrintLog($"UI收到通知后的主题_command:0456_{ topic}");
                                    }
                                }
                            }
                        }
                    }
                };

                Gateway.Actions += action;
                DebugPrintLog("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var passData = VolumeData(-1);
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 9000)// WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (result != null && result.volumeResponseData != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > 9000)
                {
                    result = new VolumeResponseAllData
                    { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }

        ///<summary >
        ///音量
        ///<para>命令值: comandValue</para>
        ///<para>comandValue: 0-0x64 音量</para> 
        /// </summary>
        public async System.Threading.Tasks.Task<DefaultControlResponseAllData> SetVolumeAsync(int comandValue)
        {
            DefaultControlResponseAllData result = null;
            if (Gateway == null)
            {
                result = new DefaultControlResponseAllData { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            result = new DefaultControlResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            result = new DefaultControlResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }
                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (clientDataPassthroughResponseData == null)
                        {
                            result = new DefaultControlResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            if (clientDataPassthroughResponseData?.PassData != null)
                            {
                                var data = clientDataPassthroughResponseData.PassData;
                                if (data.Length == 16)
                                {
                                    var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();
                                    if (command == "0002")
                                    {
                                        var tempD = new DefaultControlResponseData();
                                        tempD.command = data[12].ToString() + data[13].ToString() + data[10].ToString() + data[11].ToString();
                                        tempD.status = Convert.ToInt32(data[14].ToString() + data[15].ToString(), 16);
                                        if (tempD.command == "0455")
                                        {
                                            result = new DefaultControlResponseAllData { defaultControlResponseData = tempD };
                                            DebugPrintLog($"UI收到通知后的主题_command:0455_{ topic}");
                                        }
                                    }
                                }
                            }
                        }
                    }
                };

                Gateway.Actions += action;
                DebugPrintLog("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var passData = VolumeData(comandValue);
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 9000)// WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (result != null && result.defaultControlResponseData != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > 9000)
                {
                    result = new DefaultControlResponseAllData
                    { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }

        /// <summary>
        /// 音量发送数据
        ///<para>comandValue: 0-100 音量</para> 
        /// </summary>
        public string VolumeData(int comandValue)
        {
            string data = "";
            string dataLength = "05";
            string dataComand1 = "55";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "01";
            string cValue = "";
            try
            {
                if (comandValue >= 1)
                {
                    cValue = Convert.ToString(comandValue, 16).ToUpper();
                    if (cValue.Length == 1)
                    {
                        cValue = "0" + cValue;
                    }
                    else
                    {
                        cValue = cValue;
                    }

                }
                else
                {
                    switch (comandValue)
                    {
                        case -1:
                            cValue = "AA";
                            break;
                        case 0:
                            cValue = "EB";
                            break;
                    }
                }
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
                   cValue;
            }
            catch (Exception ex)
            {
                var mess = ex.Message;
            };
            return data;
        }

        /// <summary>
        /// 音量回复数据
        /// </summary>
        [System.Serializable]
        public class VolumeResponseAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary> 
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 音量回复数据
            /// </summary>
            public VolumeResponseData volumeResponseData;
        }

        /// <summary>
        /// 音量回复数据
        /// </summary>
        [System.Serializable]
        public class VolumeResponseData
        {
            /// <summary>
            ///命令
            ///<para>0x00 接收成功</para>
            ///<para>0xea 语音模式</para>
            ///<para>0xeb 静音模式</para>
            /// </summary>
            public string command = "";
            /// <summary>
            /// 音量值
            /// <para>0xf1~0xfe  1-14音量</para>
            /// <para>0 无音量值</para>
            /// </summary>
            public int value = -1;
        }
        #endregion

        #region 常开模式         
        /// <summary>
        /// 读取常开模式
        /// </summary>
        /// <returns></returns>
        public async System.Threading.Tasks.Task<OpenModeResponseAllData> ReadNormallyOpenModeFuncAsync()
        {
            OpenModeResponseAllData result = null;
            if (Gateway == null)
            {
                result = new OpenModeResponseAllData { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            result = new OpenModeResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            result = new OpenModeResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }
                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (clientDataPassthroughResponseData == null)
                        {
                            result = new OpenModeResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            if (clientDataPassthroughResponseData?.PassData != null)
                            {
                                var data = clientDataPassthroughResponseData.PassData;
                                if (data.Length == 12)
                                {
                                    var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();
                                    if (command == "0458")
                                    {
                                        result = new OpenModeResponseAllData();
                                        result.command = data[10].ToString() + data[11].ToString();
                                        DebugPrintLog($"UI收到通知后的主题_command:0457_{ topic}");
                                    }
                                }
                            }
                        }
                    }
                };

                Gateway.Actions += action;
                DebugPrintLog("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var passData = OpenModeData(SwitchMode.Obtain);
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 9000)// WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (result != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > 9000)
                {
                    result = new OpenModeResponseAllData
                    { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }

        /// <summary>
        /// 设置常开模式
        /// </summary>
        /// <param name="IsNormallyOpenMode">是否打开常开模式：true：打开 false：关闭</param>
        /// <returns></returns>
        public async System.Threading.Tasks.Task<DefaultControlResponseAllData> SetNormallyOpenModeFuncAsync(bool IsNormallyOpenMode)
        {
            DefaultControlResponseAllData result = null;
            if (Gateway == null)
            {
                result = new DefaultControlResponseAllData { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            result = new DefaultControlResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            result = new DefaultControlResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }
                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (clientDataPassthroughResponseData == null)
                        {
                            result = new DefaultControlResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            if (clientDataPassthroughResponseData?.PassData != null)
                            {
                                var data = clientDataPassthroughResponseData.PassData;
                                if (data.Length == 16)
                                {
                                    var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();
                                    if (command == "0002")
                                    {
                                        var tempD = new DefaultControlResponseData();
                                        tempD.command = data[12].ToString() + data[13].ToString() + data[10].ToString() + data[11].ToString();
                                        tempD.status = Convert.ToInt32(data[14].ToString() + data[15].ToString(), 16);
                                        if (tempD.command == "0457")
                                        {
                                            result = new DefaultControlResponseAllData { defaultControlResponseData = tempD };
                                            DebugPrintLog($"UI收到通知后的主题_command:0457_{ topic}");
                                        }
                                    }
                                }
                            }
                        }
                    }
                };

                Gateway.Actions += action;
                DebugPrintLog("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var passData = "";
                    if (IsNormallyOpenMode)
                    {
                        passData = OpenModeData(SwitchMode.NormallyOpen);
                    }
                    else
                    {
                        passData = OpenModeData(SwitchMode.NormallyClose);
                    }
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 9000)// WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (result != null && result.defaultControlResponseData != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > 9000)
                {
                    result = new DefaultControlResponseAllData
                    { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }

        /// <summary>
        /// 常开模式 发送数据
        /// </summary>
        public string OpenModeData(SwitchMode switchMode)
        {
            string data = "";
            string dataLength = "05";
            string dataComand1 = "57";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "01";
            string cValue = "";
            try
            {
                switch (switchMode)
                {
                    case SwitchMode.Obtain:
                        cValue = "10";
                        break;
                    case SwitchMode.NormallyOpen:
                        cValue = "12";
                        break;
                    case SwitchMode.NormallyClose:
                        cValue = "13";
                        break;
                }
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
                   cValue;
            }
            catch (Exception ex)
            {
                var mess = ex.Message;
            };
            return data;
        }

        /// <summary>
        /// 常开模式 回复数据
        /// </summary>
        [System.Serializable]
        public class OpenModeResponseAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary> 
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary> 
            /// 0x10 常开已开启 
            /// <para>0x11 常开已关闭</para>
            /// </summary>
            public string command;
        }


        /// <summary>
        /// 开关模式
        /// </summary>
        public enum SwitchMode
        {
            /// <summary>
            /// 0x10 查询常开状态
            /// </summary>
            Obtain = 0x10,
            /// <summary>
            /// 0x12 开启常开
            /// </summary>
            NormallyOpen = 0x12,
            /// <summary>
            /// 0x13 关闭常开
            /// </summary>
            NormallyClose = 0x13
        }
        #endregion

        #endregion
    }
}