using Shared.Common;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Net;
using System.Text;
using ZigBee.Device;

namespace Shared.Phone
{
    /// <summary>
    /// 分享的逻辑
    /// </summary>
    public class HdlShardLogic
    {
        #region ■ 变量声明___________________________

        /// <summary>
        /// 分享的逻辑
        /// </summary>
        private static HdlShardLogic m_Current = null;
        /// <summary>
        /// 分享的逻辑
        /// </summary>
        public static HdlShardLogic Current
        {
            get
            {
                if (m_Current == null)
                {
                    m_Current = new HdlShardLogic();
                }
                return m_Current;
            }
            set
            {
                m_Current = value;
            }
        }
        /// <summary>
        /// 分享压缩文件的名字
        /// </summary>
        private const string SHARED_BIN_FILE = "SharedData.bin";
        /// <summary>
        /// 分享的设备对象
        /// </summary>
        private Dictionary<string, CommonDevice> DicDevices = null;
        /// <summary>
        /// 分享的场景对象
        /// </summary>
        private Dictionary<int, SceneUI> DicScenes = new Dictionary<int, SceneUI>();
        /// <summary>
        /// 分享的房间信息
        /// </summary>
        private Dictionary<string, Room> DicRooms = new Dictionary<string, Room>();
        /// <summary>
        /// 分享的楼层信息
        /// </summary>
        private Dictionary<string, string> DicFloor = new Dictionary<string, string>();
        /// <summary>
        /// 分享的文件的主键(key:文件名,value:主键)
        /// </summary>
        private Dictionary<string, string> DicShardKeys = new Dictionary<string, string>();

        #endregion

        #region ■ 同步服务器的分享内容_______________

        /// <summary>
        /// 同步服务器的分享内容(里面只负责把东西存入本地)
        /// </summary>
        public bool SynchronizeDbSharedContent()
        {
            if (HdlUserCenterResourse.ResidenceOption.AuthorityNo != 3)
            {
                //只有成员才有这个概念
                return true;
            }

            //获取主人分享给成员的文件列表
            var listShardInfo = this.GetShardFileListFromDb(Config.Instance.Guid);
            if (listShardInfo == null)
            {
                return false;
            }

            //主键
            var dicAddMark = new Dictionary<string, string>();
            //检测取消了共享的操作使用
            var dicShardFile = new Dictionary<string, string>();
            //获取前回共享文件的更新日期(keys:文件名字,value:更新日期)
            var dicUpdateTime = this.GetAllShardFileAgoUpdateTime();

            //先看看这分享数据里面有什么鬼
            foreach (var info in listShardInfo)
            {
                //如果是压缩文件,需要特殊处理
                if (info.FileName == SHARED_BIN_FILE)
                {
                    //判断Bin文件的更新日期
                    if (dicUpdateTime.ContainsKey(info.FileName) == false
                       || info.CreateTime.CompareTo(dicUpdateTime[info.FileName]) > 0)
                    {
                        dicAddMark[info.Id] = info.FileName;
                        //更新日更新
                        dicUpdateTime[info.FileName] = info.CreateTime;
                    }
                    continue;
                }
                dicShardFile[info.FileName] = info.Id;

                //如果本地没有,或者更新日期大于前回更新日期的时候
                if (Global.IsExistsByHomeId(info.FileName) == false
                    || dicUpdateTime.ContainsKey(info.FileName) == false
                    || info.CreateTime.CompareTo(dicUpdateTime[info.FileName]) > 0)
                {
                    dicAddMark[info.Id] = info.FileName;
                    //更新日更新
                    dicUpdateTime[info.FileName] = info.CreateTime;
                }
            }

            //不要忘记初始化这个东西
            this.DicDevices = new Dictionary<string, CommonDevice>();
            //从云端获取下来文件
            if (dicAddMark.Count > 0)
            {
                //开启进度条 共享数据同步中
                ProgressFormBar.Current.Start();
                ProgressFormBar.Current.SetMsg(Language.StringByID(R.MyInternationalizationString.uShardDataIsSynchronizing));

                //将分享的数据存入本地(获取的是本地没有的)
                var listDbFile = this.SetShardFileToLocation(dicAddMark);
                if (listDbFile == null)
                {
                    //关闭
                    ProgressFormBar.Current.Close();
                    return false;
                }

                //转移文件
                foreach (string fileName in listDbFile)
                {
                    //不是bin文件,则移动文件到本地
                    if (fileName != SHARED_BIN_FILE)
                    {
                        var oldPath = Path.Combine(HdlFileNameResourse.DownLoadShardDirectory, fileName);
                        var newPath = Path.Combine(Config.Instance.FullPath, fileName);
                        HdlFileLogic.Current.CopyFile(oldPath, newPath);
                    }
                    else
                    {
                        //读取bin文件的内容
                        var dataContent = this.GetShardFileContent(fileName);
                        if (dataContent != null)
                        {
                            //解析bin文件
                            this.AdjustBinFileContent(Encoding.UTF8.GetString(dataContent));
                        }
                    }
                }
            }

            //同步服务器的取消了的分享内容
            return this.SynchronizeSharedCancelContent(dicShardFile, dicUpdateTime);
        }

        /// <summary>
        /// 同步服务器的取消了的分享内容
        /// </summary>
        /// <param name="dicShardFile">云端上面分享的文件,key:文件名 value:主键</param>
        /// <param name="dicUpdateTime">分享文件的更新时间,key:文件名 value:时间</param>
        /// <returns></returns>
        private bool SynchronizeSharedCancelContent(Dictionary<string, string> dicShardFile, Dictionary<string, string> dicUpdateTime)
        {
            //开启进度条  共享数据同步中
            ProgressFormBar.Current.Start();
            ProgressFormBar.Current.SetMsg(Language.StringByID(R.MyInternationalizationString.uShardDataIsSynchronizing));

            //重新设置楼层
            Config.Instance.Home.FloorDics.Clear();
            foreach (var key in this.DicFloor.Keys)
            {
                Config.Instance.Home.FloorDics[key] = this.DicFloor[key];
            }
            //获取分享的设备的文件名
            var listShardDeviceFile = new HashSet<string>();
            foreach (var device in this.DicDevices.Values)
            {
                listShardDeviceFile.Add(device.FilePath);
            }
            //住宅的根目录
            var localPath = Config.Instance.FullPath;

            //然后检测本地的文件
            var listLocalFile = HdlFileLogic.Current.GetRootPathListFile();
            foreach (string fileName in listLocalFile)
            {
                try
                {
                    if (dicShardFile.ContainsKey(fileName) == true)
                    {
                        //本地的这个文件还分享着,没有问题,或许应该只有分享图片
                        continue;
                    }

                    //检测本地设备文件,是否存在已经取消了共享了的
                    if (fileName.StartsWith("Device_") == true)
                    {
                        //判断是否还在分享的bin文件里面
                        if (listShardDeviceFile.Contains(fileName) == false)
                        {
                            //删除掉这个设备文件
                            HdlFileLogic.Current.DeleteFile(Path.Combine(localPath, fileName));
                            dicUpdateTime.Remove(fileName);
                        }
                    }
                    //检测本地房间文件,是否存在已经取消了共享了的
                    else if (fileName.StartsWith("Room_") == true)
                    {
                        var fullFile = Path.Combine(localPath, fileName);
                        var roomData = HdlFileLogic.Current.ReadFileTextContent(fullFile);
                        if (roomData != null)
                        {
                            var nowRoom = Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(roomData);
                            if (nowRoom.IsSharedRoom == false || this.DicRooms.ContainsKey(nowRoom.Id) == true)
                            {
                                //这个房间是他自己创建的,或者还在分享着
                                continue;
                            }
                            //删除掉这个房间文件
                            HdlFileLogic.Current.DeleteFile(fullFile);
                            dicUpdateTime.Remove(fileName);
                        }
                    }
                    //检测本地场景文件,是否存在已经取消了共享了的
                    else if (fileName.StartsWith("Scene_") == true)
                    {
                        var fullFile = Path.Combine(localPath, fileName);
                        var sceneData = HdlFileLogic.Current.ReadFileTextContent(fullFile);
                        var nowScene = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(sceneData);
                        if (nowScene != null)
                        {
                            if (nowScene.IsSharedScene == false || this.DicScenes.ContainsKey(nowScene.Id) == true)
                            {
                                //这个场景是他自己创建的,或者还在分享着
                                continue;
                            }
                            //删除掉这个场景文件
                            HdlFileLogic.Current.DeleteFile(fullFile);
                            dicUpdateTime.Remove(fileName);
                        }
                    }
                }
                catch { }
            }

            //保存楼层数据
            Config.Instance.Home.Save(false);

            //网关文件非合法性是刷新设备列表的函数里面实现

            //保存全部分享文件的更新日期
            this.SaveAllShardFileAgoUpdateTime(dicUpdateTime);
            //关闭
            ProgressFormBar.Current.Close();

            //释放缓存
            this.Dispone();

            return true;
        }

