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

namespace Shared.Phone.UserCenter
{
    /// <summary>
    /// 房间的逻辑
    /// </summary>
    public class HdlRoomLogic
    {
        #region ■ 变量声明___________________________

        /// <summary>
        /// 房间的逻辑
        /// </summary>
        private static HdlRoomLogic m_Current = null;
        /// <summary>
        /// 房间的逻辑
        /// </summary>
        public static HdlRoomLogic Current
        {
            get
            {
                if (m_Current == null)
                {
                    m_Current = new HdlRoomLogic();
                }
                return m_Current;
            }
        }
        /// <summary>
        /// 当前主页选择的房间对象
        /// </summary>
        public Room NowMainPageRoom = null;
        /// <summary>
        /// 当前分类选择的房间对象
        /// </summary>
        public Room NowCategoryRoom = null;
        /// <summary>
        /// 所有的房间信息
        /// </summary>
        private Dictionary<string, Room> dicRooms = new Dictionary<string, Room>();

        #endregion

        #region ■ 初始化_____________________________

        /// <summary>
        /// 初始化房间信息
        /// 从文件中全部读取所有的房间数据到内存
        /// </summary>
        public void InitAllRoom()
        {
            this.NowMainPageRoom = null;
            this.NowCategoryRoom = null;

            //清空本地缓存
            this.dicRooms.Clear();
            //检测我的喜爱这个房间对象
            this.CheckLoveRoom();

            var listFile = HdlFileLogic.Current.GetRootPathListFile();
            foreach (var fileName in listFile)
            {
                if (fileName.StartsWith("Room_") == true)
                {
                    //从文件里面获取房间对象
                    var room = this.GetRoomByFilePath(fileName);
                    if (room != null)
                    {
                        this.dicRooms[room.Id] = (room);
                    }
                }
            }
            //顺便刷新场景
            HdlSceneLogic.Current.ReFreshByLocal();
            //刷新房间视图列表
            this.RefreshRoomListView();
        }

        /// <summary>
        /// 从本地重新加载全部的房间
        /// </summary>
        public void RefreshAllRoomByLocation()
        {
            var listFile = HdlFileLogic.Current.GetRootPathListFile();

            //我的喜爱的房间必须要在第0位才行
            string fRoom = "Room_Favorite.json";
            if (listFile.Contains(fRoom) == true)
            {
                listFile.Remove(fRoom);
            }

            var listRoomFile = new List<string>();
            foreach (string fileName in listFile)
            {
                if (fileName.StartsWith("Room_"))
                {
                    string roomId = fileName.Replace("Room_", string.Empty).Replace(".json", string.Empty);
                    listRoomFile.Add(fileName);
                }
            }
            //检测楼层数据的合法性
            if (UserCenterResourse.UserInfo.AuthorityNo == 3)
            {
                this.CheckMemberFloorData(listRoomFile);
            }
            else
            {
                this.CheckAdminFloorData(listRoomFile);
            }

            this.InitAllRoom();
        }

        /// <summary>
        /// 刷新房间视图列表
        /// </summary>
        public void RefreshRoomListView()
        {
            Application.RunOnMainThread(() =>
            {
                MainPage.LeftListRoomViewFrom.Instance?.RefreshListRoom();
            });
        }

        /// <summary>
        /// 检测楼层数据的合法性
        /// </summary>
        /// <param name="listRoomFile"></param>
        private void CheckAdminFloorData(List<string> listRoomFile)
        {
            //没有楼层,则无需处理
            if (Config.Instance.Home.FloorDics.Count == 0) { return; }

            //主人或者管理员的话,就检测是否存在未分配楼层的房间
            for (int i = 0; i < listRoomFile.Count; i++)
            {
                try
                {
                    var byteData = Global.ReadFileByHomeId(listRoomFile[i]);
                    string valueData = System.Text.Encoding.UTF8.GetString(byteData);
                    var roomTemp = Newtonsoft.Json.JsonConvert.DeserializeObject<Common.Room>(valueData);

                    //检测多个手机来回创建,然后又删除之后,楼层数据不能保证100%同步的问题
                    if (roomTemp.FloorId != string.Empty && Config.Instance.Home.FloorDics.ContainsKey(roomTemp.FloorId) == false)
                    {
                        //未知楼层
                        Config.Instance.Home.FloorDics[roomTemp.FloorId] = Language.StringByID(R.MyInternationalizationString.uUnKnownFloor);
                    }
                }
                catch (Exception ex) { HdlLogLogic.Current.WriteLog(ex); }
            }
        }

