using System;
using Shared.Common;
using Newtonsoft.Json;
using Shared.Common.ResponseEntity;
using System.Collections.Generic;
using System.Text;

namespace Shared.Phone.UserCenter
{
    /// <summary>
    /// 个人中心逻辑类
    /// </summary>
    public class UserCenterLogic
    {
        #region ■ 云端接口访问_______________________

        /// <summary>
        /// 访问指定接口，返回是否成功
        /// </summary>
        /// <returns>是否成功</returns>
        /// <param name="RequestName">访问地址</param>
        /// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
        /// <param name="obj">一个类</param>
        /// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【true】</param>
        /// <param name="setAgain">当发送失败时,是否重发,默认不重发</param>
        public static bool GetResultStatuByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null, bool setAgain = false)
        {
            if (HdlWifiLogic.Current.CanAccessHttp == false && setAgain == false)
            {
                //当前无法访问网络(当需要重新发送时,跳过这个判断)
                ShowNotNetMsg(listNotShowError);
                return false;
            }
            //检测是否已经完成账号信息初始化
            if (UserCenterResourse.UserInfo.InitUserInfoSuccess == false)
            {
                //不管结果怎么样,如果调用了这个函数,需要重头获取Token,所以必须返回失败
                ReInitUserAccoutInfo(listNotShowError);
                return false;
            }
            //获取接口的连接模式
            var connectMode = GetHttpConnectMode(checkAuthority);
            //获取从接口那里取到的比特数据
            var byteData = GettByteResponsePack(RequestName, connectMode, obj);
            if (byteData == null && setAgain == true)
            {
                if (setAgain == false)
                {
                    //不指定重发
                    return false;
                }
                byteData = ResetByteRequestHttps(RequestName, checkAuthority, obj);
                if (byteData == null)
                {
                    return false;
                }
            }
            var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
            //检测是否存在错误信息
            return CheckNotEorrorMsg(revertObj, RequestName, listNotShowError, obj);
        }