        #endregion

        #region ■ 同步内容更新时间___________________

        /// <summary>
        /// 获取全部分享文件的前回更新日期
        /// </summary>
        /// <returns></returns>
        private Dictionary<string, string> GetAllShardFileAgoUpdateTime()
        {
            var dicTime = new Dictionary<string, string>();
            var data = HdlFileLogic.Current.ReadFileByteContent(HdlFileNameResourse.ShardFileUpdateTimeFile);
            if (data == null)
            {
                //目标文件不存在
                return dicTime;
            }
            dicTime = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, string>>(System.Text.Encoding.UTF8.GetString(data));
            return dicTime;
        }

        /// <summary>
        /// 保存全部分享文件的更新日期
        /// </summary>
        /// <param name="dicTime"></param>
        private void SaveAllShardFileAgoUpdateTime(Dictionary<string, string> dicTime)
        {
            HdlFileLogic.Current.SaveFileContent(HdlFileNameResourse.ShardFileUpdateTimeFile, dicTime);
        }

        #endregion

        #region ■ 获取分享数据列表___________________

        /// <summary>
        /// 从云端获取分享的文件列表
        /// </summary>
        /// <param name="i_childAccountId">账号的id,成员登陆的话,直接传账号密码登陆之后,云端返回的那个id</param>
        /// <returns></returns>
        private List<ReceiveShardInfoResult> GetShardFileListFromDb(string i_childAccountId)
        {
            //获取主人分享给成员的文件列表
            var pra = new { homeId = Config.Instance.HomeId, childAccountId = i_childAccountId };
            var result = HdlHttpLogic.Current.RequestResponseFromZigbeeHttps("home-wisdom/home/share/findAll", RestSharp.Method.POST, pra, null, null, CheckMode.A账号权限);
            //检测状态码
            if (HdlCheckLogic.Current.CheckNetCode(result, ShowNetCodeMode.YES) == false)
            {
                return null;
            }
            var listShardInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<List<ReceiveShardInfoResult>>(result.Data.ToString());

            return listShardInfo;
        }

        /// <summary>
        /// 将分享的数据存入本地,返回的是文件名字(异常时返回null)
        /// </summary>
        /// <param name="dicFileKeys">key:文件的主键 value:文件名称</param>
        /// <returns></returns>
        private List<string> SetShardFileToLocation(Dictionary<string, string> dicFileKeys)
        {
            if (dicFileKeys.Count == 0)
            {
                return new List<string>();
            }
            //创建文件夹
            string strDir = HdlFileNameResourse.DownLoadShardDirectory;
            HdlFileLogic.Current.CreateDirectory(strDir, true);

            int listMarkCount = dicFileKeys.Count;

            List<string> listFile = new List<string>();

            //不允许按系统的返回键
            Config.Instance.BackKeyCanClick = false;
            HdlUserCenterResourse.AccountOption.AppCanSignout = false;

            //计数
            int nowCount = 0;
            foreach (var fileKey in dicFileKeys.Keys)
            {
                nowCount++;
                var pra = new { homeId = Config.Instance.Home.Id, homeShareId = fileKey };
                var result = HdlHttpLogic.Current.RequestByteFromZigbeeHttps("home-wisdom/home/share/downOne", RestSharp.Method.POST, pra, null, null, CheckMode.A账号权限, true, 10);
                //检测状态码
                if (result == null)
                {
                    //允许按系统的返回键
                    Config.Instance.BackKeyCanClick = true;
                    HdlUserCenterResourse.AccountOption.AppCanSignout = true;
                    return null;
                }
                string shareName = dicFileKeys[fileKey];
                //文件名字
                listFile.Add(shareName);
                //保存到指定文件夹下
                HdlFileLogic.Current.SaveByteToFile(System.IO.Path.Combine(strDir, shareName), result);
                //设置进度值
                ProgressFormBar.Current.SetValue(nowCount, listMarkCount);
            }

            //允许按系统的返回键
            Config.Instance.BackKeyCanClick = true;
            HdlUserCenterResourse.AccountOption.AppCanSignout = true;

            return listFile;
        }

        #endregion


        #region ■ 初始化成员分享数据_________________

        /// <summary>
        /// 初始化成员共享列表然后保存到本地
        /// </summary>
        /// <param name="i_ChildAccountId">成员ID</param>
        /// <returns></returns>
        public bool InitMemberShardContentListAndSetToLocation(string i_ChildAccountId)
        {
            if (DicDevices != null)
            {
                //已经获取了,则不再获取
                return true;
            }

            //正在获取分享数据
            ProgressFormBar.Current.Start();
            ProgressFormBar.Current.SetMsg(Language.StringByID(R.MyInternationalizationString.uShardContentGetting));

            //从云端获取分享的文件列表
            var listData = this.GetShardFileListFromDb(i_ChildAccountId);
            if (listData == null)
            {
                //关闭进度条
                ProgressFormBar.Current.Close();
                return false;
            }

            //分享的压缩文件的主键
            string shardBinKey = string.Empty;
            foreach (var data in listData)
            {
                //如果是这个压缩文件
                if (data.FileName == SHARED_BIN_FILE)
                {
                    shardBinKey = data.Id;
                }
                //记录起它们的主键
                this.DicShardKeys[data.FileName] = data.Id;
            }

            //下载压缩的bin文件,然后进行解析,其他文件不用理会
            bool result = this.DownloadBinFileAndAdjust(shardBinKey);
            //关闭进度条
            ProgressFormBar.Current.Close();

            return result;
        }

        /// <summary>
        /// 下载压缩的bin文件,然后进行解析
        /// </summary>
        /// <param name="i_binFileId">压缩文件的主键</param>
        /// <returns></returns>
        private bool DownloadBinFileAndAdjust(string i_binFileId)
        {
            if (i_binFileId == string.Empty)
            {
                //不要忘记要初始化这个东西
                this.DicDevices = new Dictionary<string, CommonDevice>();
                return true;
            }
            var pra = new { homeId = Config.Instance.Home.Id, homeShareId = i_binFileId };
            var result = HdlHttpLogic.Current.RequestByteFromZigbeeHttps("home-wisdom/home/share/downOne", RestSharp.Method.POST, pra, null, null, CheckMode.A账号权限, true, 10);
            //检测状态码
            if (result == null)
            {
                return false;
            }
            //不要忘记要初始化这个东西
            this.DicDevices = new Dictionary<string, CommonDevice>();

            //直接飙到100%
            ProgressFormBar.Current.SetValue(1);

            var fileContent = Encoding.UTF8.GetString(result);
            //解析压缩的bin文件
            this.AdjustBinFileContent(fileContent);

            return true;
        }