        /// <summary>
        /// 检测楼层数据的合法性
        /// </summary>
        /// <param name="listRoomFile"></param>
        private void CheckMemberFloorData(List<string> listRoomFile)
        {
            //没有楼层,则无需处理
            if (Config.Instance.Home.FloorDics.Count == 0) { return; }

            //成员的话,就检测是否存在没有房间的楼层
            var listEsixtFloor = new List<string>();
            for (int i = 0; i < listRoomFile.Count; i++)
            {
                try
                {
                    var byteData = Global.ReadFileByHomeId(listRoomFile[i]);
                    string valueData = System.Text.Encoding.UTF8.GetString(byteData);
                    var roomTemp = Newtonsoft.Json.JsonConvert.DeserializeObject<Common.Room>(valueData);
                    if (roomTemp.FloorId != string.Empty && listEsixtFloor.Contains(roomTemp.FloorId) == false)
                    {
                        //收集楼层
                        listEsixtFloor.Add(roomTemp.FloorId);
                    }
                }
                catch (Exception ex) { HdlLogLogic.Current.WriteLog(ex); }
            }
            var listDeleteId = new List<string>();
            foreach (var flootId in Config.Instance.Home.FloorDics.Keys)
            {
                if (listEsixtFloor.Contains(flootId) == false)
                {
                    //如果这个id不存在于任何房间的话,收集它
                    listDeleteId.Add(flootId);
                }
            }
            foreach (var deleteId in listDeleteId)
            {
                //删除这个id
                Config.Instance.Home.FloorDics.Remove(deleteId);
            }
            Config.Instance.Home.Save(false);
        }

        #endregion

        #region ■ 添加房间___________________________

        /// <summary>
        /// 增加房间
        /// </summary>
        /// <param name="room">Room.</param>
        /// <param name="rorefreshRoomViewom">是否刷新房间视图列表界面</param>
        public void AddRoom(Room room, bool refreshRoomView = true)
        {
            if (Global.IsExistsByHomeId(room.FileName) == true)
            {
                return;
            }
            //添加到缓存
            this.dicRooms[room.Id] = room;
            //生成文件
            room.Save();
            //备份
            HdlAutoBackupLogic.AddOrEditorFile(room.FileName);
            if (refreshRoomView == true)
            {
                //刷新房间视图列表
                this.RefreshRoomListView();
            }
        }

        #endregion

        #region ■ 删除房间___________________________

        /// <summary>
        /// 删除房间
        /// </summary>
        /// <param name="roomId">房间ID</param>
        /// <param name="refreshLeftView">是否刷新左滑界面(此变量目前是给删除全部房间用的)</param>
        /// <returns></returns>
        public void RemoveRoom(string roomId, bool refreshLeftView = true)
        {
            if (this.NowMainPageRoom != null && this.NowMainPageRoom.Id == roomId)
            {
                //当删除的是主页的房间的时候
                this.NowMainPageRoom = this.GetLoveRoom();
            }
            if (this.NowCategoryRoom != null && this.NowCategoryRoom.Id == roomId)
            {
                //当删除的是分类的房间的时候
                this.NowCategoryRoom = this.GetLoveRoom();
            }

            //根据房间Id，获取房间对象
            var room = this.GetRoomById(roomId);
            if (room == null)
            {
                return;
            }
            //删除来自拍照或者系统图库的房间背景图片
            if (room.BackgroundImageType == 1 || room.BackgroundImageType == 2)
            {
                //删除掉原来的自定义图片
                if (Global.IsExistsByHomeId(room.BackgroundImage) == true)
                {
                    Global.DeleteFilebyHomeId(room.BackgroundImage);
                    //删除备份
                    HdlAutoBackupLogic.DeleteFile(room.BackgroundImage);
                }
            }
            //我的喜爱
            var loveRoom = this.GetLoveRoom();
            if (loveRoom != null)
            {
                //移除我的喜爱里面的设备
                for (int i = 0; i < room.ListDevice.Count; i++)
                {
                    loveRoom.ListDevice.Remove(room.ListDevice[i]);
                }
                //移除我的喜爱里面的场景
                for (int i = 0; i < room.ListSceneId.Count; i++)
                {
                    loveRoom.ListSceneId.Remove(room.ListSceneId[i]);
                }
                loveRoom.Save(false);
            }
            this.dicRooms.Remove(roomId);

            string roomFilePath = room.FileName;
            if (Global.IsExistsByHomeId(roomFilePath) == true)
            {
                //删除文件
                Global.DeleteFilebyHomeId(roomFilePath);
            }
            HdlAutoBackupLogic.DeleteFile(roomFilePath);

            //根据房间ID,移除指定的真实物理设备的所属房间记录
            Common.LocalDevice.Current.DeleteRealDeviceByRoomId(roomId);
            if (refreshLeftView == true)
            {
                //HdlAutoBackupLogic.DeleteFile(roomFilePath);
                //刷新房间视图列表
                this.RefreshRoomListView();
            }
        }

