using Shared.Common;
using Shared.Phone.UserCenter.SmartSound;
using System;
using System.Collections.Generic;
using System.Text;
using ZigBee.Device;

namespace Shared.Phone.UserCenter.Device
{
    /// <summary>
    /// 设备列表的主界面
    /// </summary>
    public class DeviceListMainForm : EditorCommonForm
    {
        #region ■ 变量声明___________________________
        /// <summary>
        /// 智能音箱
        /// </summary>
        private MySmartSoundControl smmartSoundView = null;
        /// <summary>
        /// 网关控件
        /// </summary>
        private MyGatewayControl gatewayViewRow = null;
        /// <summary>
        /// 列表控件
        /// </summary>
        private VerticalListRefreshControl listView = null;
        /// <summary>
        /// 前一次显示出左滑菜单的RowLayout
        /// </summary>
        private RowLayoutControl oldShowRightMuneRow = null;
        /// <summary>
        /// 行控件的信息(Keys：Mac地址)
        /// </summary>
        private Dictionary<string, DeviceObjRowInfo> dicRowInfo = new Dictionary<string, DeviceObjRowInfo>();
        /// <summary>
        /// 当前正在操作的设备对象Mac地址(设备信息编辑界面用)
        /// </summary>
        private string nowActionDeviceMac = null;

        #endregion

        #region ■ 初始化_____________________________

        /// <summary>
        /// 画面显示(底层会固定调用此方法，借以完成画面创建)
        /// </summary>
        public void ShowForm()
        {
            this.ScrollEnabled = false;

            //设置标题信息
            base.SetTitleText(Language.StringByID(R.MyInternationalizationString.DeviceManagement));

            //右上添加按钮
            var btnAddDeviceIcon = new MostRightIconControl(69, 69);
            btnAddDeviceIcon.UnSelectedImagePath = "Item/Add.png";
            topFrameLayout.AddChidren(btnAddDeviceIcon);
            btnAddDeviceIcon.InitControl();
            btnAddDeviceIcon.ButtonClickEvent += (sender, e) =>
            {
                var form = new DeviceDirection.AddDeviceTypeListForm();
                form.AddForm();
            };

            //初始化中部控件
            this.InitMiddleFrame();

            //开启传感器报警监视
            this.StartCheckDeviceAlarm();
            //添加接收设备在线上报的监听
            HdlGatewayReceiveLogic.Current.AddAttributeEvent("DeviceListFormReceivePushOnline", ReceiveComandDiv.A设备在线上报, (report) =>
            {
                HdlThreadLogic.Current.RunMain(() =>
                {
                    //接受设备状态
                    this.ReceiveDeviceStatu(report);

                }, ShowErrorMode.NO);
            });
            //开启检测网关在线状态的线程
            HdlGatewayLogic.Current.StartCheckGatewayOnlineThread(this);
        }

        /// <summary>
        /// 初始化中部控件(外部可以调用)
        /// </summary>
        public void InitMiddleFrame()
        {
            //清空bodyFrame
            this.ClearBodyFrame();

            smmartSoundView = new MySmartSoundControl();
            bodyFrameLayout.AddChidren(smmartSoundView);
            smmartSoundView.InitControl();
            //当前不是虚拟住宅的话
            if (Config.Instance.Home.IsVirtually == false)
            {
                smmartSoundView.ButtonClickEvent += (sernder, e) =>
                {
                    var form = new SmartSoundListForm();
                    form.AddForm();
                };
            }
            //初始化网关行控件
            HdlGatewayResourse.NowSelectGatewayId = HdlGatewayResourse.AppOldSelectGatewayId;
            var nowGateway = HdlGatewayLogic.Current.GetLocalGateway(HdlGatewayResourse.AppOldSelectGatewayId);
            this.gatewayViewRow = new MyGatewayControl(nowGateway);
            bodyFrameLayout.AddChidren(gatewayViewRow);
            gatewayViewRow.InitControl();

            //初始化搜索控件
            this.InitSearchControl();

            HdlThreadLogic.Current.RunThread(() =>
            {
                //初始化设备列表控件
                this.InitDeviceListControl();
            });
        }

        #endregion

        #region ■ 初始化搜索控件_____________________

        /// <summary>
        /// 初始化搜索控件
        /// </summary>
        private void InitSearchControl()
        {
            //白色背景
            var frame = new FrameLayout();
            frame.BackgroundColor = UserCenterColor.Current.White;
            frame.Y = this.gatewayViewRow.Bottom + Application.GetRealHeight(23);
            frame.Height = bodyFrameLayout.Height - this.gatewayViewRow.Bottom - Application.GetRealHeight(23);
            bodyFrameLayout.AddChidren(frame);

            //搜索设备关键词
            string textTip = Language.StringByID(R.MyInternationalizationString.uSearchDeviceKeyWorld);
            var txtSearchControl = new SearchTextControl(textTip);
            frame.AddChidren(txtSearchControl);
            txtSearchControl.Y = Application.GetRealHeight(46);
            //绑定回调函数
            txtSearchControl.BindEvent(this.SetRowDataBySearchKeys);

            //列表控件
            listView = new VerticalListRefreshControl(29);
            listView.Y = txtSearchControl.Bottom + Application.GetRealHeight(29);
            listView.Height = frame.Height - txtSearchControl.Bottom - Application.GetRealHeight(29);
            frame.AddChidren(listView);
            listView.BeginHeaderRefreshingAction += () =>
            {
                //刷新设备的话,主页需要重新刷新
                UserView.UserPage.Instance.RefreshAllForm = true;

                HdlThreadLogic.Current.RunThread(() =>
                {
                    //下拉刷新
                    this.ListViewBeginHeaderRefreshing();
                });
            };
        }

        #endregion

        #region ■ 初始化设备列表控件_________________

