using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Shared.Common;
using ZigBee.Device;

namespace Shared.Phone.UserCenter.DoorLock
{
    public class DoorLockCommonInfo : CommonDevice
    {
        #region  本地变量
        /// <summary>
        /// 网关（门锁）所在的时间
        /// </summary>
        public static DateTime DoorlockZoneTime = DateTime.Now;
        /// <summary>
        /// 常开模式执行时间
        /// </summary>
        public static int NormallyOpenModeInvalidTime = 12;
        /// <summary>
        /// 是否支持修改
        /// </summary>
        public static bool IsModify = false;
        /// <summary>
        /// 是否显示临时密码
        /// </summary>
        public static bool InTempPasswordVisiable = false;
        /// <summary>
        /// 有效日期“年”
        /// </summary>
        public static int ValidDateYear = 0;
        /// <summary>
        /// 有效日期“月”
        /// </summary>
        public static int ValidDateMonth = 0;
        /// <summary>
        /// 有效日期“日”
        /// </summary>
        public static int ValidDateDay = 0;
        /// <summary>
        /// 有效日期“时”
        /// </summary>
        public static int ValidDateHour = 100;
        /// <summary>
        /// 有效日期“分”
        /// </summary>
        public static int ValidDateMinute = 100;
        /// <summary>
        /// 有效日期“秒”
        /// </summary>
        public static int ValidDateSecond = 0;
        /// <summary>
        /// 失效效日期“年”
        /// </summary>
        public static int InValidDateYear = 0;
        /// <summary>
        /// 失效效日期“月”
        /// </summary>
        public static int InValidDateMonth = 0;
        /// <summary>
        /// 失效效日期“日”
        /// </summary>
        public static int InValidDateDay = 0;
        /// <summary>
        /// 失效效日期“时”
        /// </summary>
        public static int InValidDateHour = 100;
        /// <summary>
        /// 失效效日期“分”
        /// </summary>
        public static int InValidDateMinute = 100;
        /// <summary>
        /// 失效效日期“秒”
        /// </summary>
        public static int InValidDateSecond = 0;
        #endregion

        /// <summary>
        /// 获取当前门锁的常开模式 
        /// </summary>
        /// <param name="doorLock:当前门锁"></param> 
        /// <returns>null:没有回复  ； true:门锁常开；false：门锁常关</returns> 
        public static async System.Threading.Tasks.Task<bool?> GetNormallyOpenMode(ZigBee.Device.DoorLock doorLock)
        {
            bool? IsDoorLockNormallyMode = null;
            var result = await doorLock.ReadNormallyOpenModeFuncAsync();
            //共通错误检测
            string error = HdlCheckLogic.Current.CheckCommonErrorCode(result);

            if (result == null || result.errorMessageBase != null || result.errorResponData != null)
            {
                IsDoorLockNormallyMode = null;
            }

            if (result.command == "10")
            {
                IsDoorLockNormallyMode = true;
            }
            if (result.command == "11")
            {
                IsDoorLockNormallyMode = false;
            }
            return IsDoorLockNormallyMode;
        }

        /// <summary>
        /// 门锁是否支持常开[这里暂时只有S-One门锁支持，H06C不支持, 后期通过能力值支持]
        /// </summary>
        /// <param name="doorLock:当前门锁"></param> 
        /// <returns></returns> 
        public static bool CanNormallyOpen(ZigBee.Device.DoorLock doorLock)
        {
            var listDevice = new List<CommonDevice> { };
            listDevice.Add(doorLock);
            var devTemp = Common.LocalDevice.Current.GetMyDeviceEnumInfo(listDevice);
            if (devTemp.ConcreteType == DeviceConcreteType.IntelligentLocks_Sone)
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 门锁是否支持音量[这里暂时只有S-One门锁支持，H06C不支持，后期通过能力值支持]
        /// </summary>
        /// <param name="doorLock:当前门锁"></param> 
        /// <returns></returns> 
        public static bool CanVolume(ZigBee.Device.DoorLock doorLock)
        {
            var listDevice = new List<CommonDevice> { };
            listDevice.Add(doorLock);
            var devTemp = Common.LocalDevice.Current.GetMyDeviceEnumInfo(listDevice);
            if (devTemp.ConcreteType == DeviceConcreteType.IntelligentLocks_Sone)
            {
                return true;
            }
            return false;
        }

        #region 从云端获取的方法 
        /// <summary>
        /// 获取当前账户门锁操作权限（是否被冻结）
        /// </summary>
        /// <param name="doorLock:当前门锁"></param>
        /// <param name="subAccountDistributedMark：登录账户的GUID"></param>
        /// <returns></returns>
        public static async System.Threading.Tasks.Task<bool> GetDoorLockOperateAccess(ZigBee.Device.DoorLock doorLock, string subAccountDistributedMark)
        {
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<bool>>)(async () =>
            {
                if (doorLock.IsFreezeAccount.ContainsKey(subAccountDistributedMark) == false)
                {
                    doorLock.IsFreezeAccount.Add(subAccountDistributedMark, false);
                }
                var resultList = await Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetAccountDoorLockUserList(doorLock, subAccountDistributedMark);
                var d = resultList.Find((obj) => { return obj.IsFreezeUser == true; });
                if (d != null)
                {
                    doorLock.IsFreezeAccount[subAccountDistributedMark] = true;
                }
                else
                {
                    doorLock.IsFreezeAccount[subAccountDistributedMark] = false;
                }
                return doorLock.IsFreezeAccount[subAccountDistributedMark];
            }));
        }