        /// <summary>
        /// 删除全部的房间
        /// </summary>
        public void DeleteAllRoom()
        {
            var listRoomId = new List<string>();
            foreach (var room in this.dicRooms.Values)
            {
                if (room.IsLove == false)
                {
                    listRoomId.Add(room.Id);
                }
            }
            foreach (var roomId in listRoomId)
            {
                this.RemoveRoom(roomId, false);
            }
        }

        #endregion

        #region ■ 获取房间___________________________

        /// <summary>
        /// 获取喜爱房间
        /// </summary>
        /// <returns></returns>
        public Room GetLoveRoom()
        {
            //检测我的喜爱这个房间对象
            this.CheckLoveRoom();

            return this.dicRooms["Favorite"];
        }

        /// <summary>
        /// 通过路径获取房间
        /// </summary>
        /// <returns>The room by file path.</returns>
        /// <param name="roomFilePath">Room file path.</param>
        private Room GetRoomByFilePath(string roomFilePath)
        {
            try
            {
                var roomFile = Global.ReadFileByHomeId(roomFilePath);
                var nowRoom = Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(Encoding.UTF8.GetString(roomFile));

                return nowRoom;
            }
            catch (Exception ex)
            {
                HdlLogLogic.Current.WriteLog(ex);
                return null;
            }
        }

        /// <summary>
        /// 根据房间Id，获取房间对象
        /// </summary>
        /// <returns>The room by name.</returns>
        /// <param name="roomId">房间ID</param>
        public Room GetRoomById(string roomId)
        {
            if (this.dicRooms.ContainsKey(roomId) == false)
            {
                return null;
            }
            return this.dicRooms[roomId];
        }

        /// <summary>
        /// 根据设备获取房间名字(楼层+房间名)
        /// </summary>
        /// <returns>房间名</returns>
        /// <param name="device">设备对象</param>
        public string GetRoomNameByDevice(CommonDevice device)
        {
            var room = this.GetRoomByDevice(device);
            return this.GetRoomName(room);
        }

        /// <summary>
        /// 获取房间名字(楼层+房间名)
        /// </summary>
        /// <returns>房间名</returns>
        /// <param name="room">房间对象</param>
        public string GetRoomName(Room room)
        {
            if (room == null)
            {
                //未分配区域
                return Language.StringByID(R.MyInternationalizationString.uDeviceNotAssignedRoom);
            }
            if (Config.Instance.Home.FloorDics.ContainsKey(room.FloorId) == true)
            {
                //(楼层+房间名)
                return Config.Instance.Home.FloorDics[room.FloorId] + " " + room.Name;
            }
            return room.Name;
        }

        /// <summary>
        /// 获取设备所在的房间(没有设置有房间则返回null)
        /// </summary>
        /// <returns>The room by device.</returns>
        /// <param name="device">设备对象</param>
        public Room GetRoomByDevice(CommonDevice device)
        {
            string mainKeys = LocalDevice.Current.GetDeviceMainKeys(device);
            foreach (var room in this.dicRooms.Values)
            {
                if (room.IsLove == true)
                {
                    //喜爱房间不处理
                    continue;
                }
                if (room.ListDevice.Contains(mainKeys) == true)
                {
                    return room;
                }
            }
            return null;
        }

