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

namespace Shared.Phone.UserCenter
{
    /// <summary>
    /// 场景的逻辑
    /// </summary>
    public class HdlSceneLogic
    {
        #region ■ 变量声明___________________________

        /// <summary>
        /// 场景的逻辑
        /// </summary>
        private static HdlSceneLogic m_Current = null;
        /// <summary>
        /// 场景的逻辑
        /// </summary>
        public static HdlSceneLogic Current
        {
            get
            {
                if (m_Current == null)
                {
                    m_Current = new HdlSceneLogic();
                }
                return m_Current;
            }
        }

        /// <summary>
        /// 场景对象
        /// </summary>
        private Dictionary<int, SceneUI> dicScenes = new Dictionary<int, SceneUI>();

        #endregion

        #region ■ 刷新场景___________________________

        /// <summary>
        /// 从本地刷新场景
        /// </summary>
        public void ReFreshByLocal()
        {
            //清空场景
            this.dicScenes.Clear();
            //获取全部文件
            var listFile = this.GetAllSceneFile();
            foreach (string fileName in listFile)
            {
                try
                {
                    var jsonInfo = Encoding.UTF8.GetString(Global.ReadFileByHomeId(fileName));
                    var tempScene = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(jsonInfo);
                    if (tempScene == null)
                    {
                        continue;
                    }
                    this.dicScenes[tempScene.Id] = tempScene;
                }
                catch(Exception ex)
                {
                    HdlLogLogic.Current.WriteLog(ex);
                    try
                    {
                        //删掉错误文件
                        Global.DeleteFilebyHomeId(fileName);
                    }
                    catch { }
                }
            }
        }

        /// <summary>
        /// 刷新房间的场景列表
        /// </summary>
        public async Task<bool> RefreshSceneUIList()
        {
            //获取网关存在的场景
            var sceneList = await ZigBee.Device.Scene.GetSceneListAsync();
            if (sceneList == null)
            {
                return false;
            }
            var listEsxit = new HashSet<int>();
            foreach (var scene in sceneList)
            {
                if (scene == null)
                {
                    continue;
                }
                listEsxit.Add(scene.ScenesId);
            }

            var listDelete = new List<SceneUI>();
            foreach (var scId in this.dicScenes.Keys)
            {
                if (listEsxit.Contains(scId) == false)
                {
                    //删除的对象
                    listDelete.Add(this.dicScenes[scId]);
                }
            }
            foreach (var sceneui in listDelete)
            {
                //执行删除
                this.RemoveScene(sceneui);
            }

            return true;
        }

        #endregion

        #region ■ 添加场景___________________________

        /// <summary>
        /// 添加场景(更新网关)  0失败 1成功  -1已经存在
        /// </summary>
        /// <returns>The scene.</returns>
        /// <param name="sceneName">Scene name.</param>
        /// <param name="sceneIconPath">背景图片，不包含住宅路径 如果iconPathType=1或者2 需要拼接住宅 变成 住宅/sceneIconPath</param>
        /// <param name="commons">Commons.</param>
        /// <param name="iconPathType">I场景背景图片来源类型 图片来源 0--本地图库 1--拍照 2--系统图库 默认0</param>
        public async Task<int> AddScene(Room i_room, string sceneName, string sceneIconPath, List<Scene.AddSceneMemberData> commons, int iconPathType)
        {
            var getSceneIdAllData = await Scene.GetSceneNewIdAsync(sceneName);
            if (getSceneIdAllData == null || getSceneIdAllData.getSceneIdData == null)
            {
                return 0;
            }
            var getSceneIdData = getSceneIdAllData.getSceneIdData;

            bool result = true;
            foreach (var common in commons)
            {
                //添加新成员
                var addSceneMemberData = new Scene.AddSceneMemberData
                {
                    Type = common.Type,
                    DeviceAddr = common.DeviceAddr,
                    Epoint = common.Epoint,
                    ScenesId = getSceneIdData.NewScenesId,
                    TaskList = common.TaskList,
                    DelayTime = common.DelayTime,
                    MemberNumber = common.MemberNumber,
                    ElseScenesId = common.ElseScenesId
                };
                //添加新成员 返回结果
                var addSceneMemberResponseAllData = await Scene.AddSceneMemberAsync(addSceneMemberData);
                if (addSceneMemberResponseAllData == null || addSceneMemberResponseAllData.addSceneMemberResponseData == null)
                {
                    continue;
                }
                var addSceneMemberResponseData = addSceneMemberResponseAllData.addSceneMemberResponseData;
                if (addSceneMemberResponseData == null && addSceneMemberResponseData.Result != 1)
                {
                    result = false;
                }
            }
            //加入成功
            if (result)
            {
                var sceneUI = new SceneUI
                {
                    Name = sceneName,
                    Id = getSceneIdData.NewScenesId,
                    IconPath = sceneIconPath,
                    IconPathType = iconPathType,
                    AddSceneMemberDataList = commons
                };
                //添加缓存
                sceneUI.Save();
                this.dicScenes[sceneUI.Id] = sceneUI;
                if (i_room.ListSceneId.Contains(sceneUI.Id) == false)
                {
                    i_room.ListSceneId.Add(sceneUI.Id);
                    i_room.Save();
                }
                return 1;
            }
            return 0;
        }