        /// <summary>
        /// 获取当前账户门锁远程开锁权限（是否被拥有远程开锁权限）
        /// </summary>
        /// <param name="doorLock:当前门锁"></param>
        /// <param name="subAccountDistributedMark：登录账户的GUID"></param>
        /// <returns></returns>
        public static async System.Threading.Tasks.Task<bool> GetDoorLockUnlockAccess(ZigBee.Device.DoorLock doorLock, string subAccountDistributedMark)
        {
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<bool>>)(async () =>
            {
                if (doorLock.HasRemoteUnlockAccess.ContainsKey(subAccountDistributedMark) == false)
                {
                    doorLock.HasRemoteUnlockAccess.Add(subAccountDistributedMark, false);
                }
                var resultList = await Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetAccountDoorLockUserList(doorLock, subAccountDistributedMark);
                var d = resultList.Find((obj) => { return obj.IsTempUnlockAuthority == true; });
                if (d != null)
                {
                    doorLock.HasRemoteUnlockAccess[subAccountDistributedMark] = true;
                }
                else
                {
                    doorLock.HasRemoteUnlockAccess[subAccountDistributedMark] = false;
                }
                return doorLock.HasRemoteUnlockAccess[subAccountDistributedMark];
            }));
        }

        /// <summary>
        ///  获取当前账户列表（门锁只对主人和拥有管理员权限对成员用）
        /// </summary>
        public static async System.Threading.Tasks.Task<List<Shared.Phone.UserCenter.MemberInfoRes>> LocalAccountList()
        {
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                List<Shared.Phone.UserCenter.MemberInfoRes> localAccountList = new List<Shared.Phone.UserCenter.MemberInfoRes> { };
                List<Shared.Phone.UserCenter.MemberInfoRes> SubAccounList = new List<Shared.Phone.UserCenter.MemberInfoRes> { };

                //只有主人才有权限获取自己的子账户
                if (UserCenterResourse.UserInfo.AuthorityNo == 1)
                {
                    var SubAccounListTemp = await ZigBee.Device.DoorLock.GetSubAccountByDistributedMark();
                    var SubAccounListDictionary = new Dictionary<string, Shared.Phone.UserCenter.MemberInfoRes> { };

                    foreach (var member in SubAccounListTemp)
                    {
                        //判断一个账户绑定了邮箱的情况
                        if (SubAccounListDictionary.ContainsKey(member.DistributedMark) == true
                        || member.Account == UserCenterResourse.UserInfo.Phone
                        || member.Account == UserCenterResourse.UserInfo.Email)
                        {
                            //如果是它自己的话，不显示,账户和绑定的邮箱只显示其中之一
                            continue;
                        }
                        //去掉子账户中普通成员，留下拥有管理员权限的成员
                        //（因为分配账户给普通成员，普通成员在app中不能进入设备管理那里，所以没发查看主人分配对账户）
                        if (member.AccountType != 1)
                        {
                            continue;
                        }

                        SubAccounListDictionary.Add(member.DistributedMark, member);
                    }

                    foreach (var addMemberID in SubAccounListDictionary.Keys)
                    {
                        SubAccounList.Add(SubAccounListDictionary[addMemberID]);
                    }
                }

                // 注意：SubAccountDistributedMark这个值很有用,“添加门锁”到云端信息中，CloudAccountId如果是子账户，则是SubAccountDistributedMark这个值很有用，如果是管理员或者主人则是登录到G
                var masterAccount = new Shared.Phone.UserCenter.MemberInfoRes();
                masterAccount.Account = Shared.Common.Config.Instance.Account;
                masterAccount.AccountType = Shared.Common.Config.Instance.AccountType;
                masterAccount.SubAccountDistributedMark = Shared.Common.Config.Instance.Guid;
                masterAccount.UserName = UserCenterResourse.UserInfo.UserName;
                localAccountList.Add(masterAccount);
                localAccountList.AddRange(SubAccounList);
                return localAccountList;
            });
        }

        /// <summary>
        ///  获取所有账户和门锁包含的信息
        /// </summary>
        public static async System.Threading.Tasks.Task<Dictionary<int, LocaDoorLockObj>> GetDoorLockAllAcountUserlist(ZigBee.Device.DoorLock doorLock)
        {
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<Dictionary<int, LocaDoorLockObj>>>)(async () =>
            {
                //1、读取门锁信息
                var getDoorLockInfo = await doorLock.GetDoorlockUserInfoAsync();

                //本地门锁列表处理
                foreach (var curAccountObj in doorLock.localAllAccountList)
                {
                    if (getDoorLockInfo == null)
                    {
                        doorLock.IsFailedToGetDoorLockInfo[curAccountObj.SubAccountDistributedMark] = true;
                    }
                    else
                    {
                        doorLock.IsFailedToGetDoorLockInfo[curAccountObj.SubAccountDistributedMark] = false;
                    }
                }
                // 用户信息处理
                if (getDoorLockInfo != null && getDoorLockInfo.doorLockUserDetailData != null)
                {
                    doorLock.localDoorLockUserList.Clear();
                    var dataList = getDoorLockInfo.doorLockUserDetailData.UserObjList;
                    foreach (var doorData in dataList)
                    {
                        var localDoorLockObj1 = new ZigBee.Device.DoorLock.LocaDoorLockObj()
                        {
                            UserID = doorData.UserId,
                            UnlockType = doorData.UserType
                        };
                        if ((doorLock.localDoorLockUserList.ContainsKey(localDoorLockObj1.UserID)) == false)
                        {
                            doorLock.localDoorLockUserList.Add(localDoorLockObj1.UserID, localDoorLockObj1);
                        }
                    }


                    //2、读取云端门锁信息  
                    var getDoorLockInfoAllList = new List<ZigBee.Device.DoorLock.CloudDoorLockObj> { };
                    var getDoorLockInfoList = await Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetDoorLockAllAccountInfolist(doorLock);
                    if (getDoorLockInfoList != null)
                    {
                        if (getDoorLockInfoList.PageData.Count != 0)
                        {
                            getDoorLockInfoAllList = getDoorLockInfoList.PageData;
                        }
                    }
                    if (getDoorLockInfoList.TotalPages > 1)
                    {
                        for (int j = 1; j < getDoorLockInfoList.TotalPages; j++)
                        {
                            var getDoorLockInfoListTemp = await Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetDoorLockAllAccountInfolist(doorLock, j + 1);
                            if (getDoorLockInfoListTemp != null)
                            {
                                if (getDoorLockInfoListTemp.PageData.Count != 0)
                                {
                                    foreach (var curDoorLockUser in getDoorLockInfoListTemp.PageData)
                                    {
                                        getDoorLockInfoAllList.Add(curDoorLockUser);
                                    }
                                }
                            }
                        }
                    }

                    if (getDoorLockInfoAllList.Count != 0)
                    {
                        foreach (var curDoorLockUser in getDoorLockInfoAllList)
                        {
                            if (string.IsNullOrEmpty(curDoorLockUser.DoorLockLocalUserId))
                            {
                                continue;
                            }
                            if (doorLock.localDoorLockUserList.ContainsKey(int.Parse(curDoorLockUser.DoorLockLocalUserId)))
                            {
                                var doorLockObj = new ZigBee.Device.DoorLock.LocaDoorLockObj() { };
                                doorLockObj.UserID = int.Parse(curDoorLockUser.DoorLockLocalUserId);
                                doorLockObj.UnlockType = curDoorLockUser.OpenLockMode;
                                doorLockObj.PrimaryId = curDoorLockUser.Id;
                                doorLockObj.EntryTime = curDoorLockUser.EntryTime;
                                doorLockObj.UserName = curDoorLockUser.UserIdRemarks;
                                doorLockObj.ConnectedAccount = curDoorLockUser.CloudAccountId;
                                doorLock.localDoorLockUserList[int.Parse(curDoorLockUser.DoorLockLocalUserId)] = doorLockObj;
                            }
                            else
                            {
                                if (curDoorLockUser.DoorLockLocalUserId != null)
                                {
                                    //门锁中没有，云端有用户ID，后台删除云端这些ID
                                    var deleteDoorLockData = new ZigBee.Device.DoorLock.DeleteDoorLockData();
                                    if (UserCenterResourse.UserInfo.AuthorityNo != 1)
                                    {
                                        deleteDoorLockData.LoginAccessToken = UserCenterLogic.GetConnectMainToken();
                                        deleteDoorLockData.IsOtherAccountCtrl = true;
                                    }
                                    if (doorLock.DeviceAddr != null)
                                    {
                                        deleteDoorLockData.DoorLockId = doorLock.DeviceAddr + "_" + doorLock.DeviceEpoint;
                                    }
                                    deleteDoorLockData.DoorLockLocalUserId = curDoorLockUser.DoorLockLocalUserId;
                                    deleteDoorLockData.PrimaryId = curDoorLockUser.Id;
                                    deleteDoorLockData.DelDoorLockDelType = 2;
                                    var result = await ZigBee.Device.DoorLock.SendDoorLockToServer("DoorLock/DelDoorLock", deleteDoorLockData);
                                }
                            }
                        }
                        doorLock.ReSave();
                    }
                }
                return doorLock.localDoorLockUserList;
            }));
        }

        /// <summary>
        ///  获取当前账户中门锁信息
        /// </summary>
        public static async System.Threading.Tasks.Task<Dictionary<int, LocaDoorLockObj>> GetLocaDoorLocklist(ZigBee.Device.DoorLock doorLock, Shared.Phone.UserCenter.MemberInfoRes curAccountObj)
        {
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<Dictionary<int, LocaDoorLockObj>>>)(async () =>
            {
                //读取设备中的信息
                doorLock.localDoorLockUserList.Clear();
                var getDoorLockInfo = await doorLock.GetDoorlockUserInfoAsync();
                if (getDoorLockInfo == null)
                {
                    doorLock.IsFailedToGetDoorLockInfo[curAccountObj.SubAccountDistributedMark] = true;
                }
                else
                {
                    doorLock.IsFailedToGetDoorLockInfo[curAccountObj.SubAccountDistributedMark] = false;
                    if (getDoorLockInfo != null && getDoorLockInfo.doorLockUserDetailData != null)
                    {
                        var dataList = getDoorLockInfo.doorLockUserDetailData.UserObjList;
                        foreach (var doorData in dataList)
                        {
                            var localDoorLockObj1 = new ZigBee.Device.DoorLock.LocaDoorLockObj()
                            {
                                UserID = doorData.UserId,
                                UnlockType = doorData.UserType
                            };
                            if ((doorLock.localDoorLockUserList.ContainsKey(localDoorLockObj1.UserID)) == false)
                            {
                                doorLock.localDoorLockUserList.Add(localDoorLockObj1.UserID, localDoorLockObj1);
                            }
                        }
                    }

                    //  读取云端门锁设备中的信息
                    var getDoorLockInfoAllList = await Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetDoorLockAllInfolist(doorLock, curAccountObj.SubAccountDistributedMark);
                    if (getDoorLockInfoAllList.Count != 0)
                    {
                        foreach (var getDoorLockInfoList in getDoorLockInfoAllList)
                        {
                            if (getDoorLockInfoList != null)
                            {
                                foreach (var curDoorLockUser in getDoorLockInfoList.PageData)
                                {
                                    if (string.IsNullOrEmpty(curDoorLockUser.DoorLockLocalUserId))
                                    {
                                        continue;
                                    }
                                    if (doorLock.localDoorLockUserList.ContainsKey(int.Parse(curDoorLockUser.DoorLockLocalUserId)))
                                    {
                                        var doorLockObj = new ZigBee.Device.DoorLock.LocaDoorLockObj() { };
                                        doorLockObj.UserID = int.Parse(curDoorLockUser.DoorLockLocalUserId);
                                        doorLockObj.UnlockType = curDoorLockUser.OpenLockMode;
                                        doorLockObj.PrimaryId = curDoorLockUser.Id;
                                        doorLockObj.EntryTime = curDoorLockUser.EntryTime;
                                        doorLockObj.UserName = curDoorLockUser.UserIdRemarks;
                                        doorLockObj.ConnectedAccount = curDoorLockUser.CloudAccountId;
                                        doorLock.localDoorLockUserList[int.Parse(curDoorLockUser.DoorLockLocalUserId)] = doorLockObj;
                                    }
                                    else
                                    {
                                        if (curDoorLockUser.DoorLockLocalUserId != null)
                                        {
                                            //门锁中没有，云端有用户ID，后台删除云端这些ID
                                            var deleteDoorLockData = new ZigBee.Device.DoorLock.DeleteDoorLockData();
                                            if (UserCenterResourse.UserInfo.AuthorityNo != 1)
                                            {
                                                deleteDoorLockData.LoginAccessToken = UserCenterLogic.GetConnectMainToken();
                                                deleteDoorLockData.IsOtherAccountCtrl = true;
                                            }
                                            if (doorLock.DeviceAddr != null)
                                            {
                                                deleteDoorLockData.DoorLockId = doorLock.DeviceAddr + "_" + doorLock.DeviceEpoint;
                                            }
                                            deleteDoorLockData.DoorLockLocalUserId = curDoorLockUser.DoorLockLocalUserId;
                                            deleteDoorLockData.PrimaryId = curDoorLockUser.Id;
                                            deleteDoorLockData.DelDoorLockDelType = 2;
                                            var result = await ZigBee.Device.DoorLock.SendDoorLockToServer("DoorLock/DelDoorLock", deleteDoorLockData);
                                        }
                                    }
                                }
                                doorLock.ReSave();
                            }
                        }
                    }
                }
                return doorLock.localDoorLockUserList;
            }));
        }

        /// <summary>
        ///  获取当前账户中云端存储的门锁信息
        /// </summary>
        public static async System.Threading.Tasks.Task<Dictionary<int, LocaDoorLockObj>> GetCloudLocalDoorLocklist(ZigBee.Device.DoorLock doorLock, string subAccountDistributedMark)
        {
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<Dictionary<int, LocaDoorLockObj>>>)(async () =>
            {
                var getDoorLockInfoAllList = new List<ZigBee.Device.DoorLock.CloudDoorLockObj> { };
                //  读取云端门锁设备中的信息
                var localDoorLockObj = new ZigBee.Device.DoorLock.GetDoorLockData() { };

                if (UserCenterResourse.UserInfo.AuthorityNo != 1)
                {
                    localDoorLockObj.LoginAccessToken = UserCenterLogic.GetConnectMainToken();
                    localDoorLockObj.IsOtherAccountCtrl = true;
                }

                localDoorLockObj.CloudAccountId = subAccountDistributedMark;
                if (doorLock.DeviceAddr != null)
                {
                    localDoorLockObj.DoorLockId = doorLock.DeviceAddr + "_" + doorLock.DeviceEpoint;
                }

                var getDoorLockInfoList = await ZigBee.Device.DoorLock.GetDoorLockInfoFromServer("DoorLock/GetDoorLockPager", localDoorLockObj);
                if (getDoorLockInfoList != null)
                {
                    if (getDoorLockInfoList.PageData.Count != 0)
                    {
                        getDoorLockInfoAllList = getDoorLockInfoList.PageData;
                    }
                }
                if (getDoorLockInfoList.TotalPages > 1)
                {
                    for (int j = 1; j < getDoorLockInfoList.TotalPages; j++)
                    {
                        var pageSetting = new ZigBee.Device.DoorLock.PageSetting() { };
                        pageSetting.Page = j + 1;
                        localDoorLockObj.pageSetting = pageSetting;
                        var getDoorLockInfoListTemp = await ZigBee.Device.DoorLock.GetDoorLockInfoFromServer("DoorLock/GetDoorLockPager", localDoorLockObj);
                        if (getDoorLockInfoListTemp != null)
                        {
                            if (getDoorLockInfoListTemp.PageData.Count != 0)
                            {
                                foreach (var curDoorLockUser in getDoorLockInfoListTemp.PageData)
                                {
                                    getDoorLockInfoAllList.Add(curDoorLockUser);
                                }
                            }
                        }
                    }
                }

                if (getDoorLockInfoAllList.Count != 0)
                {
                    foreach (var curDoorLockUser in getDoorLockInfoAllList)
                    {
                        if (string.IsNullOrEmpty(curDoorLockUser.DoorLockLocalUserId))
                        {
                            continue;
                        }
                        if (doorLock.localDoorLockUserList.ContainsKey(int.Parse(curDoorLockUser.DoorLockLocalUserId)))
                        {
                            var doorLockObj = new ZigBee.Device.DoorLock.LocaDoorLockObj() { };
                            doorLockObj.UserID = int.Parse(curDoorLockUser.DoorLockLocalUserId);
                            doorLockObj.UnlockType = curDoorLockUser.OpenLockMode;
                            doorLockObj.PrimaryId = curDoorLockUser.Id;
                            doorLockObj.EntryTime = curDoorLockUser.EntryTime;
                            doorLockObj.UserName = curDoorLockUser.UserIdRemarks;
                            doorLockObj.ConnectedAccount = curDoorLockUser.CloudAccountId;
                            doorLock.localDoorLockUserList[int.Parse(curDoorLockUser.DoorLockLocalUserId)] = doorLockObj;
                        }
                    }

                    doorLock.ReSave();
                }
                return doorLock.localDoorLockUserList;
            }));
        }

        /// <summary>
        ///  获取云端存储的当前账户的门锁信
        /// </summary>
        public static async System.Threading.Tasks.Task<List<ZigBee.Device.DoorLock.CloudDoorLockObj>> GetAccountDoorLockUserList(ZigBee.Device.DoorLock doorLock, string subAccountDistributedMark)
        {
            List<ZigBee.Device.DoorLock.CloudDoorLockObj> curAccountDoorLockUserList = new List<ZigBee.Device.DoorLock.CloudDoorLockObj> { };
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<List<ZigBee.Device.DoorLock.CloudDoorLockObj>>>)(async () =>
            {
                //  读取云端门锁设备中的信息
                var getAllDoorLockInfoList = await Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetDoorLockAllInfolist(doorLock, subAccountDistributedMark);
                if (getAllDoorLockInfoList != null)
                {
                    foreach (var getDoorLockInfoList in getAllDoorLockInfoList)
                    {
                        //获取云端存储的门锁成员信息
                        foreach (var curDoorLockUser in getDoorLockInfoList.PageData)
                        {
                            if (string.IsNullOrEmpty(curDoorLockUser.CloudAccountId) || curDoorLockUser.CloudAccountId != subAccountDistributedMark)
                            {
                                continue;
                            }
                            else
                            {
                                curAccountDoorLockUserList.Add(curDoorLockUser);
                            }
                        }
                    }
                }
                return curAccountDoorLockUserList;
            }));
        }

        /// <summary>
        ///  获取当前账户门锁的所有信息
        /// </summary>
        public static async System.Threading.Tasks.Task<List<ZigBee.Device.DoorLock.GetDoorLockDataRes>> GetDoorLockAllInfolist(ZigBee.Device.DoorLock doorLock, string subAccountDistributedMark)
        {
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<List<ZigBee.Device.DoorLock.GetDoorLockDataRes>>>)(async () =>
            {
                var getDoorLockInfoAllList = new List<ZigBee.Device.DoorLock.GetDoorLockDataRes> { };

                //  读取云端门锁设备中的信息
                var localDoorLockObj = new ZigBee.Device.DoorLock.GetDoorLockData() { };

                if (UserCenterResourse.UserInfo.AuthorityNo != 1)
                {
                    localDoorLockObj.LoginAccessToken = UserCenterLogic.GetConnectMainToken();
                    localDoorLockObj.IsOtherAccountCtrl = true;
                }

                localDoorLockObj.CloudAccountId = subAccountDistributedMark;
                if (doorLock.DeviceAddr != null)
                {
                    localDoorLockObj.DoorLockId = doorLock.DeviceAddr + "_" + doorLock.DeviceEpoint;
                }

                var getDoorLockInfoList = await ZigBee.Device.DoorLock.GetDoorLockInfoFromServer("DoorLock/GetDoorLockPager", localDoorLockObj);

                if (getDoorLockInfoList == null)
                {
                    getDoorLockInfoAllList = null;
                }
                else
                {
                    if (getDoorLockInfoList != null)
                    {
                        if (getDoorLockInfoList.PageData.Count != 0)
                        {
                            getDoorLockInfoAllList.Add(getDoorLockInfoList);
                        }
                    }
                    if (getDoorLockInfoList.TotalPages > 1)
                    {
                        for (int j = 1; j < getDoorLockInfoList.TotalPages; j++)
                        {
                            var pageSetting = new ZigBee.Device.DoorLock.PageSetting() { };
                            pageSetting.Page = j + 1;
                            localDoorLockObj.pageSetting = pageSetting;
                            var getDoorLockInfoListTemp = await ZigBee.Device.DoorLock.GetDoorLockInfoFromServer("DoorLock/GetDoorLockPager", localDoorLockObj);
                            if (getDoorLockInfoListTemp != null)
                            {
                                getDoorLockInfoAllList.Add(getDoorLockInfoListTemp);
                            }
                        }
                    }
                }
                return getDoorLockInfoAllList;
            }));
        }

        /// <summary>
        ///  获取当前账户门锁的所有信息
        /// </summary>
        public static async System.Threading.Tasks.Task<ZigBee.Device.DoorLock.GetDoorLockDataRes> GetDoorLockAllAccountInfolist(ZigBee.Device.DoorLock doorLock, int curPage = 1)
        {
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<ZigBee.Device.DoorLock.GetDoorLockDataRes>>)(async () =>
            {
                //  读取云端门锁设备中的信息
                var localDoorLockObj = new ZigBee.Device.DoorLock.GetDoorLockData() { };

                if (UserCenterResourse.UserInfo.AuthorityNo != 1)
                {
                    localDoorLockObj.LoginAccessToken = UserCenterLogic.GetConnectMainToken();
                    localDoorLockObj.IsOtherAccountCtrl = true;
                }
                if (doorLock.DeviceAddr != null)
                {
                    localDoorLockObj.DoorLockId = doorLock.DeviceAddr + "_" + doorLock.DeviceEpoint;
                }
                var pageSetting = new ZigBee.Device.DoorLock.PageSetting() { };
                pageSetting.Page = curPage;
                localDoorLockObj.pageSetting = pageSetting;
                var getDoorLockInfoList = await ZigBee.Device.DoorLock.GetDoorLockInfoFromServer("DoorLock/GetDoorLockPager", localDoorLockObj);
                return getDoorLockInfoList;
            }));
        }

        /// <summary>
        ///  获取云端存储的门锁成员信息
        /// </summary>
        public static async System.Threading.Tasks.Task<Dictionary<int, LocaDoorLockObj>> GetLocaDoorLockAccountlist(ZigBee.Device.DoorLock doorLock, Shared.Phone.UserCenter.MemberInfoRes curAccountObj, int curPage)
        {
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<Dictionary<int, LocaDoorLockObj>>>)(async () =>
            {
                //  读取云端门锁设备中的信息
                var localDoorLockObj = new ZigBee.Device.DoorLock.GetDoorLockData() { };
                if (UserCenterResourse.UserInfo.AuthorityNo != 1)
                {
                    localDoorLockObj.LoginAccessToken = UserCenterLogic.GetConnectMainToken();
                    localDoorLockObj.IsOtherAccountCtrl = true;
                }
                localDoorLockObj.CloudAccountId = curAccountObj.SubAccountDistributedMark;
                {
                    localDoorLockObj.DoorLockId = doorLock.DeviceAddr + "_" + doorLock.DeviceEpoint;
                }
                if (doorLock.DeviceAddr != null)
                {
                    localDoorLockObj.DoorLockId = doorLock.DeviceAddr + "_" + doorLock.DeviceEpoint;
                }
                var pageSetting = new ZigBee.Device.DoorLock.PageSetting() { };
                pageSetting.Page = curPage;
                localDoorLockObj.pageSetting = pageSetting;
                var getDoorLockInfoList = await ZigBee.Device.DoorLock.GetDoorLockInfoFromServer("DoorLock/GetDoorLockPager", localDoorLockObj);
                if (getDoorLockInfoList != null)
                {
                    foreach (var curDoorLockUser in getDoorLockInfoList.PageData)
                    {
                        var doorLockObj = new ZigBee.Device.DoorLock.LocaDoorLockObj() { };
                        if (curDoorLockUser.DoorLockLocalUserId != null)
                        {
                            doorLockObj.UserID = int.Parse(curDoorLockUser.DoorLockLocalUserId);
                            doorLockObj.UnlockType = curDoorLockUser.OpenLockMode;
                            doorLockObj.UserName = curDoorLockUser.UserIdRemarks;
                        }
                        doorLockObj.PrimaryId = curDoorLockUser.Id;
                        doorLockObj.EntryTime = curDoorLockUser.EntryTime;
                        doorLockObj.ConnectedAccount = curDoorLockUser.CloudAccountId;
                        if (doorLock.localDoorLockAccountList.ContainsKey(curDoorLockUser.CloudAccountId) == false)
                        {
                            doorLock.localDoorLockAccountList.Add(doorLockObj.ConnectedAccount, doorLockObj);
                        }
                        else
                        {
                            doorLock.localDoorLockAccountList[curDoorLockUser.DoorLockLocalUserId] = doorLockObj;
                        }
                    }
                }
                return doorLock.localDoorLockUserList;
            }));
        }

        /// <summary>
        ///  获取本地匹配成员的门锁用户信息列表
        /// </summary>
        public static async System.Threading.Tasks.Task<Dictionary<int, LocaDoorLockObj>> GetMatchDoorlockAccountList(ZigBee.Device.DoorLock doorLock, Shared.Phone.UserCenter.MemberInfoRes curAccountObj)
        {
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<Dictionary<int, LocaDoorLockObj>>>)(async () =>
            {
                var curAccountDoorLockUserList = new Dictionary<int, ZigBee.Device.DoorLock.LocaDoorLockObj>();
                foreach (var curUserId in doorLock.localDoorLockAccountList.Keys)
                {
                    var curDoorLockUser = doorLock.localDoorLockAccountList[curUserId];

                    if (string.IsNullOrEmpty(curDoorLockUser.ConnectedAccount) || curDoorLockUser.ConnectedAccount != curAccountObj.SubAccountDistributedMark)
                    {
                        continue;
                    }
                    else
                    {
                        curAccountDoorLockUserList.Add(curDoorLockUser.UserID, curDoorLockUser);
                    }
                }
                return curAccountDoorLockUserList;
            }));
        }

        /// <summary>
        /// 生成6位临时密码
        /// </summary>
        /// <returns></returns>
        public static string GetTempPassword()
        {
            string password = "";
            password = new Random().Next(100000, 999999).ToString();
            return password;
        }

        /// <summary>
        /// 将UNIX时间戳转换成系统时间(精确到秒)
        /// <returns></returns>
        public static DateTime GetLocalTime(int unixTimeStamp)
        {
            DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
            long lTime = long.Parse(unixTimeStamp + "0000000");
            TimeSpan toNow = new TimeSpan(lTime);
            DateTime dtResult = dtStart.Add(toNow);
            return dtResult;
        }

        /// <summary>
        /// 将系统时间转换成UNIX时间戳(精确到秒)
        /// <param name="dateTime">北京时间</param>
        /// <param name="accurateToMilliseconds">精确到毫秒，否到秒</param>
        /// </summary>
        /// <param name="dateTime"></param>
        /// <returns>返回一个长整数时间戳</returns>
        public static string GetUnixTimeStamp(DateTime dateTime)
        {
            DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
            TimeSpan toNow = dateTime.Subtract(dtStart);
            string timeStamp = toNow.Ticks.ToString();
            timeStamp = timeStamp.Substring(0, timeStamp.Length - 7);
            return timeStamp;
        }

        /// <summary>
        /// 获取时区的时间
        /// </summary>
        /// <returns></returns>
        public static DateTime GetDoorLockZoneTime()
        {
            //通过经度获取时区 
            var gwZone = int.Parse(CaculateTimeZone(Common.Config.Instance.Home.Longitude));
            //将本地时间转换成世界时
            var utc = DateTime.Now.AddHours(-gwZone);
            //世界时转换成时间戳
            var utcUnix = GetUnixTimeStamp(utc);
            //时区的时间戳
            var zoneUnix = int.Parse(utcUnix) + gwZone * 3600;
            var zoneDateTime = GetLocalTime(zoneUnix);
            DoorlockZoneTime = zoneDateTime;
            return zoneDateTime;
        }

        /// <summary>
        ///  获取时区 
        /// </summary>
        /// <param name="currentLon">currentLon:"+"为东区，“-”为西区</param>
        /// <returns></returns>
        public static String CaculateTimeZone(double currentLon)
        {
            int timeZone;
            int shangValue = (int)(currentLon / 15);
            double yushuValue = Math.Abs(currentLon % 15);
            if (yushuValue <= 7.5)
            {
                timeZone = shangValue;
            }
            else
            {
                timeZone = shangValue + (currentLon > 0 ? 1 : -1);
            }
            return timeZone >= 0 ? "+" + Math.Abs(timeZone) : "-" + Math.Abs(timeZone);

        }

        /// <summary>
        /// 门锁编程事件通知
        /// </summary>
        [System.Serializable]
        public class LocaDoorLockObj
        {
            /// <summary>
            /// 用户id
            /// <para>管理员10个，0~9，</para>
            ///<para>普通用户220个，10~234</para>
            ///<para>一次性用户10个，235~245</para>
            ///<para>临时密码密码10个，245~255，</para>
            ///<para>其中指纹100，密码100，卡56</para>
            ///<para>门锁本地录入的密码、指纹、感应卡都有唯一对应的用户Id</para>
            /// </summary>
            public int UserID = -1;
            /// <summary>
            /// 开锁类型
            /// <para>常用：</para>
            /// <para>0:Keypad(键盘/密码)；3:RFID(射频卡)；15:指纹</para>
            /// <para>不常用：
            /// <para>1:RF(Zigbee无线)；2:Manual(手动)；255:Indeterminate(不确定)</para>
            /// </summary>
            public int UnlockType;
            /// <summary>
            ///  关联账户的ID
            /// </summary>
            public string ConnectedAccount = string.Empty;
            /// <summary>
            ///  门锁用户名
            /// </summary>
            public string UserName = string.Empty;
            /// <summary>
            /// 门锁录入的时
            /// </summary>
            public DateTime EntryTime = System.DateTime.MinValue;
            /// <summary>
            /// PrimaryId 门锁云端主 键(非更新字段,以下均为更新字段) -->键名 : PrimaryId默认值: null
            /// </summary>
            public string PrimaryId = "";
        }

        #endregion

        #region 一般方法 
        /// <summary>
        /// 显示错误信息窗口
        /// </summary>
        /// <param name="msg"></param>
        private void ShowErrorMsg(string msg)
        {
            Application.RunOnMainThread(() =>
            {
                var contr = new ShowMsgControl(ShowMsgType.Error, msg);
                contr.Show();
            });
        }

        /// <summary>
        /// 显示Tip信息窗口
        /// </summary>
        /// <param name="msg"></param>
        private void ShowTipMsg(string msg)
        {
            Application.RunOnMainThread(() =>
            {
                var contr = new ShowMsgControl(ShowMsgType.Tip, msg);
                contr.Show();
            });
        }

        #endregion

        public enum DoorLockMessType
        {
            /// <summary>
            /// app操作
            /// </summary>
            AppOperate = 0,
            /// <summary>
            /// 设备上报
            /// </summary>
            DeviceReport = 1,
            /// <summary>
            /// 服务器推送
            /// </summary>
            ServicePush = 2,
        }

        /// <summary>
        /// 常开模式失效处理
        /// </summary>
        public static async void NomallyOpenModeInvalidDialog(ZigBee.Device.DoorLock doorLock, DoorLockMessType doorLockMessType, Action action)
        {
            if (UserCenterResourse.UserInfo.AuthorityNo != 1)
            {
                return;
            }
            string msg = Language.StringByID(R.MyInternationalizationString.NomallyModeIsCanceled).Replace("{0}", "\r\n");
            var confirm = Language.StringByID(R.MyInternationalizationString.SureCancel);
            var alert = new ShowDoorLockMsgControl(ShowDoorLockMsgControl.DoorLockMsgType.NomallyOpenMode, msg, confirm);
            var resTemp = await Shared.Phone.Device.Logic.SkipView.Exist();

            if (resTemp == 1)
            {
                //有逻辑设置的弹窗
                alert = new ShowDoorLockMsgControl(ShowDoorLockMsgControl.DoorLockMsgType.CancelNomallyOpenModeWithLogic, msg, confirm);
            }
            alert.Show();
            alert.MsgControlClickEvent += async () =>
            {
                if (doorLockMessType == DoorLockMessType.DeviceReport || doorLockMessType == DoorLockMessType.ServicePush)
                {
                    //取消常开
                    NormallyOpenModeValue(doorLock, false);
                }
                else
                {
                    //保持常开
                    NormallyOpenModeValue(doorLock, true);
                }
                action?.Invoke();
                action = null;
            };
            alert.CancelClickEvent += async () =>
            {
                if (doorLockMessType == DoorLockMessType.DeviceReport || doorLockMessType == DoorLockMessType.ServicePush)
                {
                    var result = await doorLock.SetNormallyOpenModeFuncAsync(true);
                    if (result == null || result.defaultControlResponseData == null)
                    {
                        string msg0 = Language.StringByID(R.MyInternationalizationString.GwResponseOvertime);
                        Application.RunOnMainThread(() =>
                        {
                            new Tip() { MaxWidth = 150, Text = msg0, Direction = AMPopTipDirection.None, CloseTime = 1 }.Show(CommonPage.Instance);
                        });
                        NormallyOpenModeValue(doorLock, false);
                        return;
                    }
                    if (result.defaultControlResponseData.status != 0)
                    {
                        string msg1 = Language.StringByID(R.MyInternationalizationString.OpenNormallyOpenModeFailed);
                        Application.RunOnMainThread(() =>
                        {
                            new Tip() { MaxWidth = 150, Text = msg1, Direction = AMPopTipDirection.None, CloseTime = 1 }.Show(CommonPage.Instance);
                        });
                        NormallyOpenModeValue(doorLock, false);
                        return;
                    }
                    else
                    {
                        NormallyOpenModeValue(doorLock, true);
                    }
                }
                else
                {
                    NormallyOpenModeValue(doorLock, true);
                }
                action?.Invoke();
                action = null;
            };
            alert.ConfirmClickEvent += async () =>
            {
                if (doorLockMessType == DoorLockMessType.DeviceReport || doorLockMessType == DoorLockMessType.ServicePush)
                {
                    NormallyOpenModeValue(doorLock, false);
                }
                else
                {
                    var result = await doorLock.SetNormallyOpenModeFuncAsync(false);
                    if (result == null || result.defaultControlResponseData == null)
                    {
                        Application.RunOnMainThread(() =>
                        {
                            new Tip() { MaxWidth = 150, Text = Language.StringByID(R.MyInternationalizationString.GwResponseOvertime), Direction = AMPopTipDirection.None, CloseTime = 1 }.Show(CommonPage.Instance);
                        });
                        return;
                    }
                    if (result.defaultControlResponseData.status != 0)
                    {
                        string msg1 = Language.StringByID(R.MyInternationalizationString.CloseNormallyOpenModeFailed);
                        Application.RunOnMainThread(() => { });

                        new Tip() { MaxWidth = 150, Text = msg1, Direction = AMPopTipDirection.None, CloseTime = 1 }.Show(CommonPage.Instance);
                        return;
                    }
                    else
                    {
                        NormallyOpenModeValue(doorLock, false);
                        string msg2 = Language.StringByID(R.MyInternationalizationString.CloseNormallyOpenModeSuccess);
                        Application.RunOnMainThread(() =>
                        {
                            new Tip() { MaxWidth = 150, Text = msg2, Direction = AMPopTipDirection.None, CloseTime = 1 }.Show(CommonPage.Instance);
                        });
                    }
                }
                action?.Invoke();
                action = null;
            };
        }

        /// <summary>
        /// 门锁常开模式值
        /// </summary>
        public static void NormallyOpenModeValue(ZigBee.Device.DoorLock doorLock, bool value)
        {
            string key = doorLock.DeviceAddr + "_" + doorLock.DeviceEpoint;
            if (doorLock.IsDoorLockNormallyMode.ContainsKey(key))
            {
                doorLock.IsDoorLockNormallyMode[key] = value;
            }
            else
            {
                doorLock.IsDoorLockNormallyMode.Add(key, value);
            }
        }
    }
}