        /// <summary>
        /// 通过场景id获取房间名
        /// </summary>
        /// <returns>The room name by scene identifier.</returns>
        /// <param name="sceneId">Scene identifier.</param>
        public string GetRoomNameBySceneId(int sceneId)
        {
            var room = GetRoomBySceneId(sceneId);
            if (room == null)
            {
                return null;
            }
            return room.Name;
        }

        /// <summary>
        /// 通过场景id获取房间对象
        /// </summary>
        /// <returns>The room  by scene identifier.</returns>
        /// <param name="sceneId">Scene identifier.</param>
        public Room GetRoomBySceneId(int sceneId)
        {
            foreach (var room in this.dicRooms.Values)
            {
                if (room.IsLove == true)
                {
                    //喜爱房间不处理
                    continue;
                }
                if (room.ListSceneId.Contains(sceneId) == true)
                {
                    return room;
                }
            }
            return null;
        }

        /// <summary>
        /// 获取当前楼层的房间
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public List<Room> GetRoomsByFloorId(string id)
        {
            var listRoom = new List<Room>();
            if (Config.Instance.Home.FloorDics.Count == 0)
            {
                //没有楼层
                foreach (var room in this.dicRooms.Values)
                {
                    listRoom.Add(room);
                }
            }
            else
            {
                foreach (var room in this.dicRooms.Values)
                {
                    if (room.FloorId == id)
                    {
                        listRoom.Add(room);
                    }
                }
            }
            return this.SortRoom(listRoom);
        }

        /// <summary>
        /// 获取全部的房间
        /// </summary>
        /// <returns></returns>
        public List<Room> GetAllListRooms()
        {
            var listRoom = new List<Room>();
            foreach (var room in this.dicRooms.Values)
            {
                listRoom.Add(room);
            }
            return this.SortRoom(listRoom);
        }

        /// <summary>
        /// 获取当前楼层的房间(拼接了【常用】在第一位)
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public List<Room> GetRoomsByFloorIdAppendLoveRoom(string id)
        {
            var listRoom = new List<Room>();
            if (Config.Instance.Home.FloorDics.Count == 0)
            {
                //没有楼层
                foreach (var room in this.dicRooms.Values)
                {
                    if (room.IsLove == false)
                    {
                        listRoom.Add(room);
                    }
                }
            }
            else
            {
                foreach (var room in this.dicRooms.Values)
                {
                    if (room.FloorId == id && room.IsLove == false)
                    {
                        listRoom.Add(room);
                    }
                }
            }
            listRoom = this.SortRoom(listRoom);

            listRoom.Insert(0, GetLoveRoom());
            return listRoom;
        }

        #endregion

        #region ■ 房间方法___________________________

        /// <summary>
        /// 设备的房间变更
        /// </summary>
        /// <param name="device">设备对象</param>
        /// <param name="roomId">新房间Id</param>
        /// <param name="saveRealRoom">是否修改真实物理设备的房间,不出意外,这个值默认为true即可</param>
        public void ChangedRoom(CommonDevice device, string roomId, bool saveRealRoom = true)
        {
            //选择的是未分配
            if (roomId == string.Empty)
            {
                //从原来的房间移除设备
                this.DeleteDevice(device);
                //移除我的喜爱
                this.DeleteLoveDevice(device);
                //设备改变房间的话,主页需要重新刷新
                UserView.UserPage.Instance.RefreshAllForm = true;
                return;
            }
            //房间是否修改
            if (this.IsRoomChanged(device, roomId) == false)
            {
                return;
            }
            //从原来的房间移除设备,这里不删除真实设备的房间
            this.DeleteDevice(device, false);

            //添加到新的房间
            var room = this.GetRoomById(roomId);
            if (room != null)
            {
                this.AddDevice(room, device, saveRealRoom);
            }
            //设备改变房间的话,主页需要重新刷新
            UserView.UserPage.Instance.RefreshAllForm = true;
        }

        /// <summary>
        /// 房间名字是否有修改
        /// </summary>
        /// <param name="device">设备对象</param>
        /// <param name="roomId">新房间Id</param>
        /// <returns></returns>
        public bool IsRoomChanged(CommonDevice device, string roomId)
        {
            var room = this.GetRoomByDevice(device);
            if (room == null || room.Id != roomId)
            {
                return true;
            }
            return false;
        }

        #endregion

        #region ■ 添加设备___________________________

