using Shared.Common;
using System;
using System.Collections.Generic;
using System.Text;

namespace Shared.Phone.UserCenter
{
    /// <summary>
    /// 住宅对象的逻辑
    /// </summary>
    public class HdlResidenceLogic
    {
        #region ■ 变量声明___________________________

        /// <summary>
        /// 住宅对象的逻辑
        /// </summary>
        private static HdlResidenceLogic m_Current = null;
        /// <summary>
        /// 住宅对象的逻辑
        /// </summary>
        public static HdlResidenceLogic Current
        {
            get
            {
                if (m_Current == null)
                {
                    m_Current = new HdlResidenceLogic();
                }
                return m_Current;
            }
        }

        #endregion

        #region ■ 创建新住宅_________________________

        /// <summary>
        /// 创建新的住宅(返回住宅id,null代表失败)
        /// </summary>
        /// <param name="residenceName">住宅名称</param>
        public string CreatNewResidence(string residenceName)
        {
            var Pra = new AddResidencePra();
            Pra.Name = residenceName;
            //添加住宅
            string resultData = UserCenterLogic.GetResponseDataByRequestHttps("App/AddHome", false, Pra);
            if (string.IsNullOrEmpty(resultData) == true)
            {
                return null;
            }
            var newInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<List<NewResidenceInfo>>(resultData);

            //添加住宅到缓存
            this.AddHouseToMemmory(newInfo[0].Id, residenceName);

            return newInfo[0].Id;
        }

        /// <summary>
        /// 添加住宅到缓存
        /// </summary>
        /// <param name="houseId">住宅id</param>
        /// <param name="houseName">住宅名称.</param>
        /// <param name="isOthreShare">是否为其他主用户分享过来的住宅</param>
        /// <param name="accountType">仅子账号登陆的时候使用,当【IsOthreShare】为"true"，并且【AccountType】为"1"时，该账号拥有管理员权限</param>
        public void AddHouseToMemmory(string houseId, string houseName,
            bool isOthreShare = false, int accountType = 0)
        {
            var home = new Common.House();
            home.Id = houseId;
            home.Name = houseName;
            home.IsOthreShare = isOthreShare;
            home.AccountType = accountType;

            //创建文件夹
            Common.Global.CreateHomeDirectory(houseId);
            home.Save();
            Common.Config.Instance.HomeFilePathList.Add(home.FileName);
            Common.Config.Instance.Save();
            //如果当前没有住宅的话
            if (Common.Config.Instance.Home.Id == string.Empty)
            {
                Common.Config.Instance.Home = this.GetHouseByFilePath(home.FileName);
                Common.Config.Instance.HomeId = home.Id;
            }
        }


        #endregion

        #region ■ 切换住宅___________________________

        /// <summary>
        /// 切换住宅(注:它只切换内存,界面并未处理)
        /// </summary>
        /// <param name="residenceId"></param>
        /// <returns></returns>
        public bool SwitchResidence(string residenceId)
        {
            //打开进度条
            ProgressBar.Show();

            Config.Instance.HomeId = residenceId;
            //重新初始化住宅对象
            Config.Instance.Home = this.GetHouseByHouseId(residenceId);
            Config.Instance.Save();
            //刷新个人中心的内存及线程
            bool result = UserCenterLogic.InitUserCenterMenmoryAndThread(false);

            //关闭进度条
            ProgressBar.Close();

            return result;
        }

        #endregion

        #region ■ 编辑住宅___________________________

        /// <summary>
        /// 编辑住宅
        /// </summary>
        /// <param name="residenceId">住宅id</param>
        /// <param name="residenceName">住宅名称</param>
        /// <returns></returns>
        public bool EditorResidenceName(string residenceId, string residenceName)
        {
            var Pra = new EditorResidencePra();
            Pra.HomeId = residenceId;
            Pra.Name = residenceName;
            Pra.IsOtherAccountCtrl = false;
            Pra.LoginAccessToken = Config.Instance.Token;

            //编辑住宅
            bool flage = UserCenterLogic.GetResultStatuByRequestHttps("App/EditHome", false, Pra);
            if (flage == true)
            {
                //刷新内存的住宅名
                this.EditorHouseByHouseId(residenceId, residenceName);
            }
            return flage;
        }