        /// <summary>
        /// 解析压缩的bin文件
        /// </summary>
        /// <param name="i_content"></param>
        private void AdjustBinFileContent(string i_content)
        {
            var deviceType = string.Empty;

            //根据换行符切分数据文本
            string[] arryData = i_content.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
            string strContentData = string.Empty;
            foreach (string strData in arryData)
            {
                if (strData == "#START#")
                {
                    //无附加数据的【数据标题】
                    continue;
                }
                if (strData.StartsWith("#DeviceInfo START#") == true)
                {
                    //附加数据:设备对象类型
                    deviceType = strData.Substring(18);
                    continue;
                }
                //执行数据处理
                try
                {
                    //场景对象
                    if (strData == "#Scene END#")
                    {
                        var scene = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(strContentData);
                        this.DicScenes[scene.Id] = scene;

                        strContentData = string.Empty;
                        continue;
                    }
                    //楼层对象
                    else if (strData == "#FloorInfo END#")
                    {
                        this.DicFloor = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, string>>(strContentData);

                        strContentData = string.Empty;
                        continue;
                    }
                    //房间对象
                    else if (strData == "#RoomInfo END#")
                    {
                        var room = Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(strContentData);
                        this.DicRooms[room.Id] = room;

                        strContentData = string.Empty;
                        continue;
                    }
                    //设备对象
                    else if (strData == "#DeviceInfo END#")
                    {
                        //反序列化设备
                        CommonDevice device = null;
                        if (HdlCheckLogic.Current.CheckIsNumber(deviceType) == true)
                        {
                            //数值型为新数据,直接转换
                            device = CommonDevice.CommonDeviceByByteString(Convert.ToInt32(deviceType), strContentData);
                        }
                        else
                        {
                            //字符串型为旧数据,需要特殊处理
                            var myType = (DeviceType)Enum.Parse(typeof(DeviceType), deviceType);
                            device = CommonDevice.CommonDeviceByByteString((int)myType, strContentData);
                        }
                        if (device != null)
                        {
                            this.DicDevices[HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device)] = device;
                        }
                        strContentData = string.Empty;
                        continue;
                    }
                    else
                    {
                        strContentData += strData;
                    }
                }
                catch (Exception ex)
                {
                    HdlLogLogic.Current.WriteLog(ex, "分享bin文件出问题\r\n" + strContentData);
                    strContentData = string.Empty;
                }
            }
        }

        #endregion


        #region ■ 上传分享内容_______________________

        /// <summary>
        /// 执行上传新的分享(设备和场景仅限同一个房间)
        /// </summary>
        /// <param name="i_ChildAccountId">成员的ID</param>
        /// <param name="i_nowRoom">指定的房间</param>
        /// <param name="i_listDevice">选择上传的设备(仅限一个房间)</param>
        /// <param name="i_listScene">选择上传的场景(仅限一个房间,不要获取它里面的绑定列表)</param>
        public bool UploadSharedContent(string i_ChildAccountId, Room i_nowRoom, List<CommonDevice> i_listDevice, List<SceneUI> i_listScene)
        {
            if (i_listDevice.Count == 0 && i_listScene.Count == 0)
            {
                return true;
            }
            //打开进度条
            ProgressBar.Show();

            var listCheck = new HashSet<string>();

            //获取场景里面嵌套的子设备和子场景(这几个东西不加到房间)
            var listChirdDevice = new List<CommonDevice>();
            var listChirdScene = new List<SceneUI>();
            foreach (var SceneTemp in i_listScene)
            {
                //从缓存获取场景的执行目标
                this.GetSceneAdjustTargetListFromLocal(SceneTemp, listCheck, listChirdScene, listChirdDevice);
            }
            //克隆一个房间出来
            var cloneRoom = HdlRoomLogic.Current.CloneRoomClass(i_nowRoom);
            if (this.DicRooms.ContainsKey(cloneRoom.Id) == true)
            {
                //把原来的的东西也复制过来
                cloneRoom.ListDevice.AddRange(this.DicRooms[cloneRoom.Id].ListDevice);
                cloneRoom.ListDeviceMac.AddRange(this.DicRooms[cloneRoom.Id].ListDeviceMac);
                cloneRoom.ListSceneId.AddRange(this.DicRooms[cloneRoom.Id].ListSceneId);
            }
            else
            {
                //这里有点特殊,如果不存在的话,把真实设备的区域丢过去,因为只是主键而已
                cloneRoom.ListDeviceMac.AddRange(i_nowRoom.ListDeviceMac);
            }
            //然后把场景和设备丢到这个克隆的对象里面去
            foreach (var device in i_listDevice)
            {
                string mainKey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
                if (cloneRoom.ListDevice.Contains(mainKey) == false)
                {
                    //丢设备过去
                    cloneRoom.ListDevice.Add(mainKey);
                }
            }
            foreach (var secne in i_listScene)
            {
                if (cloneRoom.ListSceneId.Contains(secne.Id) == false)
                {
                    //丢场景过去
                    cloneRoom.ListSceneId.Add(secne.Id);
                }
            }
            //获取需要上传的图片
            var listUploadPic = this.GetUploadPictrueFile(new List<Room> { cloneRoom }, i_listScene, listChirdScene);
            //生成分享Bin文件内容
            var binfFileContent = this.CreatShardBinContentOnAdd(new List<Room> { cloneRoom }, i_listDevice, i_listScene, listChirdDevice, listChirdScene);

            //设置最大值
            ProgressBar.SetMaxValue(listUploadPic.Count + 1);

            //上传bin文件
            var fileKey = this.DoUploadShardContent(i_ChildAccountId, SHARED_BIN_FILE, Encoding.UTF8.GetBytes(binfFileContent));
            if (fileKey == null)
            {
                ProgressBar.Close();
                return false;
            }
            ProgressBar.SetValue(1);

            //记录主键
            this.DicShardKeys[SHARED_BIN_FILE] = fileKey;
            binfFileContent = null;

            //上传图片
            foreach (var fileName in listUploadPic)
            {
                var byteData = HdlFileLogic.Current.ReadFileByteContent(Path.Combine(Config.Instance.FullPath, fileName));
                if (byteData != null)
                {
                    fileKey = this.DoUploadShardContent(i_ChildAccountId, fileName, byteData);
                    if (fileKey == null)
                    {
                        ProgressBar.Close();
                        return false;
                    }
                    //记录主键
                    this.DicShardKeys[SHARED_BIN_FILE] = fileKey;
                }
                ProgressBar.SetValue(1);
            }
            //如果全部成功了的话,覆盖缓存
            this.DicDevices.Clear();
            this.DicScenes.Clear();
            this.DicRooms.Clear();
            this.DicFloor.Clear();
            this.AdjustBinFileContent(binfFileContent);

            //删除已经不再分享的图片
            this.DeleteNotShardPictrue();

            ProgressBar.Close();

            return true;
        }