        /// <summary>
        /// 访问指定接口，返回状态码(出现异常时，返回 Error)
        /// </summary>
        /// <returns>接口的状态码(出现异常时，返回 Error)</returns>
        /// <param name="RequestName">访问地址</param>
        /// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
        /// <param name="obj">一个类</param>
        /// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【true】</param>
        /// <param name="setAgain">当发送失败时,是否重发,默认不重发</param>
        /// </param>
        public static string GetResultCodeByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null, bool setAgain = false)
        {
            if (HdlWifiLogic.Current.CanAccessHttp == false && setAgain == false)
            {
                //当前无法访问网络(当需要重新发送时,跳过这个判断)
                ShowNotNetMsg(listNotShowError);
                return "Error";
            }
            //检测是否已经完成账号信息初始化
            if (UserCenterResourse.UserInfo.InitUserInfoSuccess == false)
            {
                //不管结果怎么样,如果调用了这个函数,需要重头获取Token,所以必须返回失败
                ReInitUserAccoutInfo(listNotShowError);
                return "Error";
            }

            //获取接口的连接模式
            var connectMode = GetHttpConnectMode(checkAuthority);
            //获取从接口那里取到的比特数据
            var byteData = GettByteResponsePack(RequestName, connectMode, obj);
            if (byteData == null)
            {
                if (setAgain == false)
                {
                    //不指定重发
                    return "Error";
                }
                byteData = ResetByteRequestHttps(RequestName, checkAuthority, obj);
                if (byteData == null)
                {
                    return "Error";
                }
            }
            var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
            if (revertObj == null)
            {
                return "Error";
            }
            return revertObj.StateCode;
        }

        /// <summary>
        /// 访问指定接口，并返回接口把对象已经序列化了的字符串，存在错误信息时，返回null
        /// </summary>
        /// <returns>返回：接口把对象已经序列化了的字符串，存在错误信息时，返回null</returns>
        /// <param name="RequestName">访问地址</param>
        /// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
        /// <param name="obj">一个类</param>
        /// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【true】</param>
        /// <param name="setAgain">当发送失败时,是否重发,默认不重发</param>
        /// </param>
        public static string GetResponseDataByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null, bool setAgain = false)
        {
            if (HdlWifiLogic.Current.CanAccessHttp == false && setAgain == false)
            {
                //当前无法访问网络(当需要重新发送时,跳过这个判断)
                ShowNotNetMsg(listNotShowError);
                return null;
            }
            //检测是否已经完成账号信息初始化
            if (UserCenterResourse.UserInfo.InitUserInfoSuccess == false)
            {
                //不管结果怎么样,如果调用了这个函数,需要重头获取Token,所以必须返回失败
                ReInitUserAccoutInfo(listNotShowError);
                return null;
            }
            //获取接口的连接模式
            var connectMode = GetHttpConnectMode(checkAuthority);
            //获取从接口那里取到的比特数据
            var byteData = GettByteResponsePack(RequestName, connectMode, obj);
            if (byteData == null)
            {
                if (setAgain == false)
                {
                    //不指定重发
                    return null;
                }
                byteData = ResetByteRequestHttps(RequestName, checkAuthority, obj);
                if (byteData == null)
                {
                    return null;
                }
            }
            var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
            //检测错误
            bool notError = CheckNotEorrorMsg(revertObj, RequestName, listNotShowError, obj);
            if (notError == false)
            {
                return null;
            }
            if (revertObj == null || revertObj.ResponseData == null)
            {
                return null;
            }
            return revertObj.ResponseData.ToString();
        }

        /// <summary>
        /// 访问指定接口，并直接返回接口返回的比特，存在错误信息时，返回null
        /// </summary>
        /// <returns>返回：并直接返回接口返回的比特，存在错误信息时，返回null</returns>
        /// <param name="RequestName">访问地址</param>
        /// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
        /// <param name="obj">一个类</param>
        /// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【true】</param>
        /// <param name="setAgain">当发送失败时,是否重发,默认不重发</param>
        public static byte[] GetByteResponseDataByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null, bool setAgain = false)
        {
            if (HdlWifiLogic.Current.CanAccessHttp == false && setAgain == false)
            {
                //当前无法访问网络(当需要重新发送时,跳过这个判断)
                ShowNotNetMsg(listNotShowError);
                return null;
            }
            //检测是否已经完成账号信息初始化
            if (UserCenterResourse.UserInfo.InitUserInfoSuccess == false)
            {
                //不管结果怎么样,如果调用了这个函数,需要重头获取Token,所以必须返回失败
                ReInitUserAccoutInfo(listNotShowError);
                return null;
            }
            //获取接口的连接模式
            var connectMode = GetHttpConnectMode(checkAuthority);
            //获取从接口那里取到的比特数据
            var revertObj = GettByteResponsePack(RequestName, connectMode, obj);

            if (revertObj == null)
            {
                if (setAgain == false)
                {
                    //不指定重发
                    return null;
                }
                revertObj = ResetByteRequestHttps(RequestName, checkAuthority, obj);
                if (revertObj == null)
                {
                    return null;
                }
            }
            if (revertObj != null && revertObj.Length > 0)
            {
                if (revertObj[0] == '{' && revertObj[revertObj.Length - 1] == '}')
                {
                    string data2 = System.Text.Encoding.UTF8.GetString(revertObj);
                    var data = JsonConvert.DeserializeObject<ResponsePack>(data2);
                    if (data != null && string.IsNullOrEmpty(data.StateCode) == false)
                    {
                        bool notError = CheckNotEorrorMsg(data, RequestName, listNotShowError, obj);
                        if (notError == false)
                        {
                            return null;
                        }
                    }
                }
            }
            return revertObj;
        }

        /// <summary>
        /// 私有类型:从新发送(懂的人自然懂，很难解释清楚)
        /// </summary>
        /// <param name="RequestName">访问地址</param>
        /// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
        /// <param name="obj">一个类</param>
        /// <returns></returns>
        private static byte[] ResetByteRequestHttps(string RequestName, bool checkAuthority, object obj)
        {
            //获取接口的连接模式
            var connectMode = GetHttpConnectMode(checkAuthority);

            byte[] responsePack = null;
            int count = 0;
            while (true)
            {
                System.Threading.Thread.Sleep(1000);
                //调用接口
                responsePack = GettByteResponsePack(RequestName, connectMode, obj);
                if (responsePack != null)
                {
                    break;
                }
                count++;
                if (count == 3)
                {
                    //显示没有网络的Msg
                    ShowNotNetMsg(null);
                    break;
                }
            }
            return responsePack;
        }

        /// <summary>
        /// 获取从接口那里取到的内容
        /// </summary>
        /// <returns>获取从接口那里取到的文本内容</returns>
        /// <param name="RequestName">访问地址</param>
        /// <param name="connectMode">接口的连接模式</param>
        /// <param name="obj">一个类</param>
        private static byte[] GettByteResponsePack(string RequestName, HttpConnectMode connectMode, object obj)
        {
            try
            {
                //序列化对象
                var requestJson = JsonConvert.SerializeObject(obj);
                //访问接口
                byte[] result = null;
                if (connectMode == HttpConnectMode.Normal)
                {
                    //普通访问
                    result = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync(RequestName, Encoding.UTF8.GetBytes(requestJson));
                }
                else if (connectMode == HttpConnectMode.Admin)
                {
                    //以管理员的身份访问，自身是成员
                    result = CommonPage.Instance.RequestZigbeeHttpsByAdmin(RequestName, Encoding.UTF8.GetBytes(requestJson));
                }
                return result;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return null;
            }
        }

        /// <summary>
        /// 检测是否存在错误信息,并显示错误
        /// </summary>
        /// <returns>是否存在错误信息</returns>
        /// <param name="revertObj">从接口接收到的数据</param>
        /// <param name="RequestName">请求接口</param>
        /// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别)</param>
        /// <param name="pra">请求的参数</param>
        public static bool CheckNotEorrorMsg(ResponsePack revertObj, string RequestName, List<string> listNotShowError = null, object pra = null)
        {
            if (listNotShowError != null && listNotShowError.Contains("NotCheck") == true)
            {
                //不检测
                return true;
            }
            if (revertObj == null)
            {
                HdlThreadLogic.Current.RunMain(() =>
                {
                    //网络不稳定,请稍后再试
                    string msg = Language.StringByID(R.MyInternationalizationString.uNetIsUnStabilityAndDoAgain);
                    var control = new ShowMsgControl(ShowMsgType.Tip, msg);
                    control.Show();
                }, ShowErrorMode.NO);

                return false;
            }
            if (revertObj.StateCode.ToUpper() != "SUCCESS")
            {
                if (listNotShowError != null && listNotShowError.Contains(revertObj.StateCode) == true)
                {
                    //不显示错误,然后返回true
                    return true;
                }
                HdlThreadLogic.Current.RunMain(() =>
                {
                    if (HdlCheckLogic.Current.IsAccountLoginOut() == true)
                    {
                        //如果用户已经退出了登陆,则不处理
                        return;
                    }
                    string msg = IMessageCommon.Current.GetMsgByRequestName(RequestName, revertObj, pra);
                    if (msg != null)
                    {
                        var control = new ShowMsgControl(ShowMsgType.Tip, msg);
                        control.Show();

                        //无效登录Token
                        if (revertObj.StateCode == "NoLogin")
                        {
                            ReLoginAgain(Config.Instance.Account, false);
                        }
                    }
                }, ShowErrorMode.NO);

                return false;
            }
            return true;
        }

        /// <summary>
        /// 获取接口的连接模式
        /// </summary>
        /// <param name="checkAuthority">是否检测权限</param>
        /// <returns></returns>
        public static HttpConnectMode GetHttpConnectMode(bool checkAuthority)
        {
            if (checkAuthority == false)
            {
                return HttpConnectMode.Normal;
            }
            if (Config.Instance.Home.IsOthreShare == true)
            {
                return HttpConnectMode.Admin;
            }
            return HttpConnectMode.Normal;
        }

        /// <summary>
        /// 显示没有网络的Msg
        /// </summary>
        private static void ShowNotNetMsg(List<string> listNotShowError)
        {
            if (listNotShowError != null && listNotShowError.Contains("NotCheck") == true)
            {
                //不检测
                return;
            }
            HdlThreadLogic.Current.RunMain(() =>
            {
                // 当前无网络连接,请确认网络
                string msg = Language.StringByID(R.MyInternationalizationString.uNowIsDonotNetworkAndCheckNetwork);
                var control = new ShowMsgControl(ShowMsgType.Tip, msg);
                control.Show();
            }, ShowErrorMode.NO);
        }

        #endregion

        #region ■ 添加界面相关_______________________

        /// <summary>
        /// 检测能否添加画面
        /// </summary>
        /// <returns>true:可以追加 false:不可追加</returns>
        /// <param name="form">Form</param>
        public static bool CheckCanAddForm(CommonFormBase form)
        {
            //获取画面英文名字
            string formId = GetFormID(form);

            //二重追加不可
            if (UserCenterResourse.DicActionForm.ContainsKey(formId) == false)
            {
                return true;
            }
            //暂时这样弄看看，如果重复，则关闭掉原来的界面
            var formTemp = UserCenterResourse.DicActionForm[formId];
            formTemp.CloseForm();
            UserCenterResourse.DicActionForm.Remove(formId);

            return true;
        }

        /// <summary>
        /// 把打开的画面添加到内存中
        /// </summary>
        /// <param name="form">Form.</param>
        public static void AddActionForm(CommonFormBase form)
        {
            //获取画面英文名字
            string formId = GetFormID(form);

            //二重追加不可
            if (UserCenterResourse.DicActionForm.ContainsKey(formId) == false)
            {
                form.FormID = formId;
                //内存添加
                UserCenterResourse.DicActionForm[formId] = form;
                //添加画面时，它自身就是激活的界面
                UserCenterResourse.NowActionFormID = form.FormID;

                UserCenterResourse.listActionFormId.Add(form.FormID);
            }
        }

        /// <summary>
        /// 从列表中移除画面
        /// </summary>
        /// <param name="i_closeForm">关闭的界面</param>
        public static void RemoveActionForm(CommonFormBase i_closeForm)
        {
            //获取画面ID
            string formId = GetFormID(i_closeForm);

            if (UserCenterResourse.DicActionForm.ContainsKey(formId) == true)
            {
                //移除ID
                UserCenterResourse.listActionFormId.Remove(formId);
                //移除画面
                UserCenterResourse.DicActionForm.Remove(formId);
                //清空
                UserCenterResourse.NowActionFormID = string.Empty;

                var actionForm = UserView.HomePage.Instance.GetChildren(UserView.HomePage.Instance.ChildrenCount - 1);
                if (actionForm == null)
                {
                    return;
                }
                //如果关闭的界面是DialogCommonForm类型,则不需要触发激活函数
                if (i_closeForm is DialogCommonForm)
                {
                    if (actionForm is EditorCommonForm)
                    {
                        UserCenterResourse.NowActionFormID = GetFormID((EditorCommonForm)actionForm);
                    }
                    return;
                }
                //关闭的界面为EditorCommonForm的时候
                else if ((i_closeForm is EditorCommonForm) && (actionForm is EditorCommonForm))
                {
                    //接下来激活的界面id
                    UserCenterResourse.NowActionFormID = GetFormID((CommonFormBase)actionForm);
                    try
                    {
                        var Myform = actionForm as EditorCommonForm;
                        //重置左滑使能
                        Myform.ScrollEnabled = Myform.ScrollEnabled;
                        //触发界面再次激活的事件
                        int value = Myform.FormActionAgainEvent();
                        if (value == 1)
                        {
                            //Log出力
                            HdlLogLogic.Current.WriteLog(1, Myform.FormID + " 被激活");
                        }
                    }
                    catch (Exception ex)
                    {
                        //Log出力
                        HdlLogLogic.Current.WriteLog(ex, "界面重新激活异常 " + UserCenterResourse.NowActionFormID);
                    }
                }
                else if (actionForm is UserView.UserPage)
                {
                    //清空
                    UserCenterResourse.NowActionFormID = string.Empty;
                    //这里它已经退到主页了
                    var nowForm = UserView.UserPage.Instance.GetNowActionForm();
                    nowForm?.FormActionAgainEvent();
                }
                else
                {
                    //清空
                    UserCenterResourse.NowActionFormID = string.Empty;
                }
            }
        }

        /// <summary>
        /// 获取画面ID
        /// </summary>
        /// <returns>The form name.</returns>
        /// <param name="form">Form.</param>
        private static string GetFormID(CommonFormBase form)
        {
            if (form.FormID != string.Empty)
            {
                return form.FormID;
            }
            //将命名空间去掉
            string[] Arry = form.ToString().Split(new string[] { "." }, StringSplitOptions.RemoveEmptyEntries);
            string formName = Arry[Arry.Length - 1].Trim();
            return formName;
        }

        /// <summary>
        /// 获取当前正在激活的画面
        /// </summary>
        /// <returns></returns>
        public static CommonFormBase GetNowActionForm()
        {
            if (UserCenterResourse.DicActionForm.ContainsKey(UserCenterResourse.NowActionFormID) == true)
            {
                return UserCenterResourse.DicActionForm[UserCenterResourse.NowActionFormID];
            }
            return null;
        }

        #endregion

        #region ■ 刷新本地缓存_______________________
        /// <summary>
        /// 刷新本地所有缓存
        /// </summary>
        public static void RefreshAllMemory()
        {
            //刷新住宅对象
            RefreshHomeObject();
            //刷新本地网关文件
            HdlGatewayLogic.Current.ReFreshByLocal();
            //刷新本地设备
            Common.LocalDevice.Current.ReFreshByLocal();
            //需优先于刷新房间,同步云端的网关id，如果本地拥有云端不存在的id，则表示应该被换绑了，直接删除
            HdlGatewayLogic.Current.SynchronizeDbGateway();
            //从本地重新加载全部的房间
            HdlRoomLogic.Current.RefreshAllRoomByLocation();
        }

        /// <summary>
        /// 刷新住宅对象
        /// </summary>
        public static void RefreshHomeObject()
        {
            //备份的数据，有可能是主人自己上传的，如果管理员登陆时，他获取的备份数据有点特殊
            //比如下面这三个东西在主账号那里是不需要的
            bool isOthreShare = Config.Instance.Home.IsOthreShare;
            int accountType = Config.Instance.Home.AccountType;
            string mainMark = Config.Instance.Home.MainUserDistributedMark;
            double Longitude = Config.Instance.Home.Longitude;
            double Latitude = Config.Instance.Home.Latitude;
            //还原住宅对象
            Config.Instance.Home = HdlResidenceLogic.Current.GetHouseByHouseId(Config.Instance.Home.Id);
            Config.Instance.Home.IsOthreShare = isOthreShare;
            Config.Instance.Home.AccountType = accountType;
            Config.Instance.Home.MainUserDistributedMark = mainMark;
            Config.Instance.Home.Longitude = Longitude;
            Config.Instance.Home.Latitude = Latitude;
            Config.Instance.Home.Save(false);
        }

        #endregion

        #region ■ 删除本地文件_______________________

        /// <summary>
        /// 删除本地所有文件
        /// </summary>
        /// <param name="all">true:全部删除(用于住宅删除) false:重要的文件不删除</param>
        public static void DeleteAllLocationFile(bool all = true)
        {
            string dPath = Config.Instance.FullPath;
            if (System.IO.Directory.Exists(dPath) == false)
            {
                return;
            }

            //然后获取全部的文件
            List<string> listFile = Global.FileListByHomeId();
            foreach (string file in listFile)
            {
                if (all == false && IsNotDeleteFile(file) == true)
                {
                    //这是不能删除的文件
                    continue;
                }
                //删除文件
                Global.DeleteFilebyHomeId(file);
            }
            //如果是把文件全部删除的话，那么文件夹也一起删除掉
            if (all == true)
            {
                //删除文件夹
                System.IO.Directory.Delete(dPath, true);
            }
        }

        /// <summary>
        /// 判断是不是不应该删除的文件
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static bool IsNotDeleteFile(string fileName)
        {
            if (fileName == "Config.json")
            {
                //不能删除Config文件
                return true;
            }
            else if (fileName.StartsWith("House_") == true)
            {
                //不能删除住宅文件
                return true;
            }
            return false;
        }

        #endregion

        #region ■ 重新登录___________________________

        /// <summary>
        /// 重新登录
        /// </summary>
        /// <param name="account">账号</param>
        /// <param name="noticeDb">是否通知云端</param>
        public static void ReLoginAgain(string account = "", bool noticeDb = true)
        {
            if (Config.Instance.Home.IsVirtually == true)
            {
                //如果是虚拟住宅
                HdlThreadLogic.Current.RunMain(() =>
                {
                    //设定一个时间
                    Config.Instance.LoginDateTime = new DateTime(1970, 1, 1);
                    //清空当前住宅id
                    Config.Instance.HomeId = string.Empty;
                    Config.Instance.Save();
                    //收起左菜单
                    CommonPage.Instance.CloseLeftMenu();
                    //关闭所有打开了的界面
                    CloseAllOpenForm();

                    //显示登陆画面
                    var formLogin = new Login.AccountLoginForm();
                    Shared.Common.CommonPage.Instance.AddChidren(formLogin);
                    formLogin.ShowForm(account);
                });
                return;
            }
            UserCenterResourse.AccountOption.OldAccountId = string.Empty;
            //关闭所有接收
            HdlGatewayReceiveLogic.Current.RemoveAllEvent();
            //清除升级列表
            FirmwareUpdateResourse.dicUpdateList.Clear();

            HdlThreadLogic.Current.RunThread(() =>
            {
                //检测APP是否能够退出
                while (UserCenterResourse.AccountOption.AppCanSignout == false)
                {
                    System.Threading.Thread.Sleep(500);
                }
                //设定一个时间
                Config.Instance.LoginDateTime = new DateTime(1970, 1, 1);
                Config.Instance.Save();

                //清空当前住宅id
                Config.Instance.HomeId = string.Empty;
                HdlGatewayLogic.Current.ClearAllRealGateway();

                //断开远程Mqtt连接
                HdlThreadLogic.Current.RunThread(async () =>
                {
                    await ZigBee.Device.ZbGateway.DisConnectRemoteMqttClient();
                }, ShowErrorMode.NO);

                HdlThreadLogic.Current.RunMain(() =>
                {
                    //收起左菜单
                    CommonPage.Instance.CloseLeftMenu();
                    //关闭所有打开了的界面
                    CloseAllOpenForm();

                    //显示登陆画面
                    var formLogin = new Login.AccountLoginForm();
                    Shared.Common.CommonPage.Instance.AddChidren(formLogin);
                    formLogin.ShowForm(account);
                });

                if (noticeDb == true)
                {
                    //通知云端，已经退出登陆
                    var result = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("ZigbeeUsers/SignOut", null, "GET");
                }
            });
        }

        /// <summary>
        /// 关闭所有打开了的界面
        /// </summary>
        /// <param name="tagetFrom">目标界面,如果指定了的话,则关闭目标界面上层的全部界面(它自身不关闭)</param>
        public static void CloseAllOpenForm(string tagetFrom = null)
        {
            while (UserView.HomePage.Instance.ChildrenCount > 0)
            {
                var view = UserView.HomePage.Instance.GetChildren(UserView.HomePage.Instance.ChildrenCount - 1);
                //(因底层控件修改了, 父控件移除时, 不触发子控件的移除事件)
                if (view is ViewGroup)
                {
                    //关闭加载在ViewGroup里面的自定义界面Form
                    CloseViewGroupChildren((ViewGroup)view);
                }

                if (view is CommonFormBase)
                {
                    if (((CommonFormBase)view).FormID == tagetFrom)
                    {
                        //只关闭到指定目标界面
                        return;
                    }
                    ((CommonFormBase)view).CloseForm();
                }
                else if (view is UserView.UserPage)
                {
                    return;
                }
                else
                {
                    view.RemoveFromParent();
                }
            }
        }

        /// <summary>
        /// 关闭加载在ViewGroup里面的自定义界面Form(因底层控件修改了,父控件移除时,不触发子控件的移除事件)
        /// </summary>
        /// <param name="group"></param>
        private static void CloseViewGroupChildren(ViewGroup group)
        {
            for (int i = 0; i < group.ChildrenCount; i++)
            {
                var view = group.GetChildren(i);
                if (view is CommonFormBase)
                {
                    ((CommonFormBase)view).CloseForm();
                    i--;
                }
            }
        }

        #endregion

        #region ■ 拼接信息___________________________

        /// <summary>
        /// 拼接路径(全路径)，以住宅ID的文件夹为起点，当没有指定参数时，则返回【住宅ID的文件夹】的全路径
        /// </summary>
        /// <param name="listNames">要拼接的路径</param>
        /// <returns></returns>
        public static string CombinePath(params object[] listNames)
        {
            string rootPath = Config.Instance.FullPath;
            if (listNames == null || listNames.Length == 0)
            {
                return rootPath;
            }
            foreach (var file in listNames)
            {
                if (file == null)
                {
                    continue;
                }
                rootPath = System.IO.Path.Combine(rootPath, file.ToString());
            }
            return rootPath;
        }

        /// <summary>
        /// 拼接网关回复超时的信息
        /// </summary>
        /// <param name="errorMsg">错误信息</param>
        /// <param name="resultData">网关返回的resultData,里面有【errorMessageBase】这个东西的那种对象</param>
        /// <param name="strResultData">网关返回的resultData,里面的【errorMessageBase】的值,设定有此值时，resultData无效</param>
        /// <param name="addBrackets">是否添加括号</param>
        /// <returns></returns>
        public static string CombineGatewayTimeOutMsg(string errorMsg, object resultData, string strResultData = null, bool addBrackets = true)
        {
            if (resultData == null && strResultData == null)
            {
                return errorMsg;
            }

            string errorMsgBase = strResultData;
            if (errorMsgBase == null)
            {
                if (resultData is ReceiptGatewayResult)
                {
                    errorMsgBase = string.Empty;
                    if (((ReceiptGatewayResult)resultData).ErrorMsgDiv == 0)
                    {
                        errorMsgBase = "回复超时";
                    }
                }
                else
                {
                    Type myType = resultData.GetType();
                    object errorObj = myType.InvokeMember("errorMessageBase", System.Reflection.BindingFlags.GetField, null, resultData, null);
                    if (errorObj == null)
                    {
                        return errorMsg;
                    }
                    errorMsgBase = errorObj.ToString();
                }
            }

            if (errorMsgBase.Contains("回复超时") == false)
            {
                //只有回复超时的时候才会加上
                return errorMsg;
            }
            errorMsg += "\r\n";
            if (addBrackets == true)
            {
                //(网关回复超时,请稍后再试)
                return errorMsg + "(" + Language.StringByID(R.MyInternationalizationString.uGatewayResponseTimeOut) + ")";
            }
            else
            {
                //网关回复超时,请稍后再试
                return errorMsg + Language.StringByID(R.MyInternationalizationString.uGatewayResponseTimeOut);
            }
        }

        #endregion

        #region ■ 刷新个人中心的内存及线程___________

        /// <summary>
        /// 异步方法执行(仅限切换住宅时调用)，刷新个人中心的内存及线程
        /// </summary>
        /// <param name="ShowPrompted">新追加变量：是否显示提示自动备份的界面</param>
        /// <returns></returns>
        public static bool InitUserCenterMenmoryAndThread(bool ShowPrompted = true)
        {
            //调用这个方法,都需要重新刷新主页
            UserView.UserPage.Instance.RefreshForm = true;

            //添加网络状态监听
            HdlWifiLogic.Current.StartListenNetWork();

            //如果是虚拟住宅
            if (Config.Instance.Home.IsVirtually == true)
            {
                //初始化虚拟住宅的个人中心的数据(切换住宅使用)
                InitUserCenterMenmoryByVirtualHome();
                return true;
            }

            //APP缓存加载开始
            UserCenterResourse.AccountOption.AppCanSignout = false;
            //还原远程连接权限变量
            ZigBee.Device.ZbGateway.AllowRemoteCtrl = true;

            //只有在住宅ID不一样的时候才做这个操作
            if (Common.Config.Instance.HomeId != UserCenterResourse.AccountOption.OldHomeStringId
                || Common.Config.Instance.Account != UserCenterResourse.AccountOption.OldAccountId)
            {
                //断开远程Mqtt连接
                HdlThreadLogic.Current.RunThread(async () =>
                {
                    await ZigBee.Device.ZbGateway.DisConnectRemoteMqttClient();
                }, ShowErrorMode.NO);

                //清空所有成员缓存
                ClearAllMemberMemory();

                //加载账号配置信息
                var optionInfo = UserCenterResourse.AccountOption.Load();
                UserCenterResourse.AccountOption = optionInfo;
                //变更根用户图片目录路径
                UserCenterResourse.AccountOption.UserPictruePath = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath, Config.Instance.Guid, DirNameResourse.UserPictrueDirectory);

                //加载住宅配置信息
                UserCenterResourse.ResidenceOption = UserCenterResourse.ResidenceOption.Load();

                //初始化登陆账号的信息
                var hadNet = InitUserAccoutInfo(true);
                //如果有网络的话
                if (hadNet == 1)
                {
                    //重新发送命令去绑定断网情况下备份的网关
                    HdlGatewayLogic.Current.ResetComandToBindBackupGateway();
                    //读取隐匿配置
                    HdlBackupLogic.Current.LoadHideOption();
                }

                //预创建个人中心全部的文件夹
                CreatAllUserCenterDirectory();

                //关闭所有接收
                HdlGatewayReceiveLogic.Current.RemoveAllEvent();
                //刷新安防上报信息
                HdlAlarmsLogic.Current.RefreshAlarmInfo();

                //保存用户的登陆信息到本地
                SaveUserInformationToLocation();

                UserCenterResourse.AccountOption.OldHomeStringId = Common.Config.Instance.HomeId;
                UserCenterResourse.AccountOption.OldAccountId = Common.Config.Instance.Account;

                //同步数据(二次调用没关系)
                int result = -1;
                if (hadNet == 1)
                {
                    result = HdlAutoBackupLogic.SynchronizeDbAutoBackupData();
                }

                //初始化本地的网关信息
                HdlGatewayLogic.Current.ReFreshByLocal();
                //初始化本地的设备信息
                LocalDevice.Current.ReFreshByLocal();

                //初始化房间(郭雪城那边不做处理,需要这里特殊执行一步)
                HdlRoomLogic.Current.RefreshAllRoomByLocation();

                if (hadNet == 1)
                {
                    //同步云端的网关id，如果本地拥有云端不存在的id，则表示应该被换绑了，直接删除
                    HdlGatewayLogic.Current.SynchronizeDbGateway();
                }

                //刷新APP前一次选择的网关ID(可以反复调用,需要在网关初始化完了之后才能调用)
                HdlGatewayLogic.Current.RefreshAppOldSelectGatewayId();

                //0:已经同步过，不需要同步,这个时候需要提示备份
                if (result == 0 && ShowPrompted == true)
                {
                    //开启自动备份
                    HdlAutoBackupLogic.ShowAutoBackupPromptedForm();
                }
                //显示引导界面
                ShowGuideForm(result);
            }
            //APP缓存加载完成
            UserCenterResourse.AccountOption.AppCanSignout = true;

            return true;
        }

        /// <summary>
        /// 初始化虚拟住宅的个人中心的数据(切换住宅使用)
        /// </summary>
        private static void InitUserCenterMenmoryByVirtualHome()
        {
            UserCenterResourse.AccountOption.OldHomeStringId = Common.Config.Instance.Home.Id;
            //清空所有成员缓存
            ClearAllMemberMemory();
            //预创建个人中心全部的文件夹
            CreatAllUserCenterDirectory();
            //关闭所有接收
            HdlGatewayReceiveLogic.Current.RemoveAllEvent();
            //初始化本地的网关信息
            HdlGatewayLogic.Current.ReFreshByLocal();
            //初始化本地的设备信息
            Common.LocalDevice.Current.ReFreshByLocal();
            //初始化房间(郭雪城那边不做处理,需要这里特殊执行一步)
            HdlRoomLogic.Current.RefreshAllRoomByLocation();
            //刷新左边刷新房间视图列表
            HdlRoomLogic.Current.RefreshRoomListView();
        }

        /// <summary>
        /// 清空所有成员缓存
        /// </summary>
        private static void ClearAllMemberMemory()
        {
            //消息记录重新读取及检测
            ControlCommonResourse.ReadMessageAgain = true;
            ControlCommonResourse.HadNewMessage = false;
            HdlThreadLogic.Current.RunMain(() =>
            {
                for (int i = 0; i < ControlCommonResourse.listMessageManaContr.Count; i++)
                {
                    //显示角标特效
                    ControlCommonResourse.listMessageManaContr[i].IsSelected = false;
                }
            });

            //切换住宅清除之前逻辑缓存数据;
            Common.Logic.LogicList.Clear();
            Common.Logic.LockLogicList.Clear();
            Common.Logic.SoneLogicList.Clear();
        }

        #endregion

        #region ■ 初始化登陆账号的信息_______________

        /// <summary>
        /// 初始化登陆账号的信息 -1:无网 1:正常 2:其他错误
        /// </summary>
        /// <param name="reLoad">是否从新从本地加载(重新初始化登陆账号的信息,不需要重新加载)</param>
        /// <returns></returns>
        private static int InitUserAccoutInfo(bool reLoad)
        {
            //初始化个人信息的标识
            UserCenterResourse.UserInfo.InitUserInfoSuccess = false;
            if (reLoad == true)
            {
                //获取本地记录的用户信息
                UserCenterResourse.UserInfo = GetUserInformationFromLocation();
                UserCenterResourse.UserInfo.UserIconFile = System.IO.Path.Combine(UserCenterResourse.AccountOption.UserPictruePath, "Admin.png");
            }
            if (HdlWifiLogic.Current.CanAccessHttp == false)
            {
                //无法连接外网
                return -1;
            }

            //获取登录账号的信息
            var pra = new AccountInfoPra();
            //序列化对象
            var requestJson = JsonConvert.SerializeObject(pra);
            //访问接口
            byte[] byteData = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("ZigbeeUsers/GetAccountInfo", Encoding.UTF8.GetBytes(requestJson));
            if (byteData == null)
            {
                return -1;
            }
            //检测错误
            var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
            if (revertObj.StateCode.ToUpper() != "SUCCESS")
            {
                return 2;
            }

            var userInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<UserInformation>(revertObj.ResponseData.ToString());
            userInfo.Account = Common.Config.Instance.Account;
            if (string.IsNullOrEmpty(userInfo.UserName) == true)
            {
                //没有昵称的时候，把账号作为昵称
                userInfo.UserName = Common.Config.Instance.Account;
            }

            if (Common.Config.Instance.Home.IsOthreShare == false)
            {
                //身份:管理员
                userInfo.AuthorityNo = 1;
                userInfo.AuthorityText = Language.StringByID(R.MyInternationalizationString.Administrator);
            }
            else if (Common.Config.Instance.Home.AccountType == 1)
            {
                //身份:成员(拥有管理员权限)
                userInfo.AuthorityNo = 2;
                userInfo.AuthorityText = Language.StringByID(R.MyInternationalizationString.uMemberHadActionAuthority);
            }
            else
            {
                //身份:成员
                userInfo.AuthorityNo = 3;
                userInfo.AuthorityText = Language.StringByID(R.MyInternationalizationString.uMember);
            }

            if (UserCenterResourse.UserInfo.AuthorityNo != userInfo.AuthorityNo)
            {
                //如果登陆的账号的权限和上一次的不一样,则删除本地这个住宅全部的文件,从头再来
                string dirPath = CombinePath();
                if (System.IO.Directory.Exists(dirPath) == true)
                {
                    try
                    {
                        //同步数据的判断文件(以防万一删除整个文件夹失败的时候,这个文件被删的话,应该没什么大问题)
                        string SynchronizeFile = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.AutoDownLoadBackupCheckFile);
                        //如果本地已经拥有了这个文件，则说明不是新手机，不再自动还原
                        if (System.IO.File.Exists(SynchronizeFile) == true)
                        {
                            System.IO.File.Delete(SynchronizeFile);
                        }
                        //删除整个文件夹
                        System.IO.Directory.Delete(dirPath, true);
                    }
                    catch { }
                    //创建住宅文件夹
                    Global.CreateHomeDirectory(Config.Instance.HomeId);
                    //预创建个人中心全部的文件夹
                    CreatAllUserCenterDirectory();
                }
            }
            if (string.IsNullOrEmpty(userInfo.UserName) == true)
            {
                //没有昵称的话,把账号丢过去
                userInfo.UserName = userInfo.Account;
            }

            UserCenterResourse.UserInfo = userInfo;
            UserCenterResourse.UserInfo.UserIconFile = System.IO.Path.Combine(UserCenterResourse.AccountOption.UserPictruePath, "Admin.png");
            if (UserCenterResourse.UserInfo.HeadImage != null)
            {
                //写入头像内容
                Shared.IO.FileUtils.WriteFileByBytes(UserCenterResourse.UserInfo.UserIconFile, UserCenterResourse.UserInfo.HeadImage);
            }
            UserCenterResourse.UserInfo.HeadImage = null;
            //手势密码
            UserCenterResourse.AccountOption.GestureAuthentication = UserCenterResourse.UserInfo.GesturePwd == null ? string.Empty : UserCenterResourse.UserInfo.GesturePwd;
            UserCenterResourse.UserInfo.GesturePwd = null;
            //密码验证
            UserCenterResourse.AccountOption.PswAuthentication = UserCenterResourse.UserInfo.StringPwd == null ? string.Empty : UserCenterResourse.UserInfo.StringPwd;
            UserCenterResourse.UserInfo.StringPwd = null;

            //初始化管理员控制主人的连接地址(因为这个连接Token是不会改变的,所以只需要初始化一次)
            var flage = InitAdminConnectMainInfo();
            //初始化个人信息的标识
            UserCenterResourse.UserInfo.InitUserInfoSuccess = flage == 1;

            return flage;
        }

        /// <summary>
        /// 从本地获取用户的登陆信息
        /// </summary>
        /// <returns></returns>
        private static UserInformation GetUserInformationFromLocation()
        {
            string fileName = CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.UserInfoFile);
            var value = LoadFileContent(fileName);
            if (value == null)
            {
                return new UserInformation();
            }
            var info = Newtonsoft.Json.JsonConvert.DeserializeObject<UserInformation>(value);
            return info;
        }

        /// <summary>
        /// 重新初始化登陆账号的信息(旨在对应那一瞬间,网络不好,导致误判的情况)
        /// </summary>
        /// <returns></returns>
        private static bool ReInitUserAccoutInfo(List<string> listNotShowError)
        {
            //重新初始化账号信息
            var result = InitUserAccoutInfo(false);
            //连接不了外网的时候
            if (result == -1)
            {
                if (listNotShowError != null && listNotShowError.Contains("NotCheck") == true)
                {
                    //有这个标识时,不提示错误
                    return false;
                }
                Application.RunOnMainThread(() =>
                {
                    //当前无网络连接,请确认网络
                    var alert = new ShowMsgControl(ShowMsgType.Tip, Language.StringByID(R.MyInternationalizationString.uNowIsDonotNetworkAndCheckNetwork));
                    alert.Show();
                });
            }
            if (result == 1)
            {
                //同步云端的网关id，如果本地拥有云端不存在的id，则表示应该被换绑了，直接删除
                HdlGatewayLogic.Current.SynchronizeDbGateway();
                //初始化个人信息的标识
                UserCenterResourse.UserInfo.InitUserInfoSuccess = true;

                return true;
            }
            return false;
        }

        /// <summary>
        /// 保存用户的登陆信息到本地
        /// </summary>
        private static void SaveUserInformationToLocation()
        {
            string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.UserInfoFile);
            //写入内容
            SaveFileContent(fullName, UserCenterResourse.UserInfo);

            //搞一下主人的默认头像
            string defultFile = IO.FileUtils.GetImageFilePath("Center/Admin.png");
            if (defultFile == string.Empty)
            {
                return;
            }
            if (System.IO.File.Exists(UserCenterResourse.UserInfo.UserIconFile) == true)
            {
                return;
            }
            //复制过去
            System.IO.File.Copy(defultFile, UserCenterResourse.UserInfo.UserIconFile);
        }

        #endregion

        #region ■ 初始化管理员权限远程连接___________

        /// <summary>
        /// 初始化管理员权限远程连接主人的信息 -1:无网 1:正常 2:其他错误
        /// </summary>
        /// <returns></returns>
        private static int InitAdminConnectMainInfo()
        {
            if (UserCenterResourse.UserInfo.AuthorityNo != 2 && UserCenterResourse.UserInfo.AuthorityNo != 3)
            {
                //时代变了,这里管理员和成员都能调用
                return 1;
            }
            var pra = new
            {
                CommonPage.RequestVersion,
                LoginAccessToken = Config.Instance.Token,
                MainAccountId = Config.Instance.Home.MainUserDistributedMark,
                SharedHid = Config.Instance.Home.Id
            };

            //序列化对象
            var requestJson = JsonConvert.SerializeObject(pra);
            //访问接口
            byte[] byteData = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("App/GetSharedHomeApiControl", Encoding.UTF8.GetBytes(requestJson));
            if (byteData == null)
            {
                return -1;
            }
            //检测错误
            var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
            if (revertObj.StateCode.ToUpper() != "SUCCESS")
            {
                return 2;
            }

            //分享链接
            var info = JsonConvert.DeserializeObject<MemberAdministratorResult>(revertObj.ResponseData.ToString());
            Config.Instance.AdminRequestBaseUrl = info.RequestBaseUrl;
            Config.Instance.AdminRequestToken = info.RequestToken;

            return 1;
        }

        #endregion

        #region ■ 预创建个人中心全部的文件夹_________

        /// <summary>
        /// 预创建个人中心全部的文件夹
        /// </summary>
        public static void CreatAllUserCenterDirectory()
        {
            //本地缓存的根目录
            string LocalDirectory = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory);
            Global.CreateEmptyDirectory(LocalDirectory);

            //自动备份【文件夹】(编辑,追加)
            string directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.AutoBackupDirectory);
            Global.CreateEmptyDirectory(directory);

            //自动备份【文件夹】(删除)
            directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.AutoBackupdeleteDirectory);
            Global.CreateEmptyDirectory(directory);

            //下载备份的时候所使用的临时【文件夹】
            directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.DownLoadBackupTempDirectory);
            Global.CreateEmptyDirectory(directory);

            //保存安防记录的【文件夹】
            directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.SafeguardAlarmDirectory);
            Global.CreateEmptyDirectory(directory);

            //上传网关备份文件到云端的临时【文件夹】
            directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.GatewayBackupDirectory);
            Global.CreateEmptyDirectory(directory);

            //下载分享文件的临时【文件夹】
            directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.DownLoadShardDirectory);
            Global.CreateEmptyDirectory(directory);

            //LOG出力【文件夹】
            directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.LogDirectory);
            Global.CreateEmptyDirectory(directory);

            //用户图片目录路径【文件夹】
            if (UserCenterResourse.AccountOption.UserPictruePath != string.Empty && !System.IO.Directory.Exists(UserCenterResourse.AccountOption.UserPictruePath))
            {
                System.IO.Directory.CreateDirectory(UserCenterResourse.AccountOption.UserPictruePath);
            }
        }

        #endregion

        #region ■ 获取控制主人账号的Token____________

        /// <summary>
        /// 获取控制主人账号的Token
        /// </summary>
        /// <returns></returns>
        public static string GetConnectMainToken()
        {
            //启用管理员权限
            if (Config.Instance.Home.IsOthreShare == true)
            {
                return Config.Instance.AdminRequestToken;
            }
            return Config.Instance.Token;
        }

        #endregion

        #region ■ 引导界面___________________________

        /// <summary>
        /// 显示引导界面
        /// </summary>
        /// <param name="result">同步结果 -1：异常   0:已经同步过，不需要同步  1：正常同步  2:没有自动备份数据</param>
        private static void ShowGuideForm(int result)
        {
            var checkFile = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath, DirNameResourse.GuideFile);
            if (System.IO.File.Exists(checkFile) == true)
            {
                //不需要显示
                return;
            }
            if (result == 2 && Config.Instance.Home.IsOthreShare == false)
            {
                HdlThreadLogic.Current.RunMain(() =>
                {
                    var form = new Guide.GuideHouseForm();
                    form.ShowFrom();
                });
            }

            //创建一个空文件(标识已经完成引导)
            var file = System.IO.File.Create(checkFile);
            file.Close();
        }

        #endregion

        #region ■ 16进制转化_________________________

        /// <summary>
        /// 将16进制的文本翻译为正常文本
        /// </summary>
        /// <param name="hexText">16进制的文本</param>
        /// <param name="count">以多少个字节为一组</param>
        /// <returns></returns>
        public static string TranslateHexadecimalIntoText(string hexText, int count = 2)
        {
            string textValue = string.Empty;
            while (hexText.Length > 0)
            {
                string temp = hexText.Substring(0, count);
                hexText = hexText.Substring(count);
                int value = Convert.ToInt32(temp, 16);
                textValue += ((char)value).ToString();
            }
            return textValue;
        }

        /// <summary>
        /// 将文本翻译为16进制的文本
        /// </summary>
        /// <param name="text">指定文本</param>
        /// <returns></returns>
        public static string TranslateTextIntoHexadecimal(string text)
        {
            string textValue = string.Empty;
            foreach (char c in text)
            {
                int value = Convert.ToInt32(c);
                textValue += Convert.ToString(value, 16);
            }
            return textValue;
        }

        #endregion

        #region ■ 加密和解密_________________________

        /// <summary>
        /// 加密密码
        /// </summary>
        /// <param name="keys"></param>
        /// <param name="strPsw"></param>
        /// <returns></returns>
        public static string EncryptPassword(string keys, string strPsw)
        {
            try
            {
                if (strPsw == string.Empty)
                {
                    return strPsw;
                }
                var des = new System.Security.Cryptography.DESCryptoServiceProvider();
                byte[] inputByteArray = Encoding.Default.GetBytes(strPsw);
                des.Key = ASCIIEncoding.ASCII.GetBytes(keys);
                des.IV = ASCIIEncoding.ASCII.GetBytes(keys);
                var ms = new System.IO.MemoryStream();
                var cs = new System.Security.Cryptography.CryptoStream(ms, des.CreateEncryptor(), System.Security.Cryptography.CryptoStreamMode.Write);
                cs.Write(inputByteArray, 0, inputByteArray.Length);
                cs.FlushFinalBlock();
                StringBuilder ret = new StringBuilder();
                foreach (byte b in ms.ToArray())
                {
                    ret.AppendFormat("{0:X2}", b);
                }
                return ret.ToString().ToLower();
            }
            catch { return strPsw; }
        }

        /// <summary>
        /// 解密密码
        /// </summary>
        /// <param name="strPsw"></param>
        /// <returns></returns>
        public static string DecryptPassword(string keys, string strPsw)
        {
            try
            {
                if (strPsw == string.Empty)
                {
                    return strPsw;
                }
                var des = new System.Security.Cryptography.DESCryptoServiceProvider();

                byte[] inputByteArray = new byte[strPsw.Length / 2];
                for (int x = 0; x < strPsw.Length / 2; x++)
                {
                    int i = (Convert.ToInt32(strPsw.Substring(x * 2, 2), 16));
                    inputByteArray[x] = (byte)i;
                }

                des.Key = ASCIIEncoding.ASCII.GetBytes(keys);
                des.IV = ASCIIEncoding.ASCII.GetBytes(keys);
                var ms = new System.IO.MemoryStream();
                var cs = new System.Security.Cryptography.CryptoStream(ms, des.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Write);
                cs.Write(inputByteArray, 0, inputByteArray.Length);
                cs.FlushFinalBlock();

                StringBuilder ret = new StringBuilder();

                return System.Text.Encoding.Default.GetString(ms.ToArray());
            }
            catch { return strPsw; }
        }
        #endregion

        #region ■ 时间转换___________________________

        /// <summary>
        /// 将utc时间类型的字符串,转换为本地时间
        /// </summary>
        /// <param name="timeText"></param>
        /// <returns></returns>
        public static DateTime ConvertUtcTimeToLocalTime(string timeText)
        {
            var utcTime = Convert.ToDateTime(timeText);
            return TimeZoneInfo.ConvertTimeFromUtc(utcTime, TimeZoneInfo.Local);
        }

        #endregion

        #region ■ 文件保存和读取_____________________

        /// <summary>
        /// 文件保存(整天忘记,所以建一个函数来玩玩)
        /// </summary>
        /// <param name="fullName">全路径</param>
        /// <param name="obj">需要序列化的东西</param>
        public static void SaveFileContent(string fullName, object obj)
        {
            var data = JsonConvert.SerializeObject(obj);
            SaveTexToFile(fullName, data);
        }

        /// <summary>
        /// 文件保存(整天忘记,所以建一个函数来玩玩)
        /// </summary>
        /// <param name="fullName">全路径</param>
        /// <param name="obj">需要序列化的东西</param>
        public static void SaveTexToFile(string fullName, string textValue)
        {
            var byteData = Encoding.UTF8.GetBytes(textValue);
            //写入内容
            System.IO.FileStream fileStream = null;
            try
            {
                fileStream = new System.IO.FileStream(fullName, System.IO.FileMode.Create, System.IO.FileAccess.Write);
                fileStream.Write(byteData, 0, byteData.Length);
                fileStream.Flush();
            }
            catch { }
            finally
            {
                fileStream?.Close();
            }
        }

        /// <summary>
        /// 读取文件,不限制住宅(文件不存在返回null,整天忘记,所以建一个函数来玩玩)
        /// </summary>
        /// <param name="fullName">全路径</param>
        /// <returns></returns>
        public static string LoadFileContent(string fullName)
        {
            //读取文件
            var varByte = ReadFileContent(fullName);
            if (varByte == null)
            {
                return null;
            }
            return Encoding.UTF8.GetString(varByte);
        }

        /// <summary>
        /// 读取文件,不限制住宅,文件不存在返回null
        /// </summary>
        /// <param name="fullName">全路径</param>
        /// <returns></returns>
        public static byte[] ReadFileContent(string fullName)
        {
            if (System.IO.File.Exists(fullName) == false)
            {
                return null;
            }
            System.IO.FileStream fileStream = null;
            try
            {
                fileStream = new System.IO.FileStream(fullName, System.IO.FileMode.Open, System.IO.FileAccess.Read);
                byte[] array = new byte[fileStream.Length];
                fileStream.Read(array, 0, array.Length);
                return array;
            }
            catch
            {
                return null;
            }
            finally
            {
                fileStream?.Close();
            }
        }

        #endregion
    }
}