        /// <summary>
        /// 初始化设备列表控件
        /// </summary>
        private void InitDeviceListControl()
        {
            //获取设备列表
            var listDevice = HdlDeviceCommonLogic.Current.GetDeviceByGatewayID(HdlGatewayResourse.NowSelectGatewayId);
            var listSpecialOta = HdlDeviceCommonLogic.Current.GetSpecialOtaDevice(HdlGatewayResourse.NowSelectGatewayId);
            listDevice.AddRange(listSpecialOta);

            this.dicRowInfo.Clear();

            //没有设备
            if (listDevice.Count == 0)
            {
                return;
            }

            //根据MAC合并设备列表
            this.MargeAllDeviceByMac(listDevice);

            if (this.Parent == null)
            {
                return;
            }
            HdlThreadLogic.Current.RunMain(() =>
            {
                var listOta = new List<OTADevice>();
                foreach (var macAddress in this.dicRowInfo.Keys)
                {
                    //获取ota设备
                    var ota = HdlDeviceCommonLogic.Current.GetOTADevice(macAddress);
                    if (ota != null)
                    {
                        listOta.Add(ota);
                    }
                    //添加设备的菜单行
                    this.AddDeviceMenuRow(macAddress);
                }
                //如果当前不是虚拟住宅
                if (Common.Config.Instance.Home.IsVirtually == false)
                {
                    //开启网关在线监测的线程
                    this.StartGatewayOnlieCheckThread();
                    //检测设备新版本
                    this.CheckDeviceNewVersion(listOta);
                }
            });
        }

        #endregion

        #region ■ 添加设备菜单行_____________________

        /// <summary>
        /// 添加设备的菜单行
        /// </summary>
        /// <param name="deviceMac">设备Mac地址</param>
        private void AddDeviceMenuRow(string deviceMac)
        {
            var rowInfo = this.dicRowInfo[deviceMac];

            //创建一个可以展开和收缩的FrameLayout,相当于菜单栏
            var frameTable = new FrameListControl(29);
            frameTable.Height = HdlControlResourse.ListViewRowHeight + frameTable.rowSpace;
            listView.AddChidren(frameTable);
            rowInfo.frameTable = frameTable;

            //控件
            var rowMenu = new DeviceObjectControl(deviceMac, listView.rowSpace / 2);
            rowMenu.MainKeys = deviceMac;
            frameTable.AddChidren(rowMenu);
            rowMenu.InitControl();
            rowInfo.MenuRow = rowMenu;
            //向右图标
            var btnRight = rowMenu.frameTable.AddMostRightEmptyIcon(58, 58);
            btnRight.UnSelectedImagePath = "Item/RightNext.png";
            btnRight.SelectedImagePath = "Item/Down.png";
            rowMenu.frameTable.ChangedChidrenBindMode(btnRight, ChidrenBindMode.NotBind);

            //提示新版本
            var btnNew = new InformationTipView(rowMenu.btnIcon);
            btnNew.Visible = false;
            rowMenu.frameTable.AddChidren(btnNew, ChidrenBindMode.BindEvent);
            rowMenu.AddTag("btnNew", btnNew);

            //检测设备是否拥有定位的功能
            var listdevice = HdlDeviceCommonLogic.Current.GetDevicesByMac(deviceMac);
            if (listdevice.Count > 0 && HdlDeviceCommonLogic.Current.DeviceIsCanFixedPosition(listdevice[0]) == true)
            {
                //定位
                var btnPosition = rowMenu.AddEditorControl(false);
                btnPosition.TextID = R.MyInternationalizationString.uFixedPosition;
                btnPosition.ButtonClickEvent += (sender, e) =>
                {
                    //定位
                    HdlDeviceCommonLogic.Current.SetFixedPositionCommand(listdevice[0], true);
                };
            }

            //展开,折叠
            btnRight.ButtonClickEvent += (sender, e) =>
            {
                //回路数大于1才展开
                var listMacDevice = HdlDeviceCommonLogic.Current.GetDevicesByMac(deviceMac, false);
                if (listMacDevice.Count > 1)
                {
                    btnRight.IsSelected = !btnRight.IsSelected;
                    //展开或者折叠明细列表
                    this.ShowDetailList(deviceMac, btnRight.IsSelected);
                }
                else
                {
                    if (HdlDeviceCommonLogic.Current.IsMiniLight(listMacDevice[0]) == true)
                    {
                        //mini夜灯的功能设置界面
                        var room = HdlRoomLogic.Current.GetRoomByDevice(listMacDevice[0]);
                        var form = new MainPage.DeviceDetailInfoForm();
                        form.AddForm(listMacDevice[0], room);
                    }
                    else
                    {
                        //设备信息界面
                        var form = new DeviceMacInfoEditorForm();
                        form.AddForm(deviceMac);
                    }
                    btnNew.Visible = false;
                    //界面跳转,记录当前的正在操作的设备的Mac地址
                    this.nowActionDeviceMac = deviceMac;
                }
            };

            rowMenu.frameTable.ButtonClickEvent += (sender, e) =>
            {
                //隐藏菜单
                rowMenu.HideMenu();
                //强制跳转真实设备界面
                if (HdlUserCenterResourse.HideOption.GotoRealDeviceForm == 1)
                {
                    var form2 = new DeviceAddSuccessForm();
                    form2.AddForm(deviceMac);
                    return;
                }
                var listMacDevice = HdlDeviceCommonLogic.Current.GetDevicesByMac(deviceMac, false);
                if (listMacDevice.Count > 0 && HdlDeviceCommonLogic.Current.IsMiniLight(listMacDevice[0]) == true)
                {
                    //mini夜灯的功能设置界面
                    var room = HdlRoomLogic.Current.GetRoomByDevice(listMacDevice[0]);
                    var form = new MainPage.DeviceDetailInfoForm();
                    form.AddForm(listMacDevice[0], room);
                }
                else
                {
                    //设备信息界面
                    var form = new DeviceMacInfoEditorForm();
                    form.AddForm(deviceMac);
                }

                btnNew.Visible = false;
                //界面跳转,记录当前的正在操作的设备的Mac地址
                this.nowActionDeviceMac = deviceMac;
            };
            //左滑菜单事件
            rowMenu.OpenMenuAction += () =>
            {
                if (this.oldShowRightMuneRow != null && this.oldShowRightMuneRow.MainKeys != rowMenu.MainKeys)
                {
                    //左滑菜单只能滑一个
                    this.oldShowRightMuneRow.HideMenu();
                }
                this.oldShowRightMuneRow = rowMenu;
            };
        }