        /// <summary>
        /// 执行上传新的分享房间(整个房间分享)
        /// </summary>
        /// <param name="i_ChildAccountId">成员的ID</param>
        /// <param name="i_listRoom">需要分享的房间</param>
        public bool UploadSharedRoom(string i_ChildAccountId, List<Room> i_listRoom)
        {
            //打开进度条
            ProgressBar.Show();

            //让设备和场景不重复的东西
            var listCheck = new HashSet<string>();
            //克隆房间
            var listCloneRoom = new List<Room>();
            //添加的设备
            var listDevice = new List<CommonDevice>();
            //添加的场景
            var listScene = new List<SceneUI>();

            foreach (var room in i_listRoom)
            {
                //克隆一个房间出来
                var cloneRoom = HdlRoomLogic.Current.CloneRoomClass(room);
                if (this.DicRooms.ContainsKey(cloneRoom.Id) == true)
                {
                    //把原来的的东西也复制过来
                    cloneRoom.ListDevice.AddRange(this.DicRooms[cloneRoom.Id].ListDevice);
                    cloneRoom.ListDeviceMac.AddRange(this.DicRooms[cloneRoom.Id].ListDeviceMac);
                    cloneRoom.ListSceneId.AddRange(this.DicRooms[cloneRoom.Id].ListSceneId);
                }
                else
                {
                    //这里有点特殊,如果不存在的话,把真实设备的区域丢过去,因为只是主键而已
                    cloneRoom.ListDeviceMac.AddRange(room.ListDeviceMac);
                }
                listCloneRoom.Add(cloneRoom);

                //获取设备对象
                foreach (var mainkey in cloneRoom.ListDevice)
                {
                    var device = HdlDeviceCommonLogic.Current.GetDevice(mainkey);
                    if (device != null)
                    {
                        listDevice.Add(device);
                    }
                    listCheck.Add(mainkey);
                }
                //获取场景对象
                foreach (var sceneId in cloneRoom.ListSceneId)
                {
                    var scene = HdlSceneLogic.Current.GetSceneUIBySceneId(sceneId);
                    if (scene != null)
                    {
                        listScene.Add(scene);
                    }
                    listCheck.Add(sceneId.ToString());
                    //从缓存获取场景的执行目标
                    this.GetSceneAdjustTargetListFromLocal(scene, listCheck, listScene, listDevice);
                }
            }

            //获取需要上传的图片
            var listUploadPic = this.GetUploadPictrueFile(listCloneRoom, listScene, new List<SceneUI>());
            //生成分享Bin文件内容
            var binfFileContent = this.CreatShardBinContentOnAdd(listCloneRoom, listDevice, listScene, new List<CommonDevice>(), new List<SceneUI>());

            //设置最大值
            ProgressBar.SetMaxValue(listUploadPic.Count + 1);

            //上传bin文件
            var fileKey = this.DoUploadShardContent(i_ChildAccountId, SHARED_BIN_FILE, Encoding.UTF8.GetBytes(binfFileContent));
            if (fileKey == null)
            {
                ProgressBar.Close();
                return false;
            }
            ProgressBar.SetValue(1);

            //记录主键
            this.DicShardKeys[SHARED_BIN_FILE] = fileKey;
            binfFileContent = null;

            //上传图片
            foreach (var fileName in listUploadPic)
            {
                var byteData = HdlFileLogic.Current.ReadFileByteContent(Path.Combine(Config.Instance.FullPath, fileName));
                if (byteData != null)
                {
                    fileKey = this.DoUploadShardContent(i_ChildAccountId, fileName, byteData);
                    if (fileKey == null)
                    {
                        ProgressBar.Close();
                        return false;
                    }
                    //记录主键
                    this.DicShardKeys[SHARED_BIN_FILE] = fileKey;
                }
                ProgressBar.SetValue(1);
            }
            //如果全部成功了的话,覆盖缓存
            this.DicDevices.Clear();
            this.DicScenes.Clear();
            this.DicRooms.Clear();
            this.DicFloor.Clear();
            this.AdjustBinFileContent(binfFileContent);

            //删除已经不再分享的图片
            this.DeleteNotShardPictrue();

            ProgressBar.Close();

            return true;
        }

        /// <summary>
        /// 删除已经不再分享的图片(不用管返回值,即使失败也没事)
        /// </summary>
        private void DeleteNotShardPictrue()
        {
            var listPictrue = new List<string>();
            foreach (var room in this.DicRooms.Values)
            {
                if (room.BackgroundImageType != 0)
                {
                    //房间图片
                    listPictrue.Add(room.BackgroundImage);
                }
            }
            foreach (var scene in this.DicScenes.Values)
            {
                if (scene.IconPathType != 0)
                {
                    //场景图片
                    listPictrue.Add(scene.IconPath);
                }
            }
            var listDeleteFile = new List<string>();
            foreach (var fileName in this.DicShardKeys.Keys)
            {
                //如果是房间或者场景的图片
                if (fileName.StartsWith("RoomIcon_") == true || fileName.StartsWith("SceneIcon_") == true)
                {
                    if (listPictrue.Contains(fileName) == false)
                    {
                        //这个图片变更了,需要删除掉
                        listDeleteFile.Add(fileName);
                    }
                }
            }
            //删除图片
            this.DoDeleteSharedContent(listDeleteFile, ShowNetCodeMode.No);
        }

        /// <summary>
        /// 上传分享内容(返回主键)
        /// </summary>
        /// <param name="i_childAccountId">子账号的主键</param>
        /// <param name="i_fileName">文件名字</param>
        /// <param name="i_content">文件内容</param>
        /// <returns></returns>
        private string DoUploadShardContent(string i_childAccountId, string i_fileName, byte[] i_content)
        {
            var dicQuery = new Dictionary<string, object>();
            dicQuery["homeId"] = Config.Instance.Home.Id;
            dicQuery["childAccountId"] = i_childAccountId;
            dicQuery["fileName"] = i_fileName;

            var result = HdlHttpLogic.Current.RequestResponseFromZigbeeHttps("home-wisdom/home/share/add", RestSharp.Method.POST, i_content, dicQuery, null, CheckMode.A账号权限, true, 10);
            //检测状态码
            if (HdlCheckLogic.Current.CheckNetCode(result, ShowNetCodeMode.YES) == false)
            {
                return null;
            }
            var info = Newtonsoft.Json.JsonConvert.DeserializeObject<ReceiveShardInfoResult>(result.Data.ToString());
            return info.Id;
        }

        #endregion

        #region ■ 上传分享内容辅助方法_______________

        /// <summary>
        /// 从本地获取场景里面的执行目标列表
        /// </summary>
        /// <param name="scene">场景</param>
        /// <param name="listCheck">重复检测用</param>
        /// <param name="listSceneUI">添加分享的场景列表</param>
        /// <param name="listDevice">添加分享的设备列表</param>
        /// <returns></returns>
        private void GetSceneAdjustTargetListFromLocal(SceneUI scene, HashSet<string> listCheck, List<SceneUI> listSceneUI, List<CommonDevice> listDevice)
        {
            foreach (var data in scene.AdjustTargetList)
            {
                //设备
                if (data.Type == 0)
                {
                    string mainKeys = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(data.DeviceAddr, data.Epoint);
                    if (listCheck.Contains(mainKeys) == true)
                    {
                        //不重复添加
                        continue;
                    }
                    listCheck.Add(mainKeys);

                    var device = HdlDeviceCommonLogic.Current.GetDevice(data.DeviceAddr, data.Epoint);
                    if (device != null)
                    {
                        listDevice.Add(device);
                    }
                }
                //场景
                else if (data.Type == 1)
                {
                    string mainKeys = data.ElseScenesId.ToString();
                    if (listCheck.Contains(mainKeys) == true)
                    {
                        //不重复添加
                        continue;
                    }
                    listCheck.Add(mainKeys);

                    //获取场景对象
                    var sceneUi = HdlSceneLogic.Current.GetSceneUIBySceneId(data.ElseScenesId);
                    if (sceneUi != null)
                    {
                        listSceneUI.Add(sceneUi);
                        //递归获取执行目标
                        this.GetSceneAdjustTargetListFromLocal(sceneUi, listCheck, listSceneUI, listDevice);
                    }
                }
            }
        }