        /// <summary>
        /// 编辑缓存住宅
        /// </summary>
        /// <param name="residenceId">住宅id</param>
        /// <param name="residenceName">住宅名称</param>
        public void EditorHouseByHouseId(string residenceId, string residenceName)
        {
            if (Config.Instance.Home.Id == residenceId)
            {
                Config.Instance.Home.Name = residenceName;
            }

            var home = GetHouseByHouseId(residenceId);
            if (home == null)
            {
                return;
            }
            home.Name = residenceName;
            home.Save();
            //住宅修改名称的话,主页需要重新刷新
            UserView.UserPage.Instance.RefreshAllForm = true;
        }


        #endregion

        #region ■ 获取住宅___________________________

        /// <summary>
        /// 通过【id】获取住宅
        /// </summary>
        /// <returns>The house by house identifier.</returns>
        /// <param name="houseId">住宅id</param>
        public House GetHouseByHouseId(string houseId)
        {
            var path = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath, Config.Instance.Guid, houseId, $"House_{houseId}.json");
            var file = HdlFileLogic.Current.ReadFileByteContent(path);
            if (file == null)
            {
                return null;
            }
            return Newtonsoft.Json.JsonConvert.DeserializeObject<House>(System.Text.Encoding.UTF8.GetString(file));
        }