        /// <summary>
        /// 添加设备
        /// </summary>
        /// <param name="i_room">房间对象</param>
        /// <param name="device">要添加的设备对象</param>
        /// <param name="saveRealRoom">是否修改真实物理设备的房间,不出意外,这个值默认为true即可</param>
        public void AddDevice(Room i_room, CommonDevice device, bool saveRealRoom)
        {
            if (device == null)
            {
                return;
            }
            //设备信息保存到本地
            device.Save();

            string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
            if (i_room.ListDevice.Contains(mainkeys) == false)
            {
                //保存到本地
                i_room.ListDevice.Add(mainkeys);
                i_room.Save();

                if (i_room.IsLove == false && saveRealRoom == true && LocalDevice.Current.GetDevicesCountByMac(device.DeviceAddr) == 1)
                {
                    //如果只有一个回路,则修改真实物理设备的房间
                    LocalDevice.Current.SaveRealDeviceRoomId(new List<CommonDevice>() { device }, i_room.Id, false);
                }
            }
        }

        /// <summary>
        /// 添加喜爱设备
        /// </summary>
        /// <param name="device">要添加的设备对象</param>
        public void AddLoveDevice(CommonDevice device)
        {
            if (device == null)
            {
                return;
            }
            //我的喜爱
            var loveRoom = this.GetLoveRoom();
            if (loveRoom != null)
            {
                string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
                if (loveRoom.ListDevice.Contains(mainkeys) == false)
                {
                    //保存到本地
                    loveRoom.ListDevice.Add(mainkeys);
                    loveRoom.Save();
                    //添加收藏设备时,需要刷新主页
                    UserView.UserPage.Instance.RefreshAllForm = true;
                }
            }
        }

        #endregion

        #region ■ 删除设备___________________________

        /// <summary>
        /// 删除设备(这个函数不删除我的喜爱)
        /// </summary>
        /// <param name="device">要删除的设备对象</param>
        /// <param name="deleteReal">是否删除真实物理设备的房间</param>
        public void DeleteDevice(CommonDevice device, bool deleteReal = true)
        {
            if (device == null)
            {
                return;
            }
            //如果它只有一个回路
            if (deleteReal == true && LocalDevice.Current.GetDevicesCountByMac(device.DeviceAddr) == 1)
            {
                //删除掉它的真实物理设备的所在位置
                LocalDevice.Current.DeleteRealDeviceFromRoom(device);
            }

            //根据设备，获取所在的房间
            var room = this.GetRoomByDevice(device);
            if (room == null)
            {
                return;
            }
            //移除缓存
            string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
            room.ListDevice.Remove(mainkeys);
            room.Save();
            //更改自动备份
            HdlAutoBackupLogic.AddOrEditorFile(room.FileName);

            //递归：删除掉以前的旧数据导致的多个房间的问题
            this.DeleteDevice(device, deleteReal);
        }

        /// <summary>
        /// 删除我的喜爱的设备
        /// </summary>
        /// <param name="device">要删除的设备对象</param>
        public void DeleteLoveDevice(CommonDevice device)
        {
            if (device == null)
            {
                return;
            }
            //我的喜爱
            var loveRoom = this.GetLoveRoom();
            if (loveRoom != null)
            {
                //移除缓存
                string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
                loveRoom.ListDevice.Remove(mainkeys);
                loveRoom.Save();
                //更改自动备份
                HdlAutoBackupLogic.AddOrEditorFile(loveRoom.FileName);
                //添加收藏设备时,需要刷新主页
                UserView.UserPage.Instance.RefreshAllForm = true;
            }
        }

        #endregion

        #region ■ 获取设备___________________________

        /// <summary>
        /// 获取当前房间下的全部设备
        /// </summary>
        /// <returns></returns>
        public List<CommonDevice> GetRoomListDevice(Room i_room)
        {
            var dicSort = new Dictionary<string, List<int>>();
            foreach (var mainKeys in i_room.ListDevice)
            {
                var device = LocalDevice.Current.GetDevice(mainKeys);
                if (device != null)
                {
                    if (dicSort.ContainsKey(device.DeviceAddr) == false)
                    {
                        dicSort[device.DeviceAddr] = new List<int>();
                    }
                    dicSort[device.DeviceAddr].Add(device.DeviceEpoint);
                }
            }
            var listDevice = new List<CommonDevice>();
            foreach (var strMac in dicSort.Keys)
            {
                var listEpont = dicSort[strMac];
                //排序
                listEpont.Sort();
                for (int i = 0; i < listEpont.Count; i++)
                {
                    var device = LocalDevice.Current.GetDevice(strMac, listEpont[i]);
                    listDevice.Add(device);
                }
            }
            return listDevice;
        }