        /// <summary>
        /// 获取需要上传的图片名字
        /// </summary>
        /// <param name="i_listRoom">房间对象</param>
        /// <param name="i_listScene">场景对象</param>
        /// <param name="i_listChirdScene">场景对象</param>
        /// <returns></returns>
        private List<string> GetUploadPictrueFile(List<Room> i_listRoom, List<SceneUI> i_listScene, List<SceneUI> i_listChirdScene)
        {
            var listPic = new List<string>();
            foreach (var room in i_listRoom)
            {
                if (room.BackgroundImageType != 0 && this.DicShardKeys.ContainsKey(room.BackgroundImage) == false)
                {
                    //自定义图片
                    listPic.Add(room.BackgroundImage);
                }
            }
            foreach (var scene in i_listScene)
            {
                if (scene.IconPathType != 0 && this.DicShardKeys.ContainsKey(scene.IconPath) == false)
                {
                    //自定义图片
                    listPic.Add(scene.IconPath);
                }
            }
            foreach (var scene in i_listChirdScene)
            {
                if (scene.IconPathType != 0 && this.DicShardKeys.ContainsKey(scene.IconPath) == false)
                {
                    //自定义图片
                    listPic.Add(scene.IconPath);
                }
            }
            return listPic;
        }

        #endregion


        #region ■ 删除分享内容_______________________

        /// <summary>
        /// 移除指定分享内容(设备和场景仅限同一个房间)
        /// </summary>
        /// <param name="i_ChildAccountId">成员ID</param>
        /// <param name="i_nowRoom">指定的房间</param>
        /// <param name="i_listDevice">选择上传的设备(仅限一个房间)</param>
        /// <param name="i_listScene">选择上传的场景(仅限一个房间,不要获取它里面的绑定列表)</param>
        /// <returns></returns>
        public bool DeleteSharedContent(string i_ChildAccountId, Room i_nowRoom,
            List<CommonDevice> i_listDevice, List<SceneUI> i_listScene)
        {
            //克隆一个房间出来
            var cloneRoom = HdlRoomLogic.Current.CloneRoomClass(i_nowRoom);
            if (this.DicRooms.ContainsKey(cloneRoom.Id) == true)
            {
                //把原来的的东西也复制过来
                cloneRoom.ListDevice.AddRange(this.DicRooms[cloneRoom.Id].ListDevice);
                cloneRoom.ListDeviceMac.AddRange(this.DicRooms[cloneRoom.Id].ListDeviceMac);
                cloneRoom.ListSceneId.AddRange(this.DicRooms[cloneRoom.Id].ListSceneId);
            }

            //让设备和场景不重复添加的东西
            var listCheck = new HashSet<string>();

            //然后把场景和设备从这个克隆的对象里面移除掉(真实物理设备的房间不用理)
            foreach (var device in i_listDevice)
            {
                string mainKey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
                cloneRoom.ListDevice.Remove(mainKey);

                listCheck.Add(mainKey);
            }
            foreach (var secne in i_listScene)
            {
                cloneRoom.ListSceneId.Remove(secne.Id);

                listCheck.Add(secne.Id.ToString());
            }
            //如果都移除完的话,则直接走删除分享房间的方法
            if (cloneRoom.ListDevice.Count == 0 && cloneRoom.ListSceneId.Count == 0)
            {
                //执行整个房间删除的方法
                return this.DeleteSharedRoom(i_ChildAccountId, new List<Room> { i_nowRoom });
            }
            //获取场景里面嵌套的子设备和子场景
            foreach (var sceneTemp in i_listScene)
            {
                //从缓存获取场景的执行目标
                this.GetSceneAdjustTargetListFromShard(sceneTemp, listCheck, i_listScene, i_listDevice);
            }
            //在删除一个房间中的一些设备的模式下,检测设备和场景是否能够删除(有可能它还在别的房间或者场景当中)
            var listDelDevice = new List<CommonDevice>();
            var listDelScene = new List<SceneUI>();
            this.CheckDeviceAndSceneCanDeleteOnDeleteSome(i_listDevice, i_listScene, ref listDelDevice, ref listDelScene, cloneRoom);

            //生成分享Bin文件内容(这里不用删除房间)
            var binfFileContent = this.CreatShardBinContentOnDelete(new List<Room>(), listDelDevice, listDelScene);

            //上传bin文件
            var fileKey = this.DoUploadShardContent(i_ChildAccountId, SHARED_BIN_FILE, Encoding.UTF8.GetBytes(binfFileContent));
            if (fileKey == null)
            {
                ProgressBar.Close();
                return false;
            }
            ProgressBar.SetValue(1);

            //记录主键
            this.DicShardKeys[SHARED_BIN_FILE] = fileKey;
            binfFileContent = null;

            //如果全部成功了的话,覆盖缓存
            this.DicDevices.Clear();
            this.DicScenes.Clear();
            this.DicRooms.Clear();
            this.DicFloor.Clear();
            this.AdjustBinFileContent(binfFileContent);

            //删除已经不再分享的图片
            this.DeleteNotShardPictrue();

            ProgressBar.Close();

            return true;
        }

        /// <summary>
        /// 移除指定分享内容(整个房间删除)
        /// </summary>
        /// <param name="i_ChildAccountId">成员ID</param>
        /// <param name="i_listRoom">需要整个删除的房间</param>
        /// <returns></returns>
        public bool DeleteSharedRoom(string i_ChildAccountId, List<Room> i_listRoom)
        {
            //打开进度条
            ProgressBar.Show();
            //设置最大值
            ProgressBar.SetMaxValue(1);

            //获取删除房间的全部全部设备和场景
            var listDevice = new List<CommonDevice>();
            var listScene = new List<SceneUI>();
            this.GetDeleteRoomAllDeviceAndScene(i_listRoom, ref listDevice, ref listScene);

            //删除的房间ID
            var listDeleteRoom = new List<string>();
            foreach (var room in i_listRoom)
            {
                //判断场景和设备是否能删除时使用
                listDeleteRoom.Add(room.Id);
            }
            //在删除整个房间的模式下,检测设备和场景是否能够删除(有可能它还在别的房间或者场景当中)
            var listDelDevice = new List<CommonDevice>();
            var listDelScene = new List<SceneUI>();
            this.CheckDeviceAndSceneCanDeleteOnDeleteRoom(listDevice, listScene, ref listDelDevice, ref listDelScene, listDeleteRoom);

            //生成分享Bin文件内容
            var binfFileContent = this.CreatShardBinContentOnDelete(i_listRoom, listDelDevice, listDelScene);

            //上传bin文件
            var fileKey = this.DoUploadShardContent(i_ChildAccountId, SHARED_BIN_FILE, Encoding.UTF8.GetBytes(binfFileContent));
            if (fileKey == null)
            {
                ProgressBar.Close();
                return false;
            }
            ProgressBar.SetValue(1);

            //记录主键
            this.DicShardKeys[SHARED_BIN_FILE] = fileKey;
            binfFileContent = null;

            //如果全部成功了的话,覆盖缓存
            this.DicDevices.Clear();
            this.DicScenes.Clear();
            this.DicRooms.Clear();
            this.DicFloor.Clear();
            this.AdjustBinFileContent(binfFileContent);

            //删除已经不再分享的图片
            this.DeleteNotShardPictrue();

            ProgressBar.Close();

            return true;
        }