        /// <summary>
        /// 通过【文件路径】获取住宅
        /// </summary>
        /// <returns>The house by file path.</returns>
        /// <param name="filePath">文件路径</param>
        public House GetHouseByFilePath(string filePath)
        {
            var path = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath, Config.Instance.Guid, GetHouseIdByFilePath(filePath), filePath);
            var file = HdlFileLogic.Current.ReadFileByteContent(path);
            if (file == null)
            {
                return null;
            }
            return Newtonsoft.Json.JsonConvert.DeserializeObject<House>(System.Text.Encoding.UTF8.GetString(file));
        }

        #endregion

        #region ■ 获取云端住宅列表___________________
        /// <summary>
        /// 获取云端住宅列表
        /// </summary>
        /// <param name="checkNetwork">是否检测网络,如果设置检测的话,当不能联网时,直接返回本地住宅</param>
        /// <returns></returns>
        public List<string> GetHomeListsFromDb(bool checkNetwork)
        {
            if (checkNetwork == true && HdlWifiLogic.Current.CanAccessHttp == false)
            {
                //当前无法联网
                return Config.Instance.HomeFilePathList;
            }
            var requestObj = new SendDataToServer.ResidenceListReqDto()
            {
                RequestVersion = CommonPage.RequestVersion,
                ReqDto = new SendDataToServer.ResidenceListObj()
                {
                    LoginAccessToken = Config.Instance.Token,
                    PageSetting = new SendDataToServer.ResidenceListPageSettingObj { PageSize = 999 }
                }
            };
            try
            {
                var requestJson = Newtonsoft.Json.JsonConvert.SerializeObject(requestObj);
                var revertObj = CommonPage.Instance.RequestHttpsZigbeeAsync("App/GetHomePager", System.Text.Encoding.UTF8.GetBytes(requestJson), 5);
                if (revertObj == null)
                {
                    return null;
                }
                if (revertObj.StateCode.ToUpper() == "SUCCESS")
                {
                    var responseDataObj = Newtonsoft.Json.JsonConvert.DeserializeObject<Shared.Common.ResponseEntity.ResidenceRes>(revertObj.ResponseData.ToString());
                    if (responseDataObj.TotalCount > 0)
                    {
                        //清空当前住宅列表
                        Config.Instance.HomeFilePathList.Clear();
                        var listHouse = new List<House>();
                        foreach (var residence in responseDataObj.PageData)
                        {
                            Config.Instance.HomeFilePathList.Add($"House_{residence.Id}.json");
                            var house = GetHouseByHouseId(residence.Id);
                            if (house == null)
                            {
                                house = new House
                                {
                                    Id = residence.Id,
                                    Name = residence.Name,
                                    IsOthreShare = residence.IsOthreShare,
                                    AccountType = residence.AccountType,
                                    MainUserDistributedMark = residence.MainUserDistributedMark,
                                    Longitude = residence.Longitude,
                                    Latitude = residence.Latitude
                                };
                            }
                            else
                            {
                                house.Id = residence.Id;
                                house.Name = residence.Name;
                                house.IsOthreShare = residence.IsOthreShare;
                                house.AccountType = residence.AccountType;
                                house.MainUserDistributedMark = residence.MainUserDistributedMark;
                                house.Longitude = residence.Longitude;
                                house.Latitude = residence.Latitude;
                            }
                            Global.CreateHomeDirectory(residence.Id);
                            house.Save(false);
                            listHouse.Add(house);
                        }
                        //检测本地的住宅文件是否合法
                        var listLocal = this.GetAllLocalResidenceListByDirectory();
                        foreach (var myHouse in listLocal)
                        {
                            //如果本地存在不属于他的住宅文件,则删除
                            if (myHouse.HouseDataDiv == 1 && Config.Instance.HomeFilePathList.Contains(myHouse.FileName) == false)
                            {
                                string housePath = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath, Config.Instance.Guid, myHouse.Id);
                                HdlFileLogic.Current.DeleteDirectory(housePath);
                            }
                        }
                        //如果切换了账号,或者原来的id不存在,则重置住宅ID
                        if (Config.Instance.TheSameLoginAccount == false ||
                            Config.Instance.HomeFilePathList.Contains($"House_{Config.Instance.HomeId}.json") == false)
                        {
                            Config.Instance.HomeId = listHouse[0].Id;
                            if (listHouse.Count > 0)
                            {
                                Config.Instance.HomeId = listHouse[0].Id;
                                Config.Instance.Home = GetHouseByHouseId(listHouse[0].Id);
                            }
                        }
                        Config.Instance.Save();
                    }
                }
            }
            catch (Exception ex)
            {
                HdlLogLogic.Current.WriteLog(ex);
            }
            return Config.Instance.HomeFilePathList;
        }

        #endregion

        #region ■ 获取本地住宅列表___________________

        /// <summary>
        /// 获取本地住宅列表
        /// </summary>
        /// <returns></returns>
        public List<Common.House> GetLocalResidenceList()
        {
            //如果是虚拟住宅,则从根目录中获取
            if (Common.Config.Instance.Home.IsVirtually == true)
            {
                //从文件夹中获取全部的住宅对象
                return this.GetAllLocalResidenceListByDirectory();
            }

            var listHome = new List<Common.House>();
            foreach (var housePath in Common.Config.Instance.HomeFilePathList)
            {
                var home = this.GetHouseByFilePath(housePath);
                if (home == null)
                {
                    continue;
                }
                listHome.Add(home);
            }
            return this.SortHouse(listHome);
        }

        /// <summary>
        /// 从文件夹中获取全部的住宅对象
        /// </summary>
        /// <returns></returns>
        public List<Common.House> GetAllLocalResidenceListByDirectory()
        {
            var strPath = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath, Common.Config.Instance.Guid);
            var listHome = new List<Common.House>();
            //获取全部的文件夹
            var listDirectory = new List<string>();
            var arryDirs = System.IO.Directory.GetDirectories(strPath);
            foreach (var file in arryDirs)
            {
                string[] arry = file.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
                listDirectory.Add(arry[arry.Length - 1]);
            }
            foreach (var myDir in listDirectory)
            {
                //获取各个文件夹里面的住宅文件
                string nowPath = System.IO.Path.Combine(strPath, myDir);
                var arryHouse = System.IO.Directory.GetFiles(nowPath, "House_*");
                if (arryHouse.Length > 0)
                {
                    //读取文件内容
                    var textValue = HdlFileLogic.Current.ReadFileTextContent(System.IO.Path.Combine(nowPath, arryHouse[0]));
                    if (textValue == null)
                    {
                        continue;
                    }
                    var myHouse = Newtonsoft.Json.JsonConvert.DeserializeObject<Common.House>(textValue);
                    listHome.Add(myHouse);
                }
            }
            return this.SortHouse(listHome);
        }

        #endregion

        #region ■ 住宅排序___________________________

        /// <summary>
        /// 住宅排序
        /// </summary>
        /// <param name="i_listHouse"></param>
        /// <returns></returns>
        public List<House> SortHouse(List<House> i_listHouse)
        {
            //从一堆文字中,获取这一堆文字里面数字字符串的最长长度
            var listName = new List<string>();
            foreach (var house in i_listHouse)
            {
                listName.Add(house.Name);
            }
            int numberLength = this.GetNumberMaxLength(listName);

            var listSort = new List<string[]>();
            var dicHouse = new Dictionary<string, House>();
            foreach (var house in i_listHouse)
            {
                //临时缓存
                dicHouse[house.Id] = house;

                var strArry = new string[2];
                strArry[0] = house.Id;
                strArry[1] = string.Empty;

                string value = string.Empty;
                foreach (var c in house.Name)
                {
                    if (char.IsNumber(c) == true)
                    {
                        //数字
                        value += c.ToString();
                        continue;
                    }
                    else if (value != string.Empty)
                    {
                        //如果房间名字带有数字的话,则左边加零,因为这里有个排序的问题
                        strArry[1] += value.PadLeft(numberLength, '0');
                        value = string.Empty;
                    }
                    strArry[1] += c.ToString();
                }
                if (value != string.Empty)
                {
                    //以数字结尾的话
                    strArry[1] += value.PadLeft(numberLength, '0');
                }
                listSort.Add(strArry);
            }
            //排序
            listSort.Sort((obj1, obj2) =>
            {
                if (obj1[1].CompareTo(obj2[1]) > 0)
                {
                    return 1;
                }
                return -1;
            });
            var listSortHouse = new List<House>();
            foreach (var strArry in listSort)
            {
                listSortHouse.Add(dicHouse[strArry[0]]);
            }
            return listSortHouse;
        }

        /// <summary>
        /// 云端住宅排序
        /// </summary>
        /// <param name="i_listData"></param>
        /// <returns></returns>
        public List<Common.ResponseEntity.ResidenceObj> SortHouse(List<Common.ResponseEntity.ResidenceObj> i_listData)
        {
            //从一堆文字中,获取这一堆文字里面数字字符串的最长长度
            var listName = new List<string>();
            foreach (var house in i_listData)
            {
                listName.Add(house.Name);
            }
            int numberLength = this.GetNumberMaxLength(listName);

            var listSort = new List<string[]>();
            var dicHouse = new Dictionary<string, Common.ResponseEntity.ResidenceObj>();
            foreach (var house in i_listData)
            {
                //临时缓存
                dicHouse[house.Id] = house;

                var strArry = new string[2];
                strArry[0] = house.Id;
                strArry[1] = string.Empty;

                string value = string.Empty;
                foreach (var c in house.Name)
                {
                    if (char.IsNumber(c) == true)
                    {
                        //数字
                        value += c.ToString();
                        continue;
                    }
                    else if (value != string.Empty)
                    {
                        //如果房间名字带有数字的话,则左边加零,因为这里有个排序的问题
                        strArry[1] += value.PadLeft(numberLength, '0');
                        value = string.Empty;
                    }
                    strArry[1] += c.ToString();
                }
                if (value != string.Empty)
                {
                    //以数字结尾的话
                    strArry[1] += value.PadLeft(numberLength, '0');
                }
                listSort.Add(strArry);
            }
            //排序
            listSort.Sort((obj1, obj2) =>
            {
                if (obj1[1].CompareTo(obj2[1]) > 0)
                {
                    return 1;
                }
                return -1;
            });
            var listSortHouse = new List<Common.ResponseEntity.ResidenceObj>();
            foreach (var strArry in listSort)
            {
                listSortHouse.Add(dicHouse[strArry[0]]);
            }
            return listSortHouse;
        }

        /// <summary>
        /// 从一堆文字中,获取这一堆文字里面数字字符串的最长长度
        /// </summary>
        /// <param name="listText"></param>
        /// <returns></returns>
        private int GetNumberMaxLength(List<string> listText)
        {
            int maxLength = 0;
            foreach (var text in listText)
            {
                string value = string.Empty;
                foreach (var c in text)
                {
                    if (char.IsNumber(c) == true)
                    {
                        //数字
                        value += c.ToString();
                        continue;
                    }
                    else if (value != string.Empty)
                    {
                        //判断数字长度
                        if (maxLength <= value.Length)
                        {
                            maxLength = value.Length;
                        }
                        value = string.Empty;
                    }
                }
                //判断数字长度
                if (maxLength <= value.Length)
                {
                    maxLength = value.Length;
                }
            }
            return maxLength;
        }

        #endregion

        #region ■ 删除住宅___________________________

        /// <summary>
        /// 删除住宅
        /// </summary>
        /// <param name="filePath">File path.</param>
        public void DeleteHouseMemmory(string houseId)
        {
            string filePath = this.GetHouseFilePathByHouseId(houseId);
            var delPath = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath, Config.Instance.Guid, GetHouseIdByFilePath(filePath));
            if (System.IO.Directory.Exists(delPath) == false)
            {
                return;
            }
            var fileList = GetHouseFileListByHomeId(houseId);
            foreach (var file in fileList)
            {
                //删除文件
                System.IO.File.Delete(System.IO.Path.Combine(delPath, file));
            }
            //删除文件夹
            System.IO.Directory.Delete(delPath, true);
            //HomeFilePathList中删除该列表
            Common.Config.Instance.HomeFilePathList.RemoveAll((obj) => obj == filePath);
            Config.Instance.Save();
        }

        #endregion

        #region ■ 获取该住宅的文件列表_______________

        /// <summary>
        /// 通过【houseId】获取该住宅的文件列表
        /// </summary>
        /// <returns>The house file list by home identifier.</returns>
        /// <param name="houseId">House identifier.</param>
        public List<string> GetHouseFileListByHomeId(string houseId)
        {
            var list = new List<string> { };
            var path = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath, Config.Instance.Guid, houseId);
            if (!System.IO.Directory.Exists(path))
            {
                return new List<string> { };
            }
            var files = System.IO.Directory.GetFiles(path);
            foreach (var file in files)
            {
                var f = file.Substring(path.Length + 1);
                System.Console.WriteLine(f);
                list.Add(f);
            }
            return list;
        }

        #endregion

        #region ■ 一般方法___________________________

        /// <summary>
        /// 获取楼层名称
        /// </summary>
        /// <param name="i_FloorId">楼层ID</param>
        /// <returns></returns>
        public string GetFloorNameById(string i_FloorId)
        {
            if (i_FloorId == null) { return string.Empty; }
            if (Config.Instance.Home.FloorDics.ContainsKey(i_FloorId) == false)
            {
                return string.Empty;
            }
            return Config.Instance.Home.FloorDics[i_FloorId];
        }

        /// <summary>
        /// 通过【文件路径】获取住宅id
        /// </summary>
        /// <returns>The house identifier by file path.</returns>
        /// <param name="filePath">文件路径</param>
        public string GetHouseIdByFilePath(string filePath)
        {
            string[] sArray = filePath.Split(new string[] { "House_", ".json" }, StringSplitOptions.RemoveEmptyEntries);
            if (sArray.Length >= 1)
            {
                return sArray[0];
            }
            return null;
        }

        /// <summary>
        /// 通过【住宅id】获取住宅路径
        /// </summary>
        /// <returns>The house identifier by file path.</returns>
        /// <param name="houseId">住宅id</param>
        public string GetHouseFilePathByHouseId(string houseId)
        {
            return $"House_{houseId}.json";
        }

        #endregion

        #region ■ 结构体_____________________________

        /// <summary>
        ///  添加住宅的启动参数
        /// </summary>
        private class AddResidencePra : IfacePraCommon
        {
            /// <summary>
            /// RequestVersion
            /// </summary>
            public string RequestVersion = Common.CommonPage.RequestVersion;
            /// <summary>
            /// LoginAccessToken
            /// </summary>
            public string LoginAccessToken = Common.Config.Instance.Token;
            /// <summary>
            /// Name
            /// </summary>
            public string Name = string.Empty;
        }

        /// <summary>
        /// 新住宅的信息
        /// </summary>
        private class NewResidenceInfo
        {
            /// <summary>
            /// ZigbeeHomeGuid
            /// </summary>
            public string Id = string.Empty;
        }
        #endregion
    }
}