        #endregion

        #region ■ 展开折叠___________________________

        /// <summary>
        /// 展开或者隐藏列表
        /// </summary>
        /// <param name="deviceMac">设备Mac地址</param>
        /// <param name="isShow">是否展开</param>
        private void ShowDetailList(string deviceMac, bool isShow)
        {
            var rowInfo = this.dicRowInfo[deviceMac];
            //它原来的高度
            int oldHeight = rowInfo.frameTable.Height;
            //变更的高度,默认为列表隐藏
            int heightValue = HdlControlResourse.ListViewRowHeight + rowInfo.frameTable.rowSpace;
            var listDevice = HdlDeviceCommonLogic.Current.GetDevicesByMac(deviceMac);
            if (isShow == true)
            {
                //备注：面板中只显示真实的设备，其他属于绑定的回路不显示
                //获取这一堆设备时属于什么类型的
                var deviceEnumInfo = HdlDeviceCommonLogic.Current.GetMyDeviceEnumInfo(listDevice);
                if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleMultifunction)
                {
                    var listTemp = HdlDeviceCommonLogic.Current.GetMutilfunctionPanelByMac(listDevice);
                    //展开模式时，扩大依据为:它有几个子控件
                    heightValue = (listTemp.Count + 1) * (HdlControlResourse.ListViewRowHeight + rowInfo.frameTable.rowSpace);
                    //标题自己就是一个子控件
                    if (rowInfo.frameTable.ChildrenCount == 1)
                    {
                        foreach (CommonDevice info in listTemp)
                        {
                            //加载它的列表
                            this.AddDeviceDetailRow(rowInfo.frameTable, info, deviceEnumInfo);
                        }
                    }
                }
                else if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFreshAir
                       || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleEnvironment
                       || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueEnvironment)
                {
                    var listTemp = HdlDeviceCommonLogic.Current.GetPanelMatchEpointByMac(listDevice);
                    //展开模式时，扩大依据为:它有几个子控件
                    heightValue = (listTemp.Count + 1) * (HdlControlResourse.ListViewRowHeight + rowInfo.frameTable.rowSpace);
                    //标题自己就是一个子控件
                    if (rowInfo.frameTable.ChildrenCount == 1)
                    {
                        foreach (CommonDevice info in listTemp)
                        {
                            //加载它的列表
                            this.AddDeviceDetailRow(rowInfo.frameTable, info, deviceEnumInfo);
                        }
                    }
                }
                else
                {
                    //展开模式时，扩大依据为:它有几个子控件
                    heightValue = (listDevice.Count + 1) * (HdlControlResourse.ListViewRowHeight + rowInfo.frameTable.rowSpace);
                    //标题自己就是一个子控件
                    if (rowInfo.frameTable.ChildrenCount == 1)
                    {
                        foreach (CommonDevice info in listDevice)
                        {
                            //加载它的列表
                            this.AddDeviceDetailRow(rowInfo.frameTable, info, deviceEnumInfo);
                        }
                    }
                }
            }
            //自身高度变更
            rowInfo.frameTable.Height = heightValue;
        }

        /// <summary>
        /// 添加设备的明细行
        /// </summary>
        /// <param name="frame">容器</param>
        /// <param name="device"></param>
        /// <param name="deviceEnumInfo"></param>
        private void AddDeviceDetailRow(FrameListControl frame, CommonDevice device, DeviceEnumInfo deviceEnumInfo)
        {
            var rowInfo = this.dicRowInfo[device.DeviceAddr];
            if (rowInfo.dicDetailRow == null)
            {
                rowInfo.dicDetailRow = new Dictionary<string, DeviceRoomControl>();
            }

            //行控件
            var rowDevice = new DeviceRoomControl(device, frame.rowSpace / 2);
            rowDevice.MainKeys = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
            frame.AddChidren(rowDevice);
            rowDevice.frameTable.LeftOffset = Application.GetRealWidth(173) - HdlControlResourse.XXLeft;
            rowDevice.InitControl();
            //底线
            rowDevice.frameTable.AddBottomLine();
            //右箭头
            rowDevice.frameTable.AddRightArrow();
            //在线状态
            rowDevice.IsOnline = rowInfo.MenuRow.IsOnline;
            //保存控件
            string maikey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
            rowInfo.dicDetailRow[maikey] = rowDevice;

            //检测设备是否拥有定位的功能
            if (HdlDeviceCommonLogic.Current.DeviceIsCanFixedPosition(device) == true)
            {
                //定位
                var btnPosition = rowDevice.AddEditorControl(false);
                btnPosition.TextID = R.MyInternationalizationString.uFixedPosition;
                btnPosition.ButtonClickEvent += (sender, e) =>
                {
                    //定位
                    HdlDeviceCommonLogic.Current.SetFixedPositionCommand(device);
                };
            }

            rowDevice.frameTable.ButtonClickEvent += (sender, e) =>
            {
                //隐藏菜单
                rowDevice.HideMenu();
                //界面跳转,记录当前的正在操作的设备的Mac地址
                this.nowActionDeviceMac = device.DeviceAddr;
                //如果当前住宅不是虚拟住宅
                if (Common.Config.Instance.Home.IsVirtually == false)
                {
                    //显示设备功能配置界面
                    this.ShowDeviceFunctionSettionForm(device, deviceEnumInfo);
                }
            };
            //左滑菜单事件
            rowDevice.OpenMenuAction += () =>
            {
                if (this.oldShowRightMuneRow != null && this.oldShowRightMuneRow.MainKeys != rowDevice.MainKeys)
                {
                    //左滑菜单只能滑一个
                    this.oldShowRightMuneRow.HideMenu();
                }
                this.oldShowRightMuneRow = rowDevice;
            };
        }

        /// <summary>
        /// 显示设备功能配置界面
        /// </summary>
        /// <param name="device"></param>
        /// <param name="deviceEnumInfo"></param>
        private void ShowDeviceFunctionSettionForm(CommonDevice device, DeviceEnumInfo deviceEnumInfo)
        {
            //智能门锁
            if (deviceEnumInfo.BeloneType == DeviceBeloneType.A智能门锁)
            {
                var form = new DeviceMacInfoEditorForm();
                form.AddForm(device.DeviceAddr);
            }
            else if (deviceEnumInfo.BeloneType == DeviceBeloneType.A窗帘)
            {
                var form = new DeviceMacInfoEditorForm();
                form.AddForm(device.DeviceAddr);
            }
            //pir传感器
            else if (deviceEnumInfo.ConcreteType == DeviceConcreteType.Sensor_Pir)
            {
                if (device is IASZone)
                {
                    var form = new DevicePirSensor.PirSensorBindTargetSettionForm();
                    form.AddForm((IASZone)device);
                }
                else
                {
                    //pir传感器,他们又搞了个继电器在里面
                    var form = new DeviceFunctionSettionForm();
                    form.AddForm(device, true);
                }
            }
            //中央空调
            else if (deviceEnumInfo.ConcreteType == DeviceConcreteType.AirConditioner_ZbGateway)
            {
                var form = new DeviceAirConditioner.IndoorUnitSettionForm();
                form.AddForm((AC)device);
            }
            //新风面板
            else if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFreshAir)
            {
                //方悦新风面板的按键配置
                //干接点
                if (device.Type == DeviceType.FreshAir)
                {
                    var form = new DevicePanel.PanelSettionWithSourceForm();
                    form.AddForm(device);
                }
                else
                {
                    var form = new DeviceFunctionSettionForm();
                    form.AddForm(device, true);
                }
            }
            //简约环境面板的按键配置
            else if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleEnvironment)
            {

                if (device.Type == DeviceType.FreshAir || device.Type == DeviceType.Thermostat)
                {
                    var form = new DevicePanel.PanelSettionWithSourceForm();
                    form.AddForm(device);
                }
                else
                {
                    var form = new DeviceFunctionSettionForm();
                    form.AddForm(device, true);
                }
            }
            //简约多功能面板的按键配置
            else if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleMultifunction)
            {
                var form = new DeviceFunctionSettionForm();
                form.AddForm(device, true);
            }
            //方悦面板
            else if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueTwo
                || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFour
                || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueEight)
            {
                //干接点
                if (device.Type == DeviceType.OnOffSwitch)
                {
                    //方悦面板的按键配置
                    var form = new DevicePanel.PanelFangyueButtonSettionForm();
                    form.AddForm(device);
                }
                //继电器
                else if (device.Type == DeviceType.OnOffOutput)
                {
                    //方悦面板的功能配置
                    var form = new DevicePanel.PanelFangyueFunctionSettionForm();
                    form.AddForm(device, deviceEnumInfo);
                }
                else
                {
                    var form = new DeviceFunctionSettionForm();
                    form.AddForm(device, true);
                }
            }
            //面板设备
            else if (deviceEnumInfo.BeloneType == DeviceBeloneType.A按键面板)
            {
                //干接点
                if (device.Type == DeviceType.OnOffSwitch)
                {
                    //河东设备
                    if (deviceEnumInfo.IsHdlDevice == true)
                    {
                        var form = new DevicePanel.PanelButtonSettionForm();
                        form.AddForm(device);
                    }
                    else
                    {
                        var form = new DeviceDryContactSettionForm();
                        form.AddForm(device);
                    }
                }
                //继电器
                else if (device.Type == DeviceType.OnOffOutput)
                {
                    //河东设备
                    if (deviceEnumInfo.IsHdlDevice == true)
                    {
                        var form = new DevicePanel.PanelFunctionSettionForm();
                        form.AddForm(device);
                    }
                    else
                    {
                        var form = new DeviceFunctionSettionForm();
                        form.AddForm(device, true);
                    }
                }
                else
                {
                    var form = new DeviceFunctionSettionForm();
                    form.AddForm(device, true);
                }
            }
            //如果是干接点
            else if (device.Type == DeviceType.OnOffSwitch)
            {
                var form = new DeviceDryContactSettionForm();
                form.AddForm(device);
            }
            else
            {
                var form = new DeviceFunctionSettionForm();
                form.AddForm(device, true);
            }
        }

        #endregion

        #region ■ 键值搜索___________________________

        /// <summary>
        /// 根据搜索键值，设定列表数据
        /// </summary>
        /// <param name="searchKey">Search key.</param>
        private void SetRowDataBySearchKeys(string searchKey)
        {
            lock (dicRowInfo)
            {
                HdlThreadLogic.Current.RunMain(() =>
                {
                    if (this.listView == null)
                    {
                        return;
                    }
                    //首先先移除列表所有控件
                    this.listView.RemoveAll();
                    //如果搜索键值为空，则还原为原始状态:显示设备类型总览
                    if (searchKey == string.Empty)
                    {
                        foreach (var deviceMac in dicRowInfo.Keys)
                        {
                            //添加设备的行
                            this.AddDeviceMenuRow(deviceMac);
                        }
                        //添加底部间隙
                        var frameTemp = new FrameLayout();
                        frameTemp.Height = Application.GetRealHeight(23);
                        listView.AddChidren(frameTemp);
                    }
                    else
                    {
                        //搜索名字里面包含键值的设备
                        foreach (var rowInfo in this.dicRowInfo.Values)
                        {
                            if ((rowInfo.MacName != null && rowInfo.MacName.Contains(searchKey) == true)
                                || rowInfo.DeviveTypeName.Contains(searchKey) == true)
                            {
                                //添加设备的行
                                this.AddDeviceMenuRow(rowInfo.DeviceMac);
                            }
                        }
                        //添加底部间隙
                        var frameTemp = new FrameLayout();
                        frameTemp.Height = Application.GetRealHeight(23);
                        listView.AddChidren(frameTemp);
                    }
                });
            }
        }

        #endregion

        #region ■ 下拉刷新___________________________

        /// <summary>
        /// 滑动控件下拉刷新
        /// </summary>
        private void ListViewBeginHeaderRefreshing()
        {
            //如果当前住宅是虚拟的
            if (Common.Config.Instance.Home.IsVirtually == true)
            {
                //就显示一个特效而已
                System.Threading.Thread.Sleep(2000);
                HdlThreadLogic.Current.RunMain(() =>
                {
                    //隐藏下拉刷新特效
                    listView.EndHeaderRefreshing();
                });
                return;
            }
            //如果是在线的
            var nowGateway = HdlGatewayLogic.Current.GetLocalGateway(HdlGatewayResourse.NowSelectGatewayId);
            if (HdlGatewayLogic.Current.CheckGatewayOnlineByMemory(nowGateway) == true)
            {
                //检测广播到的这个网关是否拥有住宅ID
                ZbGateway realWay = null;
                if (HdlGatewayLogic.Current.GetRealGateway(ref realWay, nowGateway) == true)
                {
                    //重新设置住宅ID(这个应该是不经过APP,直接把网关恢复了出厂设置)
                    if (HdlGatewayLogic.Current.HomeIdIsEmpty(realWay.HomeId) == true)
                    {
                        //显示进度条
                        ProgressBar.Show();
                        int result2 = HdlGatewayLogic.Current.ReBindNewGateway(realWay);
                        //关闭进度条
                        ProgressBar.Close();
                        if (result2 == -1)
                        {
                            HdlThreadLogic.Current.RunMain(() =>
                            {
                                //隐藏下拉刷新特效
                                listView.EndHeaderRefreshing();
                            });
                            return;
                        }
                    }
                }
            }
            if (this.Parent == null)
            {
                return;
            }

            //获取全部设备
            int result = HdlDeviceCommonLogic.Current.SetDeviceToMemmoryByGateway(nowGateway.GwId, false);
            if (this.Parent == null)
            {
                return;
            }
            HdlThreadLogic.Current.RunMain(() =>
            {
                //隐藏下拉刷新特效
                listView.EndHeaderRefreshing();
                if (result != -1)
                {
                    //重新刷新界面
                    this.InitMiddleFrame();
                }
            });
        }

        #endregion

        #region ■ 网关在线检测_______________________

        /// <summary>
        /// 开启网关在线监测的线程
        /// </summary>
        private void StartGatewayOnlieCheckThread()
        {
            string selectGwId = HdlGatewayResourse.NowSelectGatewayId;
            HdlThreadLogic.Current.RunThread(() =>
            {
                ZbGateway zbGateway = HdlGatewayLogic.Current.GetLocalGateway(selectGwId);
                if (zbGateway == null)
                {
                    return;
                }
                //刷新网关在线状态
                HdlGatewayLogic.Current.RefreshGatewayOnlineStatu(new List<ZbGateway>() { zbGateway });

                HdlThreadLogic.Current.RunMain(() =>
                {
                    if (this.gatewayViewRow != null && this.gatewayViewRow.zbGatewayId == selectGwId)
                    {
                        bool online = HdlGatewayLogic.Current.CheckGatewayOnlineByMemory(zbGateway);
                        //刷新控件在线状态
                        this.gatewayViewRow?.RefreshOnlineStatu();
                        //根据网关在线状态刷新设备在线状态
                        this.RefreshDeviceOnlineStatuByGatewayOnline(online);
                    }
                });
            });
        }

        /// <summary>
        /// 网关在线状态变更
        /// </summary>
        /// <param name="gateWay">网关对象</param>
        /// <param name="online">在线状态变更后的状态</param>
        /// <param name="hadGwOnline">2020.05.25追加:此住宅是否拥有网关在线</param>
        public override void GatewayOnlinePush(ZbGateway gateWay, bool online, bool hadGwOnline)
        {
            if (this.gatewayViewRow == null)
            {
                return;
            }
            if (gateWay.GwId == this.gatewayViewRow.zbGatewayId)
            {
                HdlThreadLogic.Current.RunMain(() =>
                {
                    //相同的状态,不需要再次刷新
                    if (this.gatewayViewRow.isOnline != online)
                    {
                        //根据网关在线状态刷新设备在线状态
                        this.RefreshDeviceOnlineStatuByGatewayOnline(online);
                    }
                    //刷新控件在线状态
                    this.gatewayViewRow?.RefreshOnlineStatu();
                });
            }
        }

        #endregion

        #region ■ 设备在线检测_______________________

        /// <summary>
        /// 根据网关在线状态刷新设备在线状态
        /// </summary>
        /// <param name="gatewayOnline">网关的在线状态</param>
        private void RefreshDeviceOnlineStatuByGatewayOnline(bool gatewayOnline)
        {
            if (gatewayOnline == false)
            {
                //设置全部设备离线
                this.SetAllDeviceOffLine();
            }
            else
            {
                //刷新设备在线状态
                this.RefreshDeviceOnlineStatu();
            }
        }

        /// <summary>
        /// 刷新设备在线状态
        /// </summary>
        private void RefreshDeviceOnlineStatu()
        {
            string gwId = HdlGatewayResourse.NowSelectGatewayId;
            HdlThreadLogic.Current.RunThread(() =>
            {
                if (this.Parent == null) { return; }
                //获取设备列表
                var listDevice = HdlDeviceCommonLogic.Current.GetDeviceByGatewayID(gwId);
                var listCheck = new List<string>();
                foreach (var device in listDevice)
                {
                    if (this.Parent == null) { return; }
                    if (listCheck.Contains(device.DeviceAddr) == false)
                    {
                        //只要一个回路即可
                        listCheck.Add(device.DeviceAddr);
                        var deviceInfo = HdlDeviceCommonLogic.Current.ReadDeviceEpointDeviceInfo(device);
                        if (deviceInfo != null)
                        {
                            //变更在线状态
                            device.IsOnline = deviceInfo.IsOnline;
                            HdlThreadLogic.Current.RunMain(() =>
                            {
                                //设置设备在线状态
                                this.ReceiveDeviceStatu(device);
                            }, ShowErrorMode.NO);
                        }
                        System.Threading.Thread.Sleep(50);
                    }
                }
            });
        }

        /// <summary>
        /// 接受设备状态
        /// </summary>
        /// <param name="device"></param>
        private void ReceiveDeviceStatu(CommonDevice device)
        {
            DeviceObjRowInfo rowInfo = null;
            if (this.dicRowInfo.ContainsKey(device.DeviceAddr) == true)
            {
                rowInfo = this.dicRowInfo[device.DeviceAddr];
            }
            if (rowInfo == null || rowInfo.MenuRow == null)
            {
                return;
            }
            //刷新设备的在线状态
            string mainkeys = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
            var localDevice = HdlDeviceCommonLogic.Current.GetDevice(mainkeys);
            if (localDevice != null)
            {
                //保存状态
                localDevice.IsOnline = device.IsOnline;
            }

            rowInfo.MenuRow.IsOnline = HdlDeviceCommonLogic.Current.CheckDeviceIsOnline(device);
            if (rowInfo.dicDetailRow != null)
            {
                foreach (var detailRow in rowInfo.dicDetailRow.Values)
                {
                    detailRow.IsOnline = rowInfo.MenuRow.IsOnline;
                }
            }
        }

        /// <summary>
        /// 设置全部设备离线
        /// </summary>
        private void SetAllDeviceOffLine()
        {
            foreach (var rowInfo in this.dicRowInfo.Values)
            {
                //菜单
                if (rowInfo.MenuRow != null)
                {
                    rowInfo.MenuRow.IsOnline = false;
                }
                //明细
                if (rowInfo.dicDetailRow != null)
                {
                    foreach (var detailRow in rowInfo.dicDetailRow.Values)
                    {
                        detailRow.IsOnline = false;
                    }
                }
            }
        }

        #endregion

        #region ■ 传感器报警_________________________

        /// <summary>
        /// 开启传感器报警监视
        /// </summary>
        private void StartCheckDeviceAlarm()
        {
            HdlGatewayReceiveLogic.Current.AddAttributeEvent("DeviceListFormSensor", ReceiveComandDiv.A传感器上报, (device) =>
             {
                 HdlThreadLogic.Current.RunMain(() =>
                 {
                     if (this.dicRowInfo.ContainsKey(device.DeviceAddr) == false)
                     {
                         return;
                     }
                     //显示传感器上报的特效
                     this.dicRowInfo[device.DeviceAddr].MenuRow?.StartSensorPushAppeal();
                 });
             });
        }

        #endregion

        #region ■ 设备新版本_________________________

        /// <summary>
        /// 检测设备新版本
        /// </summary>
        /// <param name="list">ota设备</param>
        private void CheckDeviceNewVersion(List<OTADevice> list)
        {
            HdlThreadLogic.Current.RunThread(() =>
            {
                System.Threading.Thread.Sleep(2000);
                foreach (var ota in list)
                {
                    if (this.Parent == null)
                    {
                        return;
                    }
                    //添加升级固件信息(成不成功都无所谓)
                    var result = HdlFirmwareUpdateLogic.Current.AddFirmwareVersionInfo(FirmwareLevelType.A设备, ota.HwVersion.ToString(), ota.ImgTypeId.ToString());

                    //获取设备最新版本
                    var deviceFirmware = HdlFirmwareUpdateLogic.Current.GetFirmwareMostVersionInfo(FirmwareLevelType.A设备,
                        ota.HwVersion.ToString(),
                        ota.ImgTypeId.ToString(),
                        ota.ImgVersion);

                    if (deviceFirmware == null)
                    {
                        continue;
                    }

                    //拥有新版本
                    HdlThreadLogic.Current.RunMain(() =>
                    {
                        if (this.dicRowInfo.ContainsKey(ota.DeviceAddr) == true)
                        {
                            var row = this.dicRowInfo[ota.DeviceAddr].MenuRow;
                            if (row != null)
                            {
                                var btnNew = (InformationTipView)row.GetTagByKey("btnNew");
                                if (btnNew != null)
                                {
                                    btnNew.Visible = true;
                                }
                            }
                        }
                    });
                }
            });
        }

        #endregion

        #region ■ 实现外部调用_______________________

        /// <summary>
        /// 添加新的设备到界面桌布中(外部调用)
        /// </summary>
        /// <param name="deviceAddr">设备Mac地址</param>
        public void AddDeviceToFormTable(string deviceAddr)
        {
            //新建一个对象
            if (this.dicRowInfo.ContainsKey(deviceAddr) == false)
            {
                var localDevice = HdlDeviceCommonLogic.Current.GetDevicesByMac(deviceAddr);
                if (localDevice.Count == 0)
                {
                    //针对单纯只有一个200端点的设备
                    var ota = HdlDeviceCommonLogic.Current.GetOTADevice(deviceAddr);
                    if (ota == null)
                    {
                        //入网之后，又把它删了
                        return;
                    }
                    localDevice.Add(ota);
                }
                var rowNewInfo = new DeviceObjRowInfo();
                rowNewInfo.DeviceMac = deviceAddr;
                rowNewInfo.MacName = HdlDeviceCommonLogic.Current.GetDeviceMacName(localDevice[0]);
                rowNewInfo.DeviveTypeName = HdlDeviceCommonLogic.Current.GetDeviceObjectText(localDevice);
                this.dicRowInfo[deviceAddr] = rowNewInfo;

                //创建新的行
                this.AddDeviceMenuRow(deviceAddr);

                //记录当前的正在操作的设备的Mac地址
                this.nowActionDeviceMac = deviceAddr;
            }
        }

        /// <summary>
        /// 刷新指定设备行的信息(外部调用)
        /// </summary>
        /// <param name="deviceAddr">设备Mac地址</param>
        public void RefreshDeviceRow(string deviceAddr)
        {
            if (this.dicRowInfo.ContainsKey(deviceAddr) == true)
            {
                var rowInfo = this.dicRowInfo[deviceAddr];
                //检测这个设备是否被删除 2020.01.13变更:追加Ota设备的判断
                if (HdlDeviceCommonLogic.Current.GetDevicesByMac(deviceAddr).Count == 0
                    && HdlDeviceCommonLogic.Current.GetOTADevice(deviceAddr) == null)
                {
                    //移除控件
                    rowInfo.dicDetailRow = null;
                    rowInfo.frameTable.RemoveFromParent();

                    this.dicRowInfo.Remove(deviceAddr);
                }
                else
                {
                    //刷新设备信息
                    rowInfo.MenuRow?.RefreshControlInfo(true);
                    if (rowInfo.dicDetailRow != null)
                    {
                        foreach (var contr in rowInfo.dicDetailRow.Values)
                        {
                            contr?.RefreshControlInfo();
                        }
                    }
                }
            }
        }

        #endregion

        #region ■ 合并数据___________________________

        /// <summary>
        /// 根据MAC合并设备列表
        /// </summary>
        /// <param name="listDevice"></param>
        private void MargeAllDeviceByMac(List<CommonDevice> listDevice)
        {
            //根据Mac全部分组
            var dic = new Dictionary<string, List<CommonDevice>>();
            foreach (CommonDevice device in listDevice)
            {
                if (device == null || device.DeviceAddr == null)
                {
                    continue;
                }

                //获取设备类型的
                var deviceEnumInfo = HdlDeviceCommonLogic.Current.GetMyDeviceEnumInfo(new List<CommonDevice>() { device });
                if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleEnvironment)
                {
                    foreach (var outClu in device.OutClusterList)
                    {
                        //去掉简约环境面板类的各种服务端设备，室内机不显示
                        if (outClu.OutCluster == 513)
                        {
                            continue;
                        }
                    }
                }
                if (dic.ContainsKey(device.DeviceAddr) == false)
                {
                    dic[device.DeviceAddr] = new List<CommonDevice>();
                }
                dic[device.DeviceAddr].Add(device);
            }
            //获取信息
            foreach (var mac in dic.Keys)
            {
                var info = new DeviceObjRowInfo();
                info.DeviceMac = mac;
                info.MacName = HdlDeviceCommonLogic.Current.GetDeviceMacName(dic[mac][0]);
                info.DeviveTypeName = HdlDeviceCommonLogic.Current.GetDeviceObjectText(dic[mac]);
                this.dicRowInfo[mac] = info;
            }
        }

        #endregion

        #region ■ 界面重新激活事件___________________

        /// <summary>
        /// 自身的上层界面关闭后,它自身处于最上层时,触发的事件
        /// </summary>
        public override int FormActionAgainEvent()
        {
            if (HdlGatewayResourse.AppOldSelectGatewayId != this.gatewayViewRow.zbGatewayId)
            {
                //这个网关被整掉了,需要重新初始化界面
                this.nowActionDeviceMac = null;
                this.oldShowRightMuneRow = null;
                //重新选择网关
                HdlGatewayLogic.Current.RefreshAppOldSelectGatewayId();
                //初始化界面
                this.InitMiddleFrame();
                return 1;
            }

            if (this.nowActionDeviceMac != null)
            {
                //刷新指定设备行的信息
                this.RefreshDeviceRow(this.nowActionDeviceMac);
            }
            //清空记录
            this.nowActionDeviceMac = null;
            //网关控件刷新
            this.gatewayViewRow.RefreshControl();

            return 1;
        }

        #endregion

        #region ■ 关闭界面___________________________

        /// <summary>
        /// 画面关闭
        /// </summary>
        public override void CloseFormBefore()
        {
            HdlGatewayReceiveLogic.Current.RemoveEvent("DeviceListFormSensor");
            HdlGatewayReceiveLogic.Current.RemoveEvent("DeviceListFormReceivePushOnline");

            base.CloseFormBefore();
        }

        #endregion

        #region ■ 结构体类___________________________

        /// <summary>
        /// 设备行信息
        /// </summary>
        private class DeviceObjRowInfo
        {
            /// <summary>
            /// 设备Mac地址
            /// </summary>
            public string DeviceMac = string.Empty;
            /// <summary>
            /// 设备的MAC名字
            /// </summary>
            public string MacName = string.Empty;
            /// <summary>
            /// 设备类型的文本信息
            /// </summary>
            public string DeviveTypeName = string.Empty;
            /// <summary>
            /// 菜单行
            /// </summary>
            public DeviceObjectControl MenuRow = null;
            /// <summary>
            /// 桌布FrameLayout
            /// </summary>
            public FrameListControl frameTable = null;
            /// <summary>
            /// 明细行
            /// </summary>
            public Dictionary<string, DeviceRoomControl> dicDetailRow = null;
        }

        #endregion

        #region ■ 自定义网关控件_____________________

        /// <summary>
        /// 自定义网关控件
        /// </summary>
        private class MyGatewayControl : FrameRowControl
        {
            /// <summary>
            /// 网关ID
            /// </summary>
            public string zbGatewayId = string.Empty;
            /// <summary>
            /// 网关名字控件
            /// </summary>
            private NormalViewControl btnName = null;
            /// <summary>
            /// 在线状态(初始状态为在线)
            /// </summary>
            public bool isOnline = true;

            /// <summary>
            /// 自定义网关控件
            /// </summary>
            /// <param name="i_zbGateway">网关对象</param>
            public MyGatewayControl(ZbGateway i_zbGateway)
            {
                this.UseClickStatu = false;
                if (i_zbGateway != null)
                {
                    this.zbGatewayId = i_zbGateway.GwId;
                }
                this.BackgroundColor = UserCenterColor.Current.White;
                this.Y = Application.GetRealHeight(174);
                this.Height = Application.GetRealHeight(173);
            }

            /// <summary>
            /// 初始化控件
            /// </summary>
            public void InitControl()
            {
                //获取本地网关对象
                ZbGateway zbway = HdlGatewayLogic.Current.GetLocalGateway(zbGatewayId);
                //图标
                var btnIcon = this.AddLeftIcon(81);
                if (zbway != null)
                {
                    HdlGatewayLogic.Current.SetGatewayIcon(btnIcon, zbway);
                }
                else
                {
                    btnIcon.UnSelectedImagePath = "Gateway/GatewayIcon1.png";
                }

                //显示文本
                btnName = this.AddLeftCaption(string.Empty, 700);
                btnName.Height = Application.GetRealHeight(60);
                btnName.TextSize = 15;
                btnName.Y = Application.GetRealHeight(35);
                if (zbway != null)
                {
                    btnName.Text = HdlGatewayLogic.Current.GetGatewayName(zbway);
                    //在线状态
                    //this.isOnline = HdlGatewayLogic.Current.CheckGatewayOnlineByMemory(zbway);
                    //if (this.isOnline == false)
                    //{
                    //    btnName.TextColor = UserCenterColor.Current.TextGrayColor1;
                    //}
                }
                else
                {
                    //虚拟网关
                    btnName.Text = Language.StringByID(R.MyInternationalizationString.uVirtualGateway);
                }

                //当前网关
                var btnNowGw = this.AddLeftCaption(Language.StringByID(R.MyInternationalizationString.uNowGateway), 700);
                btnNowGw.Height = Application.GetRealHeight(49);
                btnNowGw.TextSize = 12;
                btnNowGw.Y = Application.GetRealHeight(95);
                btnNowGw.TextColor = UserCenterColor.Current.TextGrayColor1;

                //向右图标
                var btnRight = this.AddRightArrow();
                btnRight.Name = "btnRight";
                //网关管理
                var btnMament = this.AddMostRightView(Language.StringByID(R.MyInternationalizationString.uGatewayManagement), 300);
                btnMament.Name = "btnMament";

                //当前不是虚拟住宅的话
                if (Common.Config.Instance.Home.IsVirtually == false)
                {
                    this.ButtonClickEvent += (sernder, e) =>
                    {
                        if (string.IsNullOrEmpty(((View)sernder).Name) == false)
                        {
                            //打开网关列表界面
                            var form = new GatewayManage.GatewayListForm();
                            form.AddForm();
                        }
                    };
                }
            }

            /// <summary>
            /// 刷新控件信息
            /// </summary>
            public void RefreshControl()
            {
                //获取本地网关对象
                ZbGateway zbway = HdlGatewayLogic.Current.GetLocalGateway(zbGatewayId);
                if (zbway == null)
                {
                    return;
                }
                btnName.Text = HdlGatewayLogic.Current.GetGatewayName(zbway);
                //刷新控件在线状态
                this.RefreshOnlineStatu();
            }

            /// <summary>
            /// 刷新控件在线状态
            /// </summary>
            public void RefreshOnlineStatu()
            {
                //获取本地网关对象
                ZbGateway zbway = HdlGatewayLogic.Current.GetLocalGateway(zbGatewayId);
                if (zbway == null)
                {
                    return;
                }
                //在线状态
                bool statu = HdlGatewayLogic.Current.CheckGatewayOnlineByMemory(zbway);
                if (this.isOnline != statu)
                {
                    this.isOnline = statu;
                    if (this.isOnline == false)
                    {
                        btnName.TextColor = UserCenterColor.Current.TextGrayColor1;
                    }
                    else
                    {
                        btnName.TextColor = UserCenterColor.Current.TextColor1;
                    }
                }
            }
        }
        #endregion

        #region ■ 自定义智能音箱控件_________________

        /// <summary>
        /// 自定义网关控件
        /// </summary>
        private class MySmartSoundControl : FrameRowControl
        {

            /// <summary>
            /// 网关名字控件
            /// </summary>
            private NormalViewControl btnName = null;

            /// <summary>
            /// 自定音箱关控件
            /// </summary>
            public MySmartSoundControl()
            {
                this.UseClickStatu = false;
                this.BackgroundColor = UserCenterColor.Current.White;
                this.Height = Application.GetRealHeight(173);

                //this.InitControl();
            }


            /// <summary>
            /// 初始化控件
            /// </summary>
            public void InitControl()
            {
                //图标
                var btnIcon = this.AddLeftIcon(81);
                btnIcon.UnSelectedImagePath = "SmartSound/SoundIcon.png";

                //显示文本
                btnName = this.AddLeftCaption(string.Empty, 700);
                btnName.Height = Application.GetRealHeight(60);
                btnName.TextSize = 15;
                btnName.Y = Application.GetRealHeight(57);
                btnName.Text = "智能音箱";

                this.AddRightArrow();
                this.AddMostRightView("", 300, false).Name = "smartSoundLayout";
                this.AddBottomLine();
            }
        }
        #endregion
    }
}