        /// <summary>
        /// 执行移除分享数据
        /// </summary>
        /// <param name="listDelFile">删除的文件</param>
        /// <param name="mode">失败时是否显示tip消息</param>
        /// <returns></returns>
        private bool DoDeleteSharedContent(List<string> listDelFile, ShowNetCodeMode mode = ShowNetCodeMode.YES)
        {
            if (listDelFile.Count == 0)
            {
                return true;
            }
            foreach (var fileName in listDelFile)
            {
                if (this.DicShardKeys.ContainsKey(fileName) == false)
                {
                    //我也不知道为什么会找不到主键
                    continue;
                }
                var pra = new { homeId = Config.Instance.Home.Id, homeShareId = this.DicShardKeys[fileName] };
                //执行删除
                var result = HdlHttpLogic.Current.RequestResponseFromZigbeeHttps("home-wisdom/home/share/delete", RestSharp.Method.POST, pra, null, null, CheckMode.A账号权限);
                //检测状态码
                if (HdlCheckLogic.Current.CheckNetCode(result, mode) == false)
                {
                    return false;
                }
                //移除缓存
                this.DicShardKeys.Remove(fileName);
            }
            return true;
        }

        #endregion

        #region ■ 删除分享内容辅助方法_______________

        /// <summary>
        /// 获取删除房间的全部全部设备和场景
        /// </summary>
        /// <param name="i_listRoom">删除的房间</param>
        /// <param name="listDevice">全部设备(返回值)</param>
        /// <param name="listScene">全部场景(返回值)</param>
        private void GetDeleteRoomAllDeviceAndScene(List<Room> i_listRoom, ref List<CommonDevice> listDevice, ref List<SceneUI> listScene)
        {
            var listCheck = new HashSet<string>();
            foreach (var room in i_listRoom)
            {
                //获取设备
                foreach (var mainkey in room.ListDevice)
                {
                    if (listCheck.Contains(mainkey) == true) { continue; }
                    listCheck.Add(mainkey);

                    //分享数据里面有才添加
                    if (this.DicDevices.ContainsKey(mainkey) == true)
                    {
                        listDevice.Add(this.DicDevices[mainkey]);
                    }
                }
                //然后再获取场景
                foreach (var sceneId in room.ListSceneId)
                {
                    if (listCheck.Contains(sceneId.ToString()) == true) { continue; }
                    listCheck.Add(sceneId.ToString());

                    //分享数据里面有才添加
                    if (this.DicScenes.ContainsKey(sceneId) == true)
                    {
                        var sceneTemp = this.DicScenes[sceneId];
                        listScene.Add(sceneTemp);

                        //获取场景里面嵌套的子设备和子场景
                        this.GetSceneAdjustTargetListFromShard(sceneTemp, listCheck, listScene, listDevice);
                    }
                }
            }
        }

        /// <summary>
        /// 在删除整个房间的模式下,检测设备和场景是否能够删除(有可能它还在别的房间或者场景当中)
        /// </summary>
        /// <param name="i_listDevice">理论上要删除的设备</param>
        /// <param name="i_listScene">理论上要删除的场景</param>
        /// <param name="listDeleteDevice">真实能够删除的设备(返回值)</param>
        /// <param name="listDeleteScene">真实能够删除的场景(返回值)</param>
        /// <param name="i_listDelleteRoom">删除的房间</param>
        private void CheckDeviceAndSceneCanDeleteOnDeleteRoom(List<CommonDevice> i_listDevice, List<SceneUI> i_listScene,
            ref List<CommonDevice> listDeleteDevice, ref List<SceneUI> listDeleteScene, List<string> i_listNotCheckRoom)
        {
            //注意：这个函数和下面的CheckDeviceAndSceneCanDeleteOnDeleteSome有本质区别
            //这个只是完全删除一个房间内的设备或者场景,因此只需要去判断删除以外的就可以了

            //获取理论上需要删除的场景ID
            var listSceneId = new List<int>();
            foreach (var scene in i_listScene)
            {
                listSceneId.Add(scene.Id);
            }
            var listShardDevice = new HashSet<string>();
            var listShardScene = new HashSet<int>();
            //获取除了理论上需要删除的场景之外，目前还分享的场景的执行目标里面的设备
            foreach (var scene in this.DicScenes.Values)
            {
                //这个是要删除的场景
                if (listSceneId.Contains(scene.Id) == true) { continue; }

                foreach (var data in scene.AdjustTargetList)
                {
                    //设备
                    if (data.Type == 0)
                    {
                        var mainkey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(data.DeviceAddr, data.Epoint);
                        if (listShardDevice.Contains(mainkey) == false)
                        {
                            listShardDevice.Add(mainkey);
                        }
                    }
                    //子场景
                    else if (data.Type == 1)
                    {
                        if (listShardScene.Contains(data.ElseScenesId) == false)
                        {
                            listShardScene.Add(data.ElseScenesId);
                        }
                    }
                }
            }
            //获取除了理论上需要删除的房间之外，目前还分享的设备
            foreach (var room in this.DicRooms.Values)
            {
                //这个是要删除的房间
                if (i_listNotCheckRoom.Contains(room.Id) == true) { continue; }

                foreach (var mainkey in room.ListDevice)
                {
                    if (listShardDevice.Contains(mainkey) == false)
                    {
                        listShardDevice.Add(mainkey);
                    }
                }
                foreach (var sceneId in room.ListSceneId)
                {
                    if (listShardScene.Contains(sceneId) == false)
                    {
                        listShardScene.Add(sceneId);
                    }
                }
            }

            //判断实际能够删除的设备
            foreach (var device in i_listDevice)
            {
                var mainkey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
                if (listShardDevice.Contains(mainkey) == false)
                {
                    //这个设备已经不在分享
                    listDeleteDevice.Add(device);
                }
            }
            //判断实际能够删除的场景
            foreach (var scene in i_listScene)
            {
                if (listShardScene.Contains(scene.Id) == false)
                {
                    //这个场景已经不在分享
                    listDeleteScene.Add(scene);
                }
            }
        }

        /// <summary>
        /// 在删除一个房间中的一些设备的模式下,检测设备和场景是否能够删除(有可能它还在别的房间或者场景当中)
        /// </summary>
        /// <param name="i_listDevice">理论上要删除的设备</param>
        /// <param name="i_listScene">理论上要删除的场景</param>
        /// <param name="listDeleteDevice">真实能够删除的设备(返回值)</param>
        /// <param name="listDeleteScene">真实能够删除的场景(返回值)</param>
        /// <param name="i_nowCloneRoom">当前房间(克隆)</param>
        private void CheckDeviceAndSceneCanDeleteOnDeleteSome(List<CommonDevice> i_listDevice, List<SceneUI> i_listScene,
            ref List<CommonDevice> listDeleteDevice, ref List<SceneUI> listDeleteScene, Room i_nowCloneRoom)
        {
            //注意：这个函数和上面的CheckDeviceAndSceneCanDeleteOnDeleteRoom有本质区别
            //这个只是删除一个房间内的部分设备或者场景,因此它有可能自身就嵌套着要删除的设备或者场景

            //先获取目前还在分享的设备和场景
            var listShardDevice = new HashSet<string>();
            var listShardScene = new HashSet<int>();

            foreach (var roomId in this.DicRooms.Keys)
            {
                //如果是当前克隆的房间,则用克隆的房间来处理,克隆的房间已经把理论上要删除的设备和场景都删除了
                var room = i_nowCloneRoom.Id != roomId ? this.DicRooms[roomId] : i_nowCloneRoom;
                //还在分享的设备
                foreach (var mainkey in room.ListDevice)
                {
                    if (listShardDevice.Contains(mainkey) == false)
                    {
                        listShardDevice.Add(mainkey);
                    }
                }
                //还在分享的场景
                foreach (var sceneId in room.ListSceneId)
                {
                    if (listShardScene.Contains(sceneId) == false)
                    {
                        listShardScene.Add(sceneId);
                    }
                    //从场景的执行目标当前获取
                    if (this.DicScenes.ContainsKey(sceneId) == true)
                    {
                        foreach (var data in this.DicScenes[sceneId].AdjustTargetList)
                        {
                            //子设备
                            if (data.Type == 0)
                            {
                                var mainkey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(data.DeviceAddr, data.Epoint);
                                if (listShardDevice.Contains(mainkey) == false)
                                {
                                    listShardDevice.Add(mainkey);
                                }
                            }
                            //子场景
                            else if (data.Type == 1)
                            {
                                if (listShardScene.Contains(data.ElseScenesId) == false)
                                {
                                    listShardScene.Add(data.ElseScenesId);
                                }
                            }
                        }
                    }
                }
            }
            //判断实际能够删除的设备
            foreach (var device in i_listDevice)
            {
                var mainkey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
                if (listShardDevice.Contains(mainkey) == false)
                {
                    //这个设备已经不在分享
                    listDeleteDevice.Add(device);
                }
            }
            //判断实际能够删除的场景
            foreach (var scene in i_listScene)
            {
                if (listShardScene.Contains(scene.Id) == false)
                {
                    //这个场景已经不在分享
                    listDeleteScene.Add(scene);
                }
            }
        }