        /// <summary>
        /// 获取房间设备类型
        /// </summary>
        /// <param name="room"></param>
        /// <returns></returns>
        public List<DeviceType> GetDeviceTypes(Room i_room)
        {
            var typeList = new List<DeviceType>();
            foreach (var mainKeys in i_room.ListDevice)
            {
                var device = LocalDevice.Current.GetDevice(mainKeys);
                if (device != null)
                {
                    typeList.Add(device.Type);
                }
            }
            return typeList;
        }

        /// <summary>
        /// 获取该类型的设备
        /// </summary>
        /// <param name="room"></param>
        /// <param name="deviceType"></param>
        /// <returns></returns>
        public List<CommonDevice> GetRoomListDevice(Room room, DeviceType deviceType)
        {
            List<CommonDevice> typeList = new List<CommonDevice>();
            foreach (var mainKeys in room.ListDevice)
            {
                var device = LocalDevice.Current.GetDevice(mainKeys);
                if (device != null && device.Type == deviceType)
                {
                    typeList.Add(device);
                }
            }

            return typeList;
        }

        /// <summary>
        /// 获取未分配区域设备
        /// </summary>
        /// <returns></returns>
        public List<CommonDevice> GetUnalloctedDevice()
        {
            var listDevice = new List<CommonDevice>();

            //已经存在的设备
            var listEsxit = new HashSet<string>();
            foreach (var room in this.dicRooms.Values)
            {
                if (room.IsLove == true)
                {
                    //不包含收藏房间
                    continue;
                }
                foreach (string mainkeys in room.ListDevice)
                {
                    if (listEsxit.Contains(mainkeys) == false)
                    {
                        listEsxit.Add(mainkeys);
                    }
                }
            }

            //所有设备
            var commonDeviceList = LocalDevice.Current.listAllDevice;
            foreach (var device in commonDeviceList)
            {
                //判断该设备能否显示在主页
                if (LocalDevice.Current.CanShowInHomeHomeMainPage(device) == false)
                {
                    continue;
                }
                string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
                if (listEsxit.Contains(mainkeys) == false)
                {
                    listDevice.Add(device);
                }
            }
            return listDevice;
        }

        /// <summary>
        /// 获取全部房间全部的设备
        /// </summary>
        /// <returns></returns>
        public List<CommonDevice> GetAllRoomListDevice()
        {
            var listDevice = new List<CommonDevice>();
            foreach (var room in this.dicRooms.Values)
            {
                if (room.IsSharedRoom || room.IsLove)
                {
                    continue;
                }
                listDevice.AddRange(this.GetRoomListDevice(room));
            }
            return listDevice;
        }

        #endregion

        #region ■ 设备是否收藏_______________________

        /// <summary>
        /// 是否是收藏设备
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public bool IsCollectInRoom(CommonDevice device)
        {
            string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
            //喜爱房间
            var room = this.GetLoveRoom();
            return room.ListDevice.Contains(mainkeys);
        }

        /// <summary>
        /// 是否是收藏设备
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public bool IsCollectInRoom(SceneUI scene)
        {
            //喜爱房间
            var room = this.GetLoveRoom();
            return room.ListSceneId.Contains(scene.Id);
        }

        #endregion

        #region ■ 楼层和房间顺序相关_________________

        /// <summary>
        /// 根据楼层的主键获取排序后的房间列表(支持无楼层模式,不获取收藏房间)
        /// </summary>
        /// <param name="i_floorKeys">楼层的主键</param>
        /// <param name="getShard">分享的房间是否也获取</param>
        /// <returns></returns>
        public List<Room> GetFloorSortRoom(string i_floorKeys, bool getShard = true)
        {
            if (i_floorKeys == null)
            {
                i_floorKeys = string.Empty;
            }
            var listRoom = new List<Room>();
            foreach (var room in this.dicRooms.Values)
            {
                if (room.FloorId != i_floorKeys && i_floorKeys != string.Empty
                    || room.IsLove == true)
                {
                    //不是同一个楼层,不要我的喜爱
                    continue;
                }
                if (getShard == false && room.IsSharedRoom == true)
                {
                    //不要分享的房间
                    continue;
                }
                listRoom.Add(room);
            }
            return this.SortRoom(listRoom);
        }