        /// <summary>
        /// 添加场景(这个单纯只改房间)
        /// </summary>
        /// <param name="scene">Scene.</param>
        public void AddScene(Room i_room, SceneUI scene)
        {
            //添加缓存
            if (i_room.ListSceneId.Contains(scene.Id) == false)
            {
                i_room.ListSceneId.Add(scene.Id);
                i_room.Save();
            }
        }

        /// <summary>
        /// 添加搜藏场景
        /// </summary>
        /// <param name="scene">Scene.</param>
        public void AddLoveScene(SceneUI scene)
        {
            var nowRoom = HdlRoomLogic.Current.GetLoveRoom();
            //添加缓存
            if (nowRoom.ListSceneId.Contains(scene.Id) == false)
            {
                nowRoom.ListSceneId.Add(scene.Id);
                nowRoom.Save();
            }
        }

        /// <summary>
        /// 删除场景(这个只移除内存)
        /// </summary>
        /// <param name="scene"></param>
        public void DeleteScene(Room i_room, SceneUI scene)
        {
            //移除缓存
            if (i_room.ListSceneId.Contains(scene.Id) == true)
            {
                i_room.ListSceneId.Remove(scene.Id);
                i_room.Save();
            }
        }

        /// <summary>
        /// 删除搜藏场景
        /// </summary>
        /// <param name="scene"></param>
        public void DeleteLoveScene(SceneUI scene)
        {
            var nowRoom = HdlRoomLogic.Current.GetLoveRoom();
            //移除缓存
            if (nowRoom.ListSceneId.Contains(scene.Id) == true)
            {
                nowRoom.ListSceneId.Remove(scene.Id);
                nowRoom.Save();
            }
        }

        #endregion

        #region ■ 修改场景___________________________

        /// <summary>
        /// 修改场景设备 0失败 1成功
        /// </summary>
        /// <returns>The scene.</returns>
        /// <param name="sceneUI">Scene user interface.</param>
        /// <param name="sceneRemoveMemberData">Scene remove member data.</param>
        /// <param name="addCommons">Add commons.</param>
        public async Task<int> ModifyScene(SceneUI sceneUI, Scene.SceneRemoveMemberData sceneRemoveMemberData, List<Scene.AddSceneMemberData> addCommons)
        {
            bool result = true;
            //移除成员 返回结果
            var removeSceneMemberResponseAllData = await ZigBee.Device.Scene.RemoveSceneMemberAsync(sceneRemoveMemberData);
            if (removeSceneMemberResponseAllData == null || removeSceneMemberResponseAllData.removeSceneMemberResponseData == null)
            {
                return 0;
            }
            var removeSceneMemberResponseData = removeSceneMemberResponseAllData.removeSceneMemberResponseData;
            if (removeSceneMemberResponseData == null)
            {
                return 0;
            }
            if (removeSceneMemberResponseData.Result != 0)
            {
                result = false;
            }
            //添加
            foreach (var addCommon in addCommons)
            {
                //添加新成员
                var addSceneMemberData = new ZigBee.Device.Scene.AddSceneMemberData
                {
                    DeviceAddr = addCommon.DeviceAddr,
                    Type = addCommon.Type,
                    Epoint = addCommon.Epoint,
                    ScenesId = sceneUI.Id,
                    TaskList = addCommon.TaskList,
                    DelayTime = addCommon.DelayTime,
                    ElseScenesId = addCommon.ElseScenesId,
                    MemberNumber = addCommon.MemberNumber
                };
                //添加新成员 返回结果
                var addSceneMemberResponseAllData = await ZigBee.Device.Scene.AddSceneMemberAsync(addSceneMemberData);
                if (addSceneMemberResponseAllData == null || addSceneMemberResponseAllData.addSceneMemberResponseData == null)
                {
                    result = false;
                    System.Console.WriteLine("添加场景失败");
                    continue;
                }
                var addSceneMemberResponseData = addSceneMemberResponseAllData.addSceneMemberResponseData;
                if (addSceneMemberResponseData == null && addSceneMemberResponseData.Result != 1)
                {
                    result = false;
                }
            }
            //加入成功
            if (result)
            {
                sceneUI.AddSceneMemberDataList = addCommons;
                sceneUI.Save();
                return 1;
            }
            return 0;
        }

        #endregion

        #region ■ 删除场景___________________________