        /// <summary>
        /// 从分享数据里面获取场景里面的执行目标列表
        /// </summary>
        /// <param name="scene">场景</param>
        /// <param name="listCheck">重复检测用</param>
        /// <param name="listSceneUI">添加分享的场景列表</param>
        /// <param name="listDevice">添加分享的设备列表</param>
        /// <returns></returns>
        private void GetSceneAdjustTargetListFromShard(SceneUI scene, HashSet<string> listCheck, List<SceneUI> listSceneUI, List<CommonDevice> listDevice)
        {
            foreach (var data in scene.AdjustTargetList)
            {
                //设备
                if (data.Type == 0)
                {
                    string mainKeys = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(data.DeviceAddr, data.Epoint);
                    if (listCheck.Contains(mainKeys) == true)
                    {
                        //不重复添加
                        continue;
                    }
                    listCheck.Add(mainKeys);
                    if (this.DicDevices.ContainsKey(mainKeys) == true)
                    {
                        listDevice.Add(this.DicDevices[mainKeys]);
                    }
                }
                //场景
                else if (data.Type == 1)
                {
                    string mainKeys = data.ElseScenesId.ToString();
                    if (listCheck.Contains(mainKeys) == true)
                    {
                        //不重复添加
                        continue;
                    }
                    listCheck.Add(mainKeys);

                    //获取场景对象
                    if (this.DicScenes.ContainsKey(data.ElseScenesId) == true)
                    {
                        var sceneUi = this.DicScenes[data.ElseScenesId];
                        listSceneUI.Add(sceneUi);

                        //递归获取执行目标
                        this.GetSceneAdjustTargetListFromShard(sceneUi, listCheck, listSceneUI, listDevice);
                    }
                }
            }
        }


        #endregion


        #region ■ 生成分享Bin文件内容________________

        /// <summary>
        /// 生成分享Bin文件内容(新增模式)
        /// </summary>
        /// <param name="i_listNewRoom">新的房间对象集合(也就是变更了的房间)</param>
        /// <param name="i_listDevice">这个是需要追加的分享设备</param>
        /// <param name="i_listScene">这个是需要追加的分享场景</param>
        /// <param name="i_listChirdDevice">这个是由场景的执行目标来的</param>
        /// <param name="i_listChirdScene">这个是由场景的执行目标来的</param>
        /// <returns></returns>
        private string CreatShardBinContentOnAdd(List<Room> i_listNewRoom, List<CommonDevice> i_listDevice, List<SceneUI> i_listScene,
            List<CommonDevice> i_listChirdDevice, List<SceneUI> i_listChirdScene)
        {
            string writeText = string.Empty;
            //生成写入文件的【设备对象数据】
            this.CreatWriteCommonDeviceData(i_listDevice, i_listChirdDevice, false, ref writeText);

            //生成写入文件的【场景数据】
            this.CreatWriteSceneData(i_listScene, i_listChirdScene, false, ref writeText);

            //生成写入文件的【场景数据】
            this.CrearWriteRoomData(i_listNewRoom, false, ref writeText);

            return writeText;
        }

        /// <summary>
        /// 生成分享Bin文件内容(删除模式)
        /// </summary>
        /// <param name="i_listDelRoom">要删除的房间</param>
        /// <param name="i_listDevice">这个是需要删除的分享设备</param>
        /// <param name="i_listScene">这个是需要删除的分享场景</param>
        /// <returns></returns>
        private string CreatShardBinContentOnDelete(List<Room> i_listDelRoom, List<CommonDevice> i_listDevice, List<SceneUI> i_listScene)
        {
            string writeText = string.Empty;
            //生成写入文件的【设备对象数据】
            this.CreatWriteCommonDeviceData(i_listDevice, new List<CommonDevice>(), true, ref writeText);

            //生成写入文件的【场景数据】
            this.CreatWriteSceneData(i_listScene, new List<SceneUI>(), true, ref writeText);

            //生成写入文件的【场景数据】
            this.CrearWriteRoomData(i_listDelRoom, true, ref writeText);

            return writeText;
        }

        /// <summary>
        /// 生成写入文件的【设备对象数据】
        /// </summary>
        /// <param name="writeText"></param>
        private void CreatWriteCommonDeviceData(List<CommonDevice> i_listDevice, List<CommonDevice> i_listChirdDevice, bool i_isDel, ref string writeText)
        {
            //合并设备到一个新的对象当中
            var dicNewDevice = this.MergeNewShardDevices(i_listDevice, i_listChirdDevice, i_isDel);
            var listCheck = new HashSet<string>();
            foreach (var device in dicNewDevice.Values)
            {
                //设备端点
                writeText += "#DeviceInfo START#" + (int)device.Type + "\r\n";
                string dataInfo = Newtonsoft.Json.JsonConvert.SerializeObject(device);
                writeText += dataInfo + "\r\n";
                writeText += "#DeviceInfo END#\r\n\r\n";

                //添加Ota设备对象的缓存
                if (listCheck.Contains(device.DeviceAddr) == false)
                {
                    listCheck.Add(device.DeviceAddr);
                    var otaDevice = HdlDeviceCommonLogic.Current.GetOTADevice(device.DeviceAddr);
                    if (otaDevice != null)
                    {
                        writeText += "#DeviceInfo START#" + (int)otaDevice.Type + "\r\n";
                        string dataInfo2 = Newtonsoft.Json.JsonConvert.SerializeObject(otaDevice);
                        writeText += dataInfo2 + "\r\n";
                        writeText += "#DeviceInfo END#\r\n\r\n";
                    }
                }
            }
        }

        /// <summary>
        /// 生成写入文件的【场景数据】
        /// </summary>
        /// <param name="i_listScene">这个是需要追加的分享场景</param>
        /// <param name="i_listChirdScene">这个是由场景的执行目标来的</param>
        /// <param name="writeText"></param>
        private void CreatWriteSceneData(List<SceneUI> i_listScene, List<SceneUI> i_listChirdScene, bool i_isDel, ref string writeText)
        {
            //合并场景到一个新的对象当中
            var dicNewScene = this.MergeNewShardScenes(i_listScene, i_listChirdScene, i_isDel);

            foreach (var scene in dicNewScene.Values)
            {
                writeText += "#START#\r\n";
                string dataInfo = Newtonsoft.Json.JsonConvert.SerializeObject(scene);
                writeText += dataInfo + "\r\n";
                writeText += "#SceneTemplate END#\r\n\r\n";
            }
        }