        /// <summary>
        /// 排序房间对象
        /// </summary>
        /// <param name="listRoom"></param>
        /// <returns></returns>
        public List<Room> SortRoom(List<Room> listRoom)
        {
            //从一堆文字中,获取这一堆文字里面数字字符串的最长长度
            var listName = new List<string>();
            foreach (var room in listRoom)
            {
                listName.Add(room.Name);
            }
            int numberLength = this.GetNumberMaxLength(listName);

            var listSort = new List<string[]>();
            foreach (var room in listRoom)
            {
                var strArry = new string[2];
                strArry[0] = room.Id;
                strArry[1] = string.Empty;

                string value = string.Empty;
                foreach (var c in room.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 listSortRoom = new List<Room>();
            foreach (var strArry in listSort)
            {
                var room = this.GetRoomById(strArry[0]);
                listSortRoom.Add(room);
            }
            return listSortRoom;
        }

        /// <summary>
        /// 获取排序后的楼层
        /// </summary>
        /// <returns></returns>
        public Dictionary<string, string> GetFloorSortList()
        {
            //没有楼层
            if (Config.Instance.Home.FloorDics.Count == 0)
            {
                return new Dictionary<string, string>();
            }
            //从一堆文字中,获取这一堆文字里面数字字符串的最长长度
            var listName = new List<string>();
            foreach (var floorName in Config.Instance.Home.FloorDics.Values)
            {
                listName.Add(floorName);
            }
            int numberLength = this.GetNumberMaxLength(listName);

            var listSort = new List<string[]>();
            foreach (var floorId in Config.Instance.Home.FloorDics.Keys)
            {
                var strArry = new string[2];
                strArry[0] = floorId;
                strArry[1] = string.Empty;

                string value = string.Empty;
                string floorName = Config.Instance.Home.FloorDics[floorId];
                foreach (var c in floorName)
                {
                    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 dic = new Dictionary<string, string>();
            foreach (var strArry in listSort)
            {
                dic[strArry[0]] = Config.Instance.Home.FloorDics[strArry[0]];
            }
            return dic;
        }

        #endregion

        #region ■ 克隆房间对象_______________________

        /// <summary>
        /// 克隆房间对象
        /// </summary>
        /// <returns></returns>
        public Room CloneRoomClass(Room i_room)
        {
            var newRoom = new Room();
            //克隆属性
            newRoom.Id = i_room.Id;
            newRoom.FloorId = i_room.FloorId;
            newRoom.TemperatrueDevice = i_room.TemperatrueDevice;
            newRoom.Temperatrue = i_room.Temperatrue;
            newRoom.HumidityDevice = i_room.HumidityDevice;
            newRoom.Humidity = i_room.Humidity;
            newRoom.Name = i_room.Name;
            newRoom.BackgroundImage = i_room.BackgroundImage;
            newRoom.BackgroundImageType = i_room.BackgroundImageType;

            return newRoom;
        }

        #endregion

        #region ■ 一般方法___________________________

        /// <summary>
        /// 获取房间总数
        /// </summary>
        /// <returns></returns>
        public int GetRoomCount()
        {
            return this.dicRooms.Count;
        }

        /// <summary>
        /// 检测我的喜爱这个房间对象
        /// </summary>
        private void CheckLoveRoom()
        {
            if (this.dicRooms.ContainsKey("Favorite") == true)
            {
                return;
            }
            //读取本地我的喜爱文件
            string favoriteFile = System.IO.Path.Combine(Common.Config.Instance.FullPath, "Room_Favorite.json");
            var fileContent = HdlFileLogic.Current.ReadFileTextContent(favoriteFile);
            if (fileContent != null)
            {
                var love = Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(fileContent);
                this.dicRooms["Favorite"] = love;
            }
            else
            {
                //默认添加喜爱的房间--禁止修改房间名
                var love = new Room { Name = Language.StringByID(R.MyInternationalizationString.Favorite), BackgroundImage = "RoomIcon/0.jpg", Id = "Favorite" };
                love.Save(false);
                this.dicRooms["Favorite"] = love;
            }
        }

        /// <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
    }
}