        /// <summary>
        /// 移除场景--该仅进行了对本地场景数据的删除
        /// </summary>
        /// <param name="sceneUI">Scene user interface.</param>
        public void RemoveScene(SceneUI sceneUI)
        {
            //移除缓存
            this.dicScenes.Remove(sceneUI.Id);
            var room = HdlRoomLogic.Current.GetRoomBySceneId(sceneUI.Id);
            if (room != null)
            {
                room.ListSceneId.Remove(sceneUI.Id);
                room.Save();
            }

            //移除喜爱
            var roomLove = HdlRoomLogic.Current.GetLoveRoom();
            if (roomLove.ListSceneId.Contains(sceneUI.Id) == true)
            {
                roomLove.ListSceneId.Remove(sceneUI.Id);
                roomLove.Save();
            }

            //删除文件
            if (Global.IsExistsByHomeId(sceneUI.FileName) == true)
            {
                Global.DeleteFilebyHomeId(sceneUI.FileName);
                HdlAutoBackupLogic.DeleteFile(sceneUI.FileName);
            }
            //删除图片
            if (sceneUI.IconPathType == 1 || sceneUI.IconPathType == 2)
            {
                if (Global.IsExistsByHomeId(sceneUI.IconPath))
                {
                    Global.DeleteFilebyHomeId(sceneUI.IconPath);
                    HdlAutoBackupLogic.DeleteFile(sceneUI.IconPath);
                }
            }
        }

        #endregion

        #region ■ 获取场景___________________________

        /// <summary>
        /// 通过场景id获取场景
        /// </summary>
        /// <returns>The scene UIB y scene identifier.</returns>
        /// <param name="sceneId">Scene identifier.</param>
        public SceneUI GetSceneUIBySceneId(int sceneId)
        {
            if (this.dicScenes.ContainsKey(sceneId) == true)
            {
                return this.dicScenes[sceneId];
            }
            return null;
        }

        /// <summary>
        /// 获取该楼层所有场景
        /// </summary>
        /// <param name="floorId"></param>
        /// <returns></returns>
        public List<SceneUI> GetSameFloorScenes(string floorId)
        {
            List<SceneUI> sceneUIs = new List<SceneUI>();
            var rooms = HdlRoomLogic.Current.GetRoomsByFloorId(floorId);
            foreach (var r in rooms)
            {
                foreach (int sceneId in r.ListSceneId)
                {
                    if (this.dicScenes.ContainsKey(sceneId) == true)
                    {
                        sceneUIs.Add(this.dicScenes[sceneId]);
                    }
                }
            }
            return sceneUIs;
        }

        /// <summary>
        /// 根据场景Id，获取楼层和房间名字(楼层,房间名字)
        /// </summary>
        /// <returns></returns>
        public string GetZoneById(int sceneId)
        {
            var room =HdlRoomLogic.Current.GetRoomBySceneId(sceneId);
            if (room == null)
            {
                return null;
            }
            var floorName = Shared.Common.Config.Instance.Home.GetFloorNameById(room.FloorId);
            if (floorName == null)
            {
                return room.Name;
            }
            return $"{floorName},{room.Name}";
        }

        /// <summary>
        /// 获取未分配区域场景
        /// </summary>
        /// <returns></returns>
        public List<SceneUI> GetUnalloctedScenes()
        {
            List<SceneUI> sceneUIs = new List<SceneUI>();
            //已经存在的场景
            var listEsxit = new HashSet<int>();
            var listAllRoom = HdlRoomLogic.Current.GetAllListRooms();
            foreach (var room in listAllRoom)
            {
                foreach (int sceneId in room.ListSceneId)
                {
                    if (listEsxit.Contains(sceneId) == false)
                    {
                        listEsxit.Add(sceneId);
                    }
                }
            }
            foreach (var myScene in this.dicScenes.Values)
            {
                if (listEsxit.Contains(myScene.Id) == false)
                {
                    sceneUIs.Add(myScene);
                }
            }

            if (sceneUIs.Count == 0)
            {
                return null;
            }
            return sceneUIs;
        }

        /// <summary>
        /// 获取全部房间的全部场景
        /// </summary>
        /// <returns></returns>
        public List<SceneUI> GetAllRoomSceneList()
        {
            List<SceneUI> sceneUIs = new List<SceneUI>();
            var listAllRoom = HdlRoomLogic.Current.GetAllListRooms();
            foreach (var room in listAllRoom)
            {
                foreach (int sceneId in room.ListSceneId)
                {
                    if (this.dicScenes.ContainsKey(sceneId) == true)
                    {
                        sceneUIs.Add(this.dicScenes[sceneId]);
                    }
                }
            }
            
            return sceneUIs;
        }

        /// <summary>
        /// 获取指定房间的全部场景
        /// </summary>
        /// <returns></returns>
        public List<SceneUI> GetRoomSceneList(Room i_room)
        {
            List<SceneUI> sceneUIs = new List<SceneUI>();
            foreach (int sceneId in i_room.ListSceneId)
            {
                if (this.dicScenes.ContainsKey(sceneId) == true)
                {
                    sceneUIs.Add(this.dicScenes[sceneId]);
                }
            }

            return sceneUIs;
        }

        #endregion

        #region ■ 一般方法___________________________

        /// <summary>
        /// 获取本地全部的场景文件
        /// </summary>
        /// <returns></returns>
        public List<string> GetAllSceneFile()
        {
            List<string> listSceneFile = new List<string>();
            List<string> listAllFile = Global.FileListByHomeId();

            foreach (string file in listAllFile)
            {
                if (file.StartsWith("Scene_") == false)
                {
                    //如果不是场景文件
                    continue;
                }
                listSceneFile.Add(file);
            }
            return listSceneFile;
        }
        #endregion
    }
}