        /// <summary>
        /// 生成写入文件的【房间模板数据】
        /// </summary>
        /// <param name="i_listNewRoom">新的房间对象集合(也就是变更了的房间)</param>
        /// <param name="writeText"></param>
        private void CrearWriteRoomData(List<Room> i_listNewRoom, bool i_isDel, ref string writeText)
        {
            var dicNewFloor = new Dictionary<string, string>();
            //合并分享的房间到一个新的对象中
            var dicNewRoom = this.MergeNewShardRooms(i_listNewRoom, i_isDel);
            foreach (var room in dicNewRoom.Values)
            {
                writeText += "#START#\r\n";
                string dataInfo2 = Newtonsoft.Json.JsonConvert.SerializeObject(room);
                writeText += dataInfo2 + "\r\n";
                writeText += "#RoomInfo END#\r\n\r\n";

                if (room.FloorId != string.Empty)
                {
                    dicNewFloor[room.FloorId] = HdlResidenceLogic.Current.GetFloorNameById(room.FloorId);
                }
            }
            //楼层数据
            writeText += "#START#\r\n";
            string dataInfo1 = Newtonsoft.Json.JsonConvert.SerializeObject(dicNewFloor);
            writeText += dataInfo1 + "\r\n";
            writeText += "#FloorInfo END#\r\n\r\n";
        }

        #endregion

        #region ■ 生成分享Bin文件内容辅助方法________

        /// <summary>
        /// 合并分享的设备到一个新的对象中
        /// </summary>
        /// <param name="i_listDevice">这个是需要追加的分享设备</param>
        /// <param name="i_listChirdDevice">这个是由场景的执行目标来的</param>
        /// <param name="i_isDel">是否是删除分享模式</param>
        /// <returns></returns>
        private Dictionary<string, CommonDevice> MergeNewShardDevices(List<CommonDevice> i_listDevice, List<CommonDevice> i_listChirdDevice, bool i_isDel)
        {
            var dicNewDevice = new Dictionary<string, CommonDevice>();
            //先合并原来的
            foreach (var key in this.DicDevices.Keys)
            {
                dicNewDevice[key] = this.DicDevices[key];
            }
            //再合并新添加的
            foreach (var device in i_listDevice)
            {
                string mainkey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
                if (i_isDel == false)
                {
                    //直接覆盖,没问题
                    dicNewDevice[mainkey] = device;
                }
                else
                {
                    //删除模式
                    dicNewDevice.Remove(mainkey);
                }
            }
            foreach (var device in i_listChirdDevice)
            {
                string mainkey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
                //直接覆盖,没问题
                dicNewDevice[mainkey] = device;
            }
            return dicNewDevice;
        }

        /// <summary>
        /// 合并分享的场景到一个新的对象中
        /// </summary>
        /// <param name="i_listScene">这个是需要追加的分享场景</param>
        /// <param name="i_listChirdScene">这个是由场景的执行目标来的</param>
        /// <param name="i_isDel">是否是删除分享模式</param>
        /// <returns></returns>
        private Dictionary<int, SceneUI> MergeNewShardScenes(List<SceneUI> i_listScene, List<SceneUI> i_listChirdScene, bool i_isDel)
        {
            var dicNewScene = new Dictionary<int, SceneUI>();
            //先合并原来的
            foreach (var key in this.DicScenes.Keys)
            {
                dicNewScene[key] = this.DicScenes[key];
            }
            //再合并新添加的
            foreach (var scene in i_listScene)
            {
                if (i_isDel == false)
                {
                    //直接覆盖,没问题
                    dicNewScene[scene.Id] = scene;
                }
                else
                {
                    //删除模式
                    dicNewScene.Remove(scene.Id);
                }
            }
            foreach (var scene in i_listChirdScene)
            {
                //直接覆盖,没问题
                dicNewScene[scene.Id] = scene;
            }
            return dicNewScene;
        }

        /// <summary>
        /// 合并分享的房间到一个新的对象中
        /// </summary>
        /// <param name="i_listNewRoom">新的房间对象集合(也就是变更了的房间)</param>
        /// <param name="i_isDel">是否是删除分享模式</param>
        /// <returns></returns>
        private Dictionary<string, Room> MergeNewShardRooms(List<Room> i_listNewRoom, bool i_isDel)
        {
            var dicNewRoom = new Dictionary<string, Room>();
            //先合并原来的
            foreach (var key in this.DicRooms.Keys)
            {
                dicNewRoom[key] = this.DicRooms[key];
            }
            //再合并新添加的
            foreach (var room in i_listNewRoom)
            {
                if (i_isDel == false)
                {
                    //直接覆盖,没问题
                    dicNewRoom[room.Id] = room;
                }
                else
                {
                    //删除模式
                    dicNewRoom.Remove(room.Id);
                }
            }
            return dicNewRoom;
        }

        #endregion


        #region ■ 获取分享缓存方法___________________

        /// <summary>
        /// 从缓存当中获取分享的设备
        /// </summary>
        /// <param name="i_deviceKey">设备的主键</param>
        /// <returns></returns>
        public CommonDevice GetShardDeviceFromMemory(string i_deviceKey)
        {
            if (this.DicDevices.ContainsKey(i_deviceKey) == true)
            {
                return this.DicDevices[i_deviceKey];
            }
            return null;
        }

        /// <summary>
        /// 从缓存当中获取分享的场景
        /// </summary>
        /// <param name="i_sceneId">场景ID</param>
        /// <returns></returns>
        public SceneUI GetShardSceneFromMemory(int i_sceneId)
        {
            if (this.DicScenes.ContainsKey(i_sceneId) == true)
            {
                return this.DicScenes[i_sceneId];
            }
            return null;
        }

        /// <summary>
        /// 从缓存当中获取分享的房间
        /// </summary>
        /// <returns></returns>
        public Dictionary<string, Room> GetShardRoomFromMemory()
        {
            return this.DicRooms;
        }

        /// <summary>
        /// 从缓存当中获取分享的房间
        /// </summary>
        /// <param name="i_roomId">房间ID</param>
        /// <returns></returns>
        public Room GetShardRoomFromMemory(string i_roomId)
        {
            if (this.DicRooms.ContainsKey(i_roomId) == true)
            {
                return this.DicRooms[i_roomId];
            }
            return null;
        }

        /// <summary>
        /// 从缓存当中获取分享的楼层
        /// </summary>
        /// <returns></returns>
        public Dictionary<string, string> GetShardFloorFormMemory()
        {
            return this.DicFloor;
        }

        #endregion

        #region ■ 一般方法___________________________

        /// <summary>
        /// 获取分享文件的内容
        /// </summary>
        /// <param name="fileName">文件名称(不是全路径)</param>
        /// <returns></returns>
        private byte[] GetShardFileContent(string fileName)
        {
            string fullName = System.IO.Path.Combine(HdlFileNameResourse.DownLoadShardDirectory, fileName);
            if (System.IO.File.Exists(fullName) == false)
            {
                return null;
            }
            var varByte = HdlFileLogic.Current.ReadFileByteContent(fullName);
            return varByte;
        }

        /// <summary>
        /// 清空共享缓存
        /// </summary>
        public void Dispone()
        {
            this.DicDevices = null;
            this.DicScenes.Clear();
            this.DicRooms.Clear();
            this.DicShardKeys.Clear();
            this.DicFloor.Clear();

            //清空文件夹
            string strDir = HdlFileNameResourse.DownLoadShardDirectory;
            HdlFileLogic.Current.CreateDirectory(strDir, true);

            m_Current = null;
        }

        #endregion

        #region ■ 结构体类___________________________

        /// <summary>
        /// 接收分享数据
        /// </summary>
        private class ReceiveShardInfoResult
        {
            /// <summary>
            /// 文件名字
            /// </summary>
            public string FileName = string.Empty;
            /// <summary>
            /// 更新时间
            /// </summary>
            public string CreateTime = string.Empty;
            /// <summary>
            /// 主键
            /// </summary>
            public string Id = string.Empty;
        }

        #endregion
    }
}