using DevExpress.Diagram.Core.Native;
using DevExpress.Mvvm.Native;
using DevExpress.Pdf.Native;
using Mapster;
using Yw.Epanet;
using Yw.Hydro;
using Yw.Model;
using Yw.Vmo;
using Yw.WinFrmUI.Bimface;

namespace HStation.WinFrmUI
{
    public partial class XhsProjectSimulationCorePage : DocumentPage
    {
        public XhsProjectSimulationCorePage()
        {
            InitializeComponent();
            this.PageTitle.Caption = "水力模拟";
            this.PageTitle.HeaderSvgImage = this.svgImg32[0];
            this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Hidden;
            RegistBulkSetEvents();
        }

        #region 模型事件

        /// <summary>
        /// 获取模型事件
        /// </summary>
        public event Func<XhsSchemeVmo, Task<Yw.Model.HydroModelInfo>> GetModelEvent;

        /// <summary>
        /// 刷新模型事件
        /// </summary>
        public event Func<Task<Yw.Model.HydroModelInfo>> RefreshModelEvent;

        #endregion 模型事件

        #region 方案事件

        /// <summary>
        /// 更新方案事件
        /// </summary>
        public event Action<XhsSchemeVmo> UpdateSchemeEvent;

        /// <summary>
        /// 移除方案事件
        /// </summary>
        public event Action<XhsSchemeVmo> RemoveSchemeEvent;

        #endregion 方案事件

        #region 工况事件

        /// <summary>
        /// 新增工况事件
        /// </summary>
        public event Action<HydroWorkingVmo> AppendWorkingEvent;

        /// <summary>
        /// 更新工况事件
        /// </summary>
        public event Action<HydroWorkingVmo> UpdateWorkingEvent;

        /// <summary>
        /// 移除工况事件
        /// </summary>
        public event Action<HydroWorkingVmo> RemoveWorkingEvent;

        /// <summary>
        /// 重载工况事件
        /// </summary>
        public event Action<Dictionary<HydroWorkingVmo, bool>> ReloadWorkingEvent;

        #endregion 工况事件

        private HStation.Vmo.XhsProjectVmo _project = null;//项目
        private HStation.Vmo.XhsProjectSiteVmo _projectSite = null;//项目站
        private HStation.Vmo.XhsSchemeVmo _scheme = null;//方案
        private Yw.Model.HydroModelInfo _hydroInfo = null;//水力信息
        private Dictionary<HydroWorkingVmo, bool> _allWorkingCheckedListDict = null;//所有工况选择列表字典

        /// <summary>
        /// 绑定数据
        /// </summary>
        public void SetBindingData
            (
                XhsProjectVmo project,
                XhsProjectSiteVmo projectSite,
                XhsSchemeVmo scheme,
                Yw.Model.HydroModelInfo hydroInfo,
                Dictionary<HydroWorkingVmo, bool> allWorkingCheckedListDict
            )
        {
            _project = project;
            _projectSite = projectSite;
            _scheme = scheme;
            _hydroInfo = hydroInfo;
            _allWorkingCheckedListDict = allWorkingCheckedListDict;
            ResetMonitorValue();
            if (_scheme == null)
            {
                this.ribPageGroupForScheme.Visible = false;
                this.PageTitle.Caption = $"水力模拟";
            }
            else
            {
                this.ribPageGroupForScheme.Visible = true;
                this.PageTitle.Caption = $"模拟方案\r\n{_scheme.Name}";
            }
        }

        /// <summary>
        /// 初始化数据
        /// </summary>
        public override void InitialDataSource()
        {
            base.InitialDataSource();
            ShowBimfaceCtrl();
            ShowL3d2Ctrl();
            ShowPropertyCtrl();
            InitialSvgImages();
        }

        //初始化Svg图片
        private void InitialSvgImages()
        {
            //监测
            this.barBtnSetMonitorList.ImageOptions.SvgImage = HydroMonitorSvgImageHelper.Docking;

            //水库
            this.barBtnSetReservoirList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Tank;
            this.barBtnSetReservoirList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetReservoirList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetReservoirList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //水池
            this.barBtnSetTankList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Tank;
            this.barBtnSetTankList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetTankList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetTankList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //水箱
            this.barBtnSetWaterboxList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Tank;
            this.barBtnSetWaterboxList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetWaterboxList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetWaterboxList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //连接节点
            this.barBtnSetJunctionList.ImageOptions.SvgImage = HydroMainSvgImageHelper.Junction;
            this.barBtnSetJunctionList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetJunctionList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetJunctionList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //闷头
            this.barBtnSetBluntheadList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Blunthead;
            this.barBtnSetBluntheadList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetBluntheadList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetBluntheadList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //弯头
            this.barBtnSetElbowsList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Elbow;
            this.barBtnSetElbowsList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetElbowsList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetElbowsList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //三通
            this.barBtnSetThreelinkList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Threelink;
            this.barBtnSetThreelinkList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetThreelinkList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetThreelinkList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //四通
            this.barBtnSetFourlinkList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Fourlink;
            this.barBtnSetFourlinkList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetFourlinkList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetFourlinkList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //消火栓
            this.barBtnSetHydrantList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Hydrant;
            this.barBtnSetHydrantList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetHydrantList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetHydrantList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //喷头
            this.barBtnSetNozzleList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Nozzle;
            this.barBtnSetNozzleList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetNozzleList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetNozzleList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //冷却塔
            this.barBtnSetCoolingList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Cooling;
            this.barBtnSetCoolingList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetCoolingList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetCoolingList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //水表
            this.barBtnSetMeterList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Meter;
            this.barBtnSetMeterList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetMeterList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetMeterList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //流量计
            this.barBtnSetFlowmeterList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Flowmeter;
            this.barBtnSetFlowmeterList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetFlowmeterList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetFlowmeterList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //压力表
            this.barBtnSetPressmeterList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Pressmeter;
            this.barBtnSetPressmeterList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetMeterList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetMeterList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //管道
            this.barBtnSetPipeList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Pipe;
            this.barBtnSetPipeList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetPipeList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetPipeList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //过渡件
            this.barBtnSetTranslationList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Translation;
            this.barBtnSetTranslationList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetTranslationList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetTranslationList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //水泵
            this.barBtnSetPumpList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Pump;
            this.barBtnSetPumpList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetPumpList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetPumpList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //阀门
            this.barBtnSetValveList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Valve;
            this.barBtnSetValveList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetValveList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetValveList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //换热器
            this.barBtnSetExchangerList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Exchanger;
            this.barBtnSetExchangerList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetExchangerList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetExchangerList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;

            //压缩机
            this.barBtnSetCompressorList.ImageOptions.SvgImage = AssetsMainSvgImageHelper.Compressor;
            this.barBtnSetCompressorList.ImageOptions.SvgImageSize = new Size(32, 32);
            this.barBtnSetCompressorList.ItemAppearance.Normal.ForeColor = Color.FromArgb(0, 122, 204);
            this.barBtnSetCompressorList.ImageOptions.AllowGlyphSkinning = DevExpress.Utils.DefaultBoolean.True;
        }

        #region 属性状态

        //属性状态辅助类
        private HydroPropStatusHelper _propStatusHelper = null;

        //获取属性状态辅助类
        private async Task<HydroPropStatusHelper> GetPropStatusHelper()
        {
            if (_propStatusHelper == null)
            {
                var allPropStatusList = await BLLFactory<Yw.BLL.HydroParterPropStatusInfo>.Instance.GetByModelID(_hydroInfo.ID);
                _propStatusHelper = new HydroPropStatusHelper(_hydroInfo, allPropStatusList);
            }
            return _propStatusHelper;
        }

        //获取属性状态Db列表
        private async Task<List<HydroParterPropStatusInfo>> GetPropStatusDbList()
        {
            var helper = await GetPropStatusHelper();
            return helper.GetPropStatusDbList();
        }

        #endregion 属性状态

        #region 更改状态

        //改变辅助类
        private HydroChangeHelper _changeHelper = null;

        //获取改变辅助类
        private HydroChangeHelper GetChangeHelper()
        {
            if (_hydroInfo == null)
            {
                return default;
            }
            if (_changeHelper == null)
            {
                _changeHelper = new HydroChangeHelper(_hydroInfo);
            }
            return _changeHelper;
        }

        //附加改变构件
        private void AppendChangeParter(HydroParterInfo parter, eChangeType changeType)
        {
            var helper = GetChangeHelper();
            helper.Append(parter, changeType);
        }

        //获取增加构件列表
        private List<HydroParterInfo> GetAddParterList()
        {
            var helper = GetChangeHelper();
            return helper.GetAddParterList();
        }

        //获取更新构件列表
        private List<HydroParterInfo> GetUpdateParterList()
        {
            var helper = GetChangeHelper();
            return helper.GetUpdateParterList();
        }

        //获取移除构件列表
        private List<string> GetRemoveParters()
        {
            var helper = GetChangeHelper();
            return helper.GetRemoveParters();
        }

        #endregion 更改状态

        #region BIM控件

        //bimface控件
        private SimulationBimfaceCtrl _bimfaceCtrl = null;

        //获取 bimface 控件
        private async Task<SimulationBimfaceCtrl> GetBimfaceCtrl()
        {
            if (_hydroInfo == null)
            {
                return default;
            }
            if (_bimfaceCtrl == null)
            {
                _bimfaceCtrl = new SimulationBimfaceCtrl();
                _bimfaceCtrl.Dock = DockStyle.Fill;
                WaitFormHelper.ShowWaitForm(this.FindForm(), "正在加载模型，请稍后...");
                await _bimfaceCtrl.InitialData(_project, _projectSite);
                _bimfaceCtrl.LoadCompletedEvent += () =>
                {//view加载完成事件
                    WaitFormHelper.HideWaitForm();
                    this.barCkDecorator.Checked = false;
                    this.barCkGrading.Checked = true;
                };
                _bimfaceCtrl.HydroMouseLeftClickEvent += (code) =>
                {//鼠标左键点击事件
                    var visualListHelper = GetVisualListHelper();
                    var visual = visualListHelper.GetVisual(code);
                    SelectVisual(visual, eSimulationVisualSource.Bimface);
                };
            }
            return _bimfaceCtrl;
        }

        //显示 bimface 控件
        private async void ShowBimfaceCtrl()
        {
            var bimfaceCtrl = await GetBimfaceCtrl();
            this.tabPageBimface.Controls.Clear();
            this.tabPageBimface.Controls.Add(bimfaceCtrl);
        }

        #endregion BIM控件

        #region L3d2控件

        //L3d2控件
        private XhsProjectSimulationL3d2Ctrl _l3d2ctrl = null;

        //获取L3d2控件
        private XhsProjectSimulationL3d2Ctrl GetL3d2Ctrl()
        {
            if (_hydroInfo == null)
            {
                return default;
            }
            if (_l3d2ctrl == null)
            {
                _l3d2ctrl = new XhsProjectSimulationL3d2Ctrl();
                _l3d2ctrl.Dock = DockStyle.Fill;
                _l3d2ctrl.InitialData(hydroInfoFunc: () => _hydroInfo);
                _l3d2ctrl.SelectedPartersChangedEvent += (codes) =>
                {
                    var visualListHelper = GetVisualListHelper();
                    var visuals = visualListHelper.GetVisualList(codes);
                    SelectVisual(visuals?.LastOrDefault(), eSimulationVisualSource.Q3d);
                };
            }
            return _l3d2ctrl;
        }

        //显示L3d2控件
        private void ShowL3d2Ctrl()
        {
            var l3d2Ctrl = GetL3d2Ctrl();
            this.tabPageQ3d.Controls.Clear();
            this.tabPageQ3d.Controls.Add(l3d2Ctrl);
        }

        #endregion

        #region 属性控件

        //属性控件
        private SimulationPropertyCtrl _propertyCtrl = null;

        //获取属性控件
        private async Task<SimulationPropertyCtrl> GetPropertyCtrl()
        {
            if (_hydroInfo == null)
            {
                return default;
            }
            if (_propertyCtrl == null)
            {
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                _propertyCtrl = new SimulationPropertyCtrl();
                _propertyCtrl.Dock = DockStyle.Fill;
                _propertyCtrl.AllowEdit = true;
                _propertyCtrl.InitialData(changeHelper, propStatusHelper);
                _propertyCtrl.CalcuResult = () => GetCalcuResult();
                _propertyCtrl.HydroViewEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Property);
                };
                _propertyCtrl.BlinkLinkNodeEvent += async (link, linkNodeCode) =>
                { //强调连接节点
                    if (link == null)
                    {
                        return;
                    }
                    var visualListHelper = GetVisualListHelper();
                    var linkNode = visualListHelper.GetVisual(linkNodeCode);
                    if (linkNode == null)
                    {
                        return;
                    }
                    var blinkCodes = new List<string>();
                    if (linkNode.GetType() == typeof(HydroJunctionInfo))
                    {
                        var allLinkList = visualListHelper.GetLinkList();
                        if (allLinkList == null || allLinkList.Count < 1)
                        {
                            return;
                        }
                        var linkList = allLinkList.Where(x => (x.StartCode == linkNodeCode || x.EndCode == linkNodeCode) && x.Code != link.Code).ToList();
                        if (linkList == null || linkList.Count < 1)
                        {
                            return;
                        }
                        blinkCodes.AddRange(linkList.Select(x => x.Code));
                    }
                    else
                    {
                        blinkCodes.Add(linkNodeCode);
                    }

                    await _bimfaceCtrl?.ClearBlinkComponents();
                    await _bimfaceCtrl?.SetBlinkComponents(blinkCodes);
                    await Task.Delay(5000);
                    await _bimfaceCtrl?.ClearBlinkComponents();
                };
                _propertyCtrl.PropertyValueChangedEvent += async (visual) =>
                {
                    if (visual == null)
                    {
                        return;
                    }
                    UpdateVisualListCtrl();
                    var gradingHelper = await GetGradingHelper();
                    gradingHelper.Set();
                };
                _propertyCtrl.MarkPropertyValueChangedEvent += async (visual) =>
                {
                    //标注属性发生改变
                    //判断当前是否有标注展示，若有则更新标注，最好是更新单个标注
                    var markHelper = await GetMarkHelper();
                    markHelper.Set(visual);
                };
                _propertyCtrl.GradingPropertyValueChangedEvent += async (visual) =>
                {
                    //分级属性发生改变
                    //判断当前是否有分级展示，若有则更新分级，最好是更新单个分级
                    var gradingHelper = await GetGradingHelper();
                    gradingHelper.Set(visual);
                };
                _propertyCtrl.FlowDirectionPropertyValueChangedEvent += async (visual) =>
                {
                    //流向属性发生改变
                    //判断当前是否有流向展示，若有则更新流向，最好是更新单个流向
                    var flowDirectionHelper = await GetFlowEffectHelper();
                    flowDirectionHelper.Set(visual);
                };
            }
            return _propertyCtrl;
        }

        //属性控件是否可见
        private bool IsPropertyCtrlVisible
        {
            get
            {
                if (this.docPnlRight.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
                {
                    if (this.controlContainerRight.Controls.Count > 0)
                    {
                        if (this.controlContainerRight.Controls[0] is SimulationPropertyCtrl)
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
        }

        //显示属性控件
        private async Task ShowPropertyCtrl()
        {
            if (IsPropertyCtrlVisible)
            {
                return;
            }
            var propertyCtrl = await GetPropertyCtrl();
            this.controlContainerRight.Controls.Clear();
            this.controlContainerRight.Controls.Add(propertyCtrl);
            this.docPnlRight.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
            this.docPnlRight.Text = "属性";
            this.docPnlRight.Width = 300;
        }

        //设置属性控件
        private async void SetPropertyCtrl(HydroVisualInfo visual)
        {
            await ShowPropertyCtrl();
            var visualVmListHelper = GetVisualVmListHelper();
            var vm = visualVmListHelper.GetVisual(visual);
            _propertyCtrl.SelectedObject = vm;
            _propertyCtrl.UpdateRows();
        }

        //更新属性控件
        private void UpdatePropertyCtrl()
        {
            _propertyCtrl?.UpdateRows();
        }

        #endregion

        #region 选择构件

        //选择构件
        private Yw.Model.HydroVisualInfo _visual = null;

        //选择构件
        private void SelectVisual(HydroVisualInfo visual, eSimulationVisualSource source)
        {
            _visual = visual;
            switch (source)
            {
                case eSimulationVisualSource.None:
                    {
                        _bimfaceCtrl?.ZoomAndSelectComponent(visual?.Code);
                        this.barBtnSetMonitorList.Enabled = visual != null;
                        SetPropertyCtrl(visual);
                    }
                    break;

                case eSimulationVisualSource.Bimface:
                    {
                        this.barBtnSetMonitorList.Enabled = visual != null;
                        SetPropertyCtrl(visual);
                    }
                    break;

                case eSimulationVisualSource.Q3d:
                    {
                        _bimfaceCtrl?.ZoomAndSelectComponent(visual?.Code);
                        this.barBtnSetMonitorList.Enabled = visual != null;
                        SetPropertyCtrl(visual);
                    }
                    break;

                case eSimulationVisualSource.Property:
                    {
                        _bimfaceCtrl?.ZoomAndSelectComponent(visual?.Code);
                        this.barBtnSetMonitorList.Enabled = visual != null;
                    }
                    break;

                case eSimulationVisualSource.List:
                    {
                        _bimfaceCtrl?.ZoomAndSelectComponent(visual?.Code);
                        this.barBtnSetMonitorList.Enabled = visual != null;
                        SetPropertyCtrl(visual);
                    }
                    break;

                case eSimulationVisualSource.Set:
                    {
                        _bimfaceCtrl?.ZoomAndSelectComponent(visual?.Code);
                        this.barBtnSetMonitorList.Enabled = visual != null;
                        SetPropertyCtrl(visual);
                    }
                    break;

                case eSimulationVisualSource.Search:
                    {
                        _bimfaceCtrl?.ZoomAndSelectComponent(visual?.Code);
                        this.barBtnSetMonitorList.Enabled = visual != null;
                        SetPropertyCtrl(visual);
                    }
                    break;

                case eSimulationVisualSource.Monitor:
                    {
                        _bimfaceCtrl?.ZoomAndSelectComponent(visual?.Code);
                        this.barBtnSetMonitorList.Enabled = visual != null;
                        SetPropertyCtrl(visual);
                    }
                    break;

                case eSimulationVisualSource.Check:
                    {
                        _bimfaceCtrl?.ZoomAndSelectComponent(visual?.Code);
                        this.barBtnSetMonitorList.Enabled = visual != null;
                        SetPropertyCtrl(visual);
                    }
                    break;

                case eSimulationVisualSource.Calcu:
                    {
                        _bimfaceCtrl?.ZoomAndSelectComponent(visual?.Code);
                        this.barBtnSetMonitorList.Enabled = visual != null;
                        SetPropertyCtrl(visual);
                    }
                    break;

                case eSimulationVisualSource.Warning:
                    {
                        _bimfaceCtrl?.ZoomAndSelectComponent(visual?.Code);
                        this.barBtnSetMonitorList.Enabled = visual != null;
                        SetPropertyCtrl(visual);
                    }
                    break;

                default: break;
            }
        }

        //选择构件
        private void SelectVisual(string code, eSimulationVisualSource source)
        {
            var visual = GetVisual(code);
            SelectVisual(visual, source);
        }

        #endregion 选择构件

        #region 构件明细

        #region 可见列表

        //可见列表辅助类
        private SimulationVisualListHelper _visualListHelper = null;

        //获取可见列表辅助类
        private SimulationVisualListHelper GetVisualListHelper()
        {
            if (_visualListHelper == null)
            {
                _visualListHelper = new SimulationVisualListHelper();
                _visualListHelper.InitialData(_hydroInfo);
            }
            return _visualListHelper;
        }

        //重置可见列表
        private void ResetVisualList()
        {
            var helper = GetVisualListHelper();
            helper.InitialData(_hydroInfo);
        }

        //获取可见构件
        private Yw.Model.HydroVisualInfo GetVisual(string code)
        {
            var helper = GetVisualListHelper();
            var visual = helper.GetVisual(code);
            return visual;
        }

        //获取可见列表
        private List<Yw.Model.HydroVisualInfo> GetVisualList()
        {
            var helper = GetVisualListHelper();
            return helper.GetVisualList();
        }

        //获取水源列表
        private List<Yw.Model.HydroSourceInfo> GetSourceList()
        {
            var helper = GetVisualListHelper();
            return helper.GetSourceList();
        }

        #endregion 可见列表

        #region 视图列表

        //可见视图列表辅助类
        private SimulationVisualVmListHelper _visualVmListHelper = null;

        //获取可见视图列表辅助类
        private SimulationVisualVmListHelper GetVisualVmListHelper()
        {
            if (_hydroInfo == null)
            {
                return default;
            }
            if (_visualVmListHelper == null)
            {
                var visualListHelper = GetVisualListHelper();
                var calcuResultHelper = GetCalcuResultHelper();
                _visualVmListHelper = new SimulationVisualVmListHelper(visualListHelper, calcuResultHelper);
            }
            return _visualVmListHelper;
        }

        //获取可见视图列表
        private List<HydroVisualViewModel> GetVisualViewModelList()
        {
            var helper = GetVisualVmListHelper();
            return helper.GetVisualList();
        }

        //获取可见视图
        private HydroVisualViewModel GetVisualViewModel(string code)
        {
            var helper = GetVisualVmListHelper();
            return helper.GetVisual(code);
        }

        #endregion 视图列表

        #region 明细控件

        //构件明细控件
        private Yw.WinFrmUI.HydroVisualListCtrl _visualListCtrl = null;

        //获取构件明细控件
        private Yw.WinFrmUI.HydroVisualListCtrl GetVisualListCtrl()
        {
            if (_visualListCtrl == null)
            {
                _visualListCtrl = new HydroVisualListCtrl();
                _visualListCtrl.Dock = DockStyle.Fill;
                _visualListCtrl.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.List);
                };
                _visualListCtrl.HydroChangedInfoEvent += (visualList) =>
                {
                    SelectVisual(_visual, eSimulationVisualSource.List);
                };
            }
            return _visualListCtrl;
        }

        //构件明细控件是否可见
        private bool IsVisualListCtrlVisible
        {
            get
            {
                if (this.docPnlBottom.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
                {
                    if (this.controlContainerBottom.Controls.Count > 0)
                    {
                        if (this.controlContainerBottom.Controls[0] is HydroVisualListCtrl)
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
        }

        //显示构件明细控件
        private async void ShowVisualListCtrl()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var visualListCtrl = GetVisualListCtrl();
            if (!IsVisualListCtrlVisible)
            {
                this.controlContainerBottom.Controls.Clear();
                this.controlContainerBottom.Controls.Add(visualListCtrl);
                this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
                this.docPnlBottom.Text = "构件明细";
                this.docPnlBottom.Height = 350;
            }
            var visualVmListHelper = GetVisualVmListHelper();
            var changeHelper = GetChangeHelper();
            var propStatusHelper = await GetPropStatusHelper();
            var allVisualVmList = visualVmListHelper.GetVisualList();
            visualListCtrl.SetBindingData(allVisualVmList, changeHelper, propStatusHelper);
            var calcuResult = GetCalcuResult();
            if (calcuResult != null && calcuResult.Succeed)
            {
                visualListCtrl.SetCalcuView();
            }
            else
            {
                visualListCtrl.SetNormalView();
            }
        }

        //更新构件明细控件
        private void UpdateVisualListCtrl()
        {
            if (!IsVisualListCtrlVisible)
            {
                return;
            }
            _visualListCtrl?.UpdateBindingData();
            var calcuResult = GetCalcuResult();
            if (calcuResult != null && calcuResult.Succeed)
            {
                _visualListCtrl.SetCalcuView();
            }
            else
            {
                _visualListCtrl.SetNormalView();
            }
        }

        //构件明细
        private void barBtnVisualList_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            ShowVisualListCtrl();
        }

        #endregion 明细控件

        #region 构件显示

        //构件可见辅助类
        private SimulationVisualVisibleHelper _visualVisibleHelper = null;

        //获取构件可见辅助类
        private async Task<SimulationVisualVisibleHelper> GetVisualVisibleHelper()
        {
            if (_hydroInfo == null)
            {
                return default;
            }
            if (_visualVisibleHelper == null)
            {
                var visualListHelper = GetVisualListHelper();
                var bimfaceCtrl = await GetBimfaceCtrl();
                _visualVisibleHelper = new SimulationVisualVisibleHelper(visualListHelper, bimfaceCtrl);
                _visualVisibleHelper.InitialData(_hydroInfo);
            }
            return _visualVisibleHelper;
        }

        //设置构件可见性
        private async void SetVisualVisible()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var visualVisibleHelper = await GetVisualVisibleHelper();
            var allVisibleList = visualVisibleHelper.Items;
            var dlg = new SetHydroVisualVisibleDlg();
            dlg.SetBindingData(allVisibleList);
            dlg.ReloadDataEvent += (list) =>
            {
                visualVisibleHelper.Items = list;
                visualVisibleHelper.Set();
            };
            dlg.ShowDialog();
        }

        //设置构件显示
        private void barBtnSetVisualVisible_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            SetVisualVisible();
        }

        #endregion 构件显示

        #endregion 构件明细

        #region 一键显隐

        private List<string> _allDecoratorCodes = null;

        //获取装饰件code列表
        private async Task<List<string>> GetDecoratorCodes()
        {
            if (_hydroInfo == null)
            {
                return default;
            }
            if (_allDecoratorCodes == null)
            {
                _allDecoratorCodes = await BLLFactory<Yw.BLL.HydroDecoratorInfo>.Instance.GetCodeListByModelID(_hydroInfo.ID, null);
            }
            if (_allDecoratorCodes == null)
            {
                _allDecoratorCodes = new List<string>();
            }
            return _allDecoratorCodes;
        }

        //设置装饰件可见性
        private async void SetDecoratorVisible(bool isDecoratorVisible)
        {
            var codes = await GetDecoratorCodes();
            if (isDecoratorVisible)
            {
                await _bimfaceCtrl?.ShowComponents(codes);
            }
            else
            {
                await _bimfaceCtrl?.HideComponents(codes);
            }
        }

        //设置
        private void barCkDecorator_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            SetDecoratorVisible(this.barCkDecorator.Checked);
        }

        #endregion 一键显隐

        #region 保存信息

        //保存锁定对象
        private object _locker_save = new();

        private bool _isSaving = false;//正在保存

        //保存
        private async void barBtnSave_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (_hydroInfo == null)
            {
                return;
            }

            lock (_locker_save)
            {
                if (_isSaving)
                {
                    this.FindForm().ShowAlertInfo("保存", "正在保存，请稍后重试！");
                    return;
                }
            }

            _isSaving = true;

            var changeHelper = GetChangeHelper();

            var addParterList = changeHelper.GetAddParterList();
            var updateParterList = changeHelper.GetUpdateParterList();
            var removeParters = changeHelper.GetRemoveParters();

            if (addParterList == null || addParterList.Count < 1)
            {
                if (updateParterList == null || updateParterList.Count < 1)
                {
                    if (removeParters == null || removeParters.Count < 1)
                    {
                        TipFormHelper.ShowWarn("未检测到修改，无需保存！");
                        _isSaving = false;
                        return;
                    }
                }
            }

            WaitFormHelper.ShowWaitForm("正在保存，请稍后...");

            bool bol = false;

            try
            {
                bol = await BLLFactory<Yw.BLL.HydroModelInfo>.Instance
                .Update(_hydroInfo, addParterList, updateParterList, removeParters);
            }
            catch (Exception ex)
            {
                XtraMessageBox.Show(ex.Message);
                _isSaving = false;
            }

            if (!bol)
            {
                WaitFormHelper.HideWaitForm();
                TipFormHelper.ShowError("水力信息更新失败！");
                _isSaving = false;
                return;
            }
            changeHelper.Reset();

            var propStatusHelper = await GetPropStatusHelper();
            var updatePropStatusList = propStatusHelper.GetUpdatePropStatusDbList();
            if (updatePropStatusList != null && updatePropStatusList.Count > 0)
            {
                bol = await BLLFactory<Yw.BLL.HydroParterPropStatusInfo>.Instance.Update(_hydroInfo.ID, updatePropStatusList);
                if (!bol)
                {
                    WaitFormHelper.HideWaitForm();
                    TipFormHelper.ShowWarn("属性状态更新失败！");
                    _isSaving = false;
                    return;
                }
            }
            propStatusHelper.Reset();

            WaitFormHelper.HideWaitForm();
            TipFormHelper.ShowSucceed("保存成功！");
            _isSaving = false;

            //Stopwatch sw = new Stopwatch();
            //sw.Start();
            //耗时巨大的代码
            //sw.Stop();
            //TimeSpan ts2 = sw.Elapsed;
            //Console.WriteLine("Stopwatch总共花费{0}ms.", ts2.TotalMilliseconds);
        }

        #endregion 保存信息

        #region 批量配置

        //注册批量配置事件
        private void RegistBulkSetEvents()
        {
            //水库
            this.barBtnSetReservoirList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroReservoirListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //水池
            this.barBtnSetTankList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroTankListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //水箱
            this.barBtnSetWaterboxList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroWaterboxListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //连接节点
            this.barBtnSetJunctionList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroJunctionListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //闷头
            this.barBtnSetBluntheadList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroBluntheadListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //弯头
            this.barBtnSetElbowsList.ItemClick += async delegate
            {
                var allVisualVmList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroElbowListDlg();
                dlg.SetBindingData(allVisualVmList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //三通
            this.barBtnSetThreelinkList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroThreelinkListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //四通
            this.barBtnSetFourlinkList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroFourlinkListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //水表
            this.barBtnSetMeterList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroMeterListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //流量计
            this.barBtnSetFlowmeterList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroFlowmeterListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //压力表
            this.barBtnSetPressmeterList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroPressmeterListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //喷嘴
            this.barBtnSetNozzleList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroNozzleListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //冷却塔
            this.barBtnSetCoolingList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroCoolingListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //管道
            this.barBtnSetPipeList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroPipeListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //过渡件
            this.barBtnSetTranslationList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroTranslationListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //水泵
            this.barBtnSetPumpList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroPumpListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //阀门
            this.barBtnSetValveList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroValveListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //换热器
            this.barBtnSetExchangerList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroExchangerListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
            //压缩机
            this.barBtnSetCompressorList.ItemClick += async delegate
            {
                var allVisualViewModelList = GetVisualViewModelList();
                var changeHelper = GetChangeHelper();
                var propStatusHelper = await GetPropStatusHelper();
                var dlg = new SetHydroCompressorListDlg();
                dlg.SetBindingData(allVisualViewModelList, changeHelper, propStatusHelper);
                dlg.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Set);
                };
                dlg.HydroChangedInfoEvent += visuals =>
                {
                    SelectVisual(visuals?.FirstOrDefault(), eSimulationVisualSource.Set);
                    UpdateVisualListCtrl();
                };
                dlg.ShowDialog();
            };
        }

        //显示RadialMenu
        private void barBtnSetList_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            this.rmSet.ShowPopup(MousePosition, true);
        }

        //弹出前
        private void rmSet_BeforePopup(object sender, CancelEventArgs e)
        {
            if (_hydroInfo == null)
            {
                e.Cancel = true;
                return;
            }
            //水库
            if (_hydroInfo.Reservoirs == null || _hydroInfo.Reservoirs.Count < 1)
            {
                this.barBtnSetReservoirList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetReservoirList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //水池
            if (_hydroInfo.Tanks == null || _hydroInfo.Tanks.Count < 1)
            {
                this.barBtnSetTankList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetTankList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //水箱
            if (_hydroInfo.Waterboxs == null || _hydroInfo.Waterboxs.Count < 1)
            {
                this.barBtnSetWaterboxList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetWaterboxList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //连接节点
            if (_hydroInfo.Junctions == null || _hydroInfo.Junctions.Count < 1)
            {
                this.barBtnSetJunctionList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetJunctionList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //喷嘴
            if (_hydroInfo.Nozzles == null || _hydroInfo.Nozzles.Count < 1)
            {
                this.barBtnSetNozzleList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetNozzleList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //消火栓
            if (_hydroInfo.Hydrants == null || _hydroInfo.Hydrants.Count < 1)
            {
                this.barBtnSetHydrantList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetHydrantList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //冷却塔
            if (_hydroInfo.Coolings == null || _hydroInfo.Coolings.Count < 1)
            {
                this.barBtnSetCoolingList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetCoolingList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //闷头
            if (_hydroInfo.Bluntheads == null || _hydroInfo.Bluntheads.Count < 1)
            {
                this.barBtnSetBluntheadList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetBluntheadList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //弯头
            if (_hydroInfo.Elbows == null || _hydroInfo.Elbows.Count < 1)
            {
                this.barBtnSetElbowsList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetElbowsList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //三通
            if (_hydroInfo.Threelinks == null || _hydroInfo.Threelinks.Count < 1)
            {
                this.barBtnSetThreelinkList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetThreelinkList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //四通
            if (_hydroInfo.Fourlinks == null || _hydroInfo.Fourlinks.Count < 1)
            {
                this.barBtnSetFourlinkList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetFourlinkList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //水表
            if (_hydroInfo.Meters == null || _hydroInfo.Meters.Count < 1)
            {
                this.barBtnSetMeterList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetMeterList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //流量计
            if (_hydroInfo.Flowmeters == null || _hydroInfo.Flowmeters.Count < 1)
            {
                this.barBtnSetFlowmeterList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetFlowmeterList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //压力表
            if (_hydroInfo.Pressmeters == null || _hydroInfo.Pressmeters.Count < 1)
            {
                this.barBtnSetPressmeterList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetPressmeterList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //管道
            if (_hydroInfo.Pipes == null || _hydroInfo.Pipes.Count < 1)
            {
                this.barBtnSetPipeList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetPipeList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //过渡件
            if (_hydroInfo.Translations == null || _hydroInfo.Translations.Count < 1)
            {
                this.barBtnSetTranslationList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetTranslationList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //水泵
            if (_hydroInfo.Pumps == null || _hydroInfo.Pumps.Count < 1)
            {
                this.barBtnSetPumpList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetPumpList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //阀门
            if (_hydroInfo.Valves == null || _hydroInfo.Valves.Count < 1)
            {
                this.barBtnSetValveList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetValveList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //换热器
            if (_hydroInfo.Exchangers == null || _hydroInfo.Exchangers.Count < 1)
            {
                this.barBtnSetExchangerList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetExchangerList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            //空压机
            if (_hydroInfo.Compressors == null || _hydroInfo.Compressors.Count < 1)
            {
                this.barBtnSetCompressorList.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                this.barBtnSetCompressorList.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }
        }

        #endregion 批量配置

        #region 构件查询

        //查询组件
        private HydroVisualSearchListCtrl _searchCtrl = null;

        //获取查询组件
        private HydroVisualSearchListCtrl GetSearchCtrl()
        {
            if (_searchCtrl == null)
            {
                var visualVmListHelper = GetVisualVmListHelper();
                var allVisualVmList = visualVmListHelper.GetVisualList();
                _searchCtrl = new HydroVisualSearchListCtrl();
                _searchCtrl.Dock = DockStyle.Fill;
                _searchCtrl.InitialData(allVisualVmList);
                _searchCtrl.HydroClickInfoEvent += (visual) =>
                {
                    SelectVisual(visual, eSimulationVisualSource.Check);
                };
                _searchCtrl.HydroSearchInfoEvent += (list) =>
                {
                    var visual = list?.FirstOrDefault();
                    SelectVisual(visual, eSimulationVisualSource.Search);
                };
            }
            return _searchCtrl;
        }

        //查询控件是否可见
        private bool IsSearchCtrlVisible
        {
            get
            {
                if (this.docPnlBottom.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
                {
                    if (this.controlContainerBottom.Controls.Count > 0)
                    {
                        if (this.controlContainerBottom.Controls[0] is HydroVisualSearchListCtrl)
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
        }

        //显示查询控件
        private void ShowSearchCtrl(string content)
        {
            if (IsSearchCtrlVisible)
            {
                return;
            }
            var searchCtrl = GetSearchCtrl();
            searchCtrl.SetBindingData(content);
            this.controlContainerBottom.Controls.Clear();
            this.controlContainerBottom.Controls.Add(searchCtrl);
            this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
            this.docPnlBottom.Text = "构件查询";
            this.docPnlBottom.Height = 350;
        }

        //显示查询窗体
        private void ShowSearchDlg()
        {
            if (IsSearchCtrlVisible)
            {
                return;
            }
            var dlg = new InputHydroVisualSearchListDlg();
            dlg.SearchEvent += (content) =>
            {
                if (string.IsNullOrEmpty(content))
                {
                    return;
                }
                ShowSearchCtrl(content);
            };
            dlg.SetBindingData();
            dlg.ShowDialog();
        }

        //查询
        private void barBtnSearch_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            ShowSearchDlg();
        }

        #endregion 构件查询

        #region 模型标注

        //标注辅助类
        private SimulationMarkHelper _markHelper = null;

        //获取标注辅助类
        private async Task<SimulationMarkHelper> GetMarkHelper()
        {
            if (_markHelper == null)
            {
                var visualListHelper = GetVisualListHelper();
                var calcuResultHelper = GetCalcuResultHelper();
                var bimfaceCtrl = await GetBimfaceCtrl();
                _markHelper = new SimulationMarkHelper(visualListHelper, calcuResultHelper, bimfaceCtrl);
            }
            return _markHelper;
        }

        //显示标注列表
        private async void ShowMarkList()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var markHelper = await GetMarkHelper();
            var dlg = new SetHydroMarkDlg();
            dlg.SetBindingData(markHelper.Sets);
            dlg.ReloadDataEvent += (list) =>
            {
                markHelper.Sets = list;
                markHelper.Set();
            };
            dlg.ShowDialog();
        }

        //设置标注
        private void barBtnSetMark_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            ShowMarkList();
        }

        //是否显示
        private async void barCkMark_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            var markHelper = await GetMarkHelper();
            markHelper.Visible = this.barCkMark.Checked;
            markHelper.Set();
        }

        #endregion

        #region 水流动画


        //水力动画辅助类
        private SimulationFlowEffectHelper _flowEffectHelper = null;

        //获取水流动画辅助类
        private async Task<SimulationFlowEffectHelper> GetFlowEffectHelper()
        {
            if (_flowEffectHelper == null)
            {
                var visualListHelper = GetVisualListHelper();
                var calcuResultHelper = GetCalcuResultHelper();
                var bimfaceCtrl = await GetBimfaceCtrl();
                _flowEffectHelper = new SimulationFlowEffectHelper(visualListHelper, calcuResultHelper, bimfaceCtrl);
            }
            return _flowEffectHelper;
        }


        //水流动画是否可见
        private async void barCkFlowEffect_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (this.barCkFlowEffect.Checked)
            {
                this.barCkGrading.Checked = false;
            }
            var flowEffectHelper = await GetFlowEffectHelper();
            flowEffectHelper.Visible = this.barCkFlowEffect.Checked;
            flowEffectHelper.Set();

        }

        #endregion

        #region 颜色分级

        //颜色分级辅助类
        private SimulationGradingHelper _gradingHelper = null;

        //获取颜色分级辅助类
        private async Task<SimulationGradingHelper> GetGradingHelper()
        {
            if (_gradingHelper == null)
            {
                var visualListHelper = GetVisualListHelper();
                var calcuResultHelper = GetCalcuResultHelper();
                var bimfaceCtrl = await GetBimfaceCtrl();
                _gradingHelper = new SimulationGradingHelper(visualListHelper, calcuResultHelper, bimfaceCtrl);
            }
            return _gradingHelper;
        }

        //设置颜色分级列表
        private async void SetGradingList()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var gradingHelper = await GetGradingHelper();
            var allGradingList = await gradingHelper.GetGradingList();
            var dlg = new SetHydroGradingTreeDlg();
            dlg.SetBindingData(_hydroInfo, allGradingList);
            dlg.ReloadDataEvent += (list) =>
            {
                gradingHelper.SetGradingList(list);
                gradingHelper.Set();
            };
            dlg.ApplyDataEvent += (catalog, propName) =>
            {
                gradingHelper.UpdateApply(catalog, propName);
                gradingHelper.Set();
            };
            dlg.ShowDialog();
        }

        //配置颜色分级
        private void barBtnSetGradingList_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            SetGradingList();
        }

        //应用颜色分级列表
        private async void ApplyGradingList()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var gradingHelper = await GetGradingHelper();
            var dlg = new ApplyHydroGradingDlg();
            dlg.SetBindingData(gradingHelper.Applies);
            dlg.ReloadDataEvent += (list) =>
            {
                gradingHelper.Applies = list;
                gradingHelper.Set();
            };
            dlg.ShowDialog();
        }

        //应用颜色分级
        private void barBtnApplyGradingList_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            ApplyGradingList();
        }

        //颜色分级展示
        private async void barCkGrading_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (this.barCkGrading.Checked)
            {
                this.barCkFlowEffect.Checked = false;
            }
            var gradingHelper = await GetGradingHelper();
            gradingHelper.Visible = this.barCkGrading.Checked;
            gradingHelper.Set();
        }

        #endregion

        #region 人工刷新

        //刷新
        private async void barBtnRefresh_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (this.RefreshModelEvent == null)
            {
                return;
            }
            if (XtraMessageBox.Show("刷新后将丢失当前水力信息更改，是否继续刷新？", "询问", MessageBoxButtons.YesNo) == DialogResult.Yes)
            {
                var hydroInfo = await this.RefreshModelEvent.Invoke();
                if (hydroInfo == null)
                {
                    TipFormHelper.ShowError("刷新失败！");
                    return;
                }
                _hydroInfo = hydroInfo;
                SelectVisual(visual: null, eSimulationVisualSource.None);

                ResetVisualList();
                TipFormHelper.ShowSucceed("刷新成功！");
            }
        }

        #endregion 人工刷新

        #region 监测点

        //监测点辅助类
        private SimulationMonitorHelper _monitorHelper = null;

        //获取监测点辅助类
        private SimulationMonitorHelper GetMonitorHelper()
        {
            if (_monitorHelper == null)
            {
                var visualListHelper = GetVisualListHelper();
                _monitorHelper = new SimulationMonitorHelper(visualListHelper);
            }
            return _monitorHelper;
        }

        //获取监测点列表
        private async Task<List<HydroMonitorVmo>> GetMonitorList()
        {
            var helper = GetMonitorHelper();
            return await helper.GetAll();
        }

        #endregion

        #region 监测值

        //监测值辅助类
        private SimulationMonitorValueHelper _monitorValueHelper = null;

        //获取监测值辅助类
        private SimulationMonitorValueHelper GetMonitorValueHelper()
        {
            if (_monitorValueHelper == null)
            {
                var visualListHelper = GetVisualListHelper();
                var monitorHelper = GetMonitorHelper();
                _monitorValueHelper = new SimulationMonitorValueHelper(visualListHelper, monitorHelper);
            }
            return _monitorValueHelper;
        }

        //获取监测值列表
        private async Task<List<HydroMonitorValueViewModel>> GetMonitorValueList()
        {
            var helper = GetMonitorValueHelper();
            return await helper.GetAll();
        }

        //重置监测值
        private void ResetMonitorValue()
        {
            var allWorkingList = GetWorkingList();
            var working = allWorkingList?.LastOrDefault(x => !string.IsNullOrEmpty(x.MonitorInfo));
            if (working != null)
            {
                var helper = GetMonitorValueHelper();
                helper.Reset(working.MonitorInfo);
            }
        }

        #endregion

        #region 设置测点

        //设置测点列表
        private async void SetMonitorList(HydroVisualInfo visual)
        {
            if (_hydroInfo == null)
            {
                return;
            }
            if (visual == null)
            {
                return;
            }
            var monitorHelper = GetMonitorHelper();
            var allMonitorList = await monitorHelper.GetAll();
            var monitorValueHelper = GetMonitorValueHelper();
            var allMonitorValueList = await monitorValueHelper.GetAll();
            var dlg = new SetHydroMonitorListDlg();
            dlg.ReloadDataEvent += async (list) =>
            {
                var monitorList = list?.Select(x => x.Vmo).ToList();
                await monitorHelper.Update(visual.Code, monitorList);
                await monitorValueHelper.Update(visual.Code, list);
                var monitorMarkerHelper = await GetMonitorMarkerHelper();
                monitorMarkerHelper.Set();
            };
            dlg.SetBindingData(_hydroInfo, visual, allMonitorList, allMonitorValueList);
            dlg.ShowDialog();
        }

        //设置测点列表
        private void barBtnSetMonitorList_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (_visual == null)
            {
                TipFormHelper.ShowWarn("请选择构件后重试！");
                return;
            }
            SetMonitorList(_visual);
        }

        #endregion

        #region 设置测值

        //监测值列表控件
        private HydroMonitorValueListCtrl _monitorValueListCtrl = null;

        //获取监测值列表控件
        private HydroMonitorValueListCtrl GetMonitorValueListCtrl()
        {
            if (_monitorValueListCtrl == null)
            {
                _monitorValueListCtrl = new HydroMonitorValueListCtrl();
                _monitorValueListCtrl.Dock = DockStyle.Fill;
                _monitorValueListCtrl.HydroViewEvent += (code) =>
                {
                    var visual = GetVisual(code);
                    SelectVisual(visual, eSimulationVisualSource.Monitor);
                };
            }
            return _monitorValueListCtrl;
        }

        //监测值列表控件是否可见
        private bool IsMonitorValueListCtrlVisible
        {
            get
            {
                if (this.docPnlBottom.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
                {
                    if (this.controlContainerBottom.Controls.Count > 0)
                    {
                        if (this.controlContainerBottom.Controls[0] is HydroMonitorValueListCtrl)
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
        }

        //显示监测值列表控件
        private async void ShowMonitorValueListCtrl()
        {
            var monitorValueListCtrl = GetMonitorValueListCtrl();
            if (!IsMonitorValueListCtrlVisible)
            {
                this.controlContainerBottom.Controls.Clear();
                this.controlContainerBottom.Controls.Add(monitorValueListCtrl);
                this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
                this.docPnlBottom.Text = "设置测值";
                this.docPnlBottom.Height = 350;
            }
            var allValueList = await GetMonitorValueList();
            monitorValueListCtrl.SetBindingData(allValueList);
        }

        //设置测值
        private void barBtnSetMonitorValueList_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            ShowMonitorValueListCtrl();
        }

        #endregion 

        #region 测点标记

        //监测标记辅助类
        private SimulationMonitorMarkerHelper _monitorMarkerHelper = null;

        //获取监测标记辅助类
        private async Task<SimulationMonitorMarkerHelper> GetMonitorMarkerHelper()
        {
            if (_monitorMarkerHelper == null)
            {
                var monitorHelper = GetMonitorHelper();
                var bimfaceCtrl = await GetBimfaceCtrl();
                _monitorMarkerHelper = new SimulationMonitorMarkerHelper(monitorHelper, bimfaceCtrl);
            }
            return _monitorMarkerHelper;
        }

        //测点显示状态改变
        private async void barCkMonitorVisible_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            var monitorMarkerHelper = await GetMonitorMarkerHelper();
            monitorMarkerHelper.Visible = this.barCkMonitorVisible.Checked;
            monitorMarkerHelper.Set();
        }

        #endregion

        #region 模型检查

        //检查控件
        private HydroCheckResultCtrl _checkCtrl = null;

        //获取检查控件
        private HydroCheckResultCtrl GetCheckCtrl()
        {
            if (_hydroInfo == null)
            {
                return default;
            }
            if (_checkCtrl == null)
            {
                _checkCtrl = new HydroCheckResultCtrl();
                _checkCtrl.Dock = DockStyle.Fill;
                _checkCtrl.HydroClickEvent += (code) =>
                {
                    var visualListHelper = GetVisualListHelper();
                    var visual = visualListHelper.GetVisual(code);
                    SelectVisual(visual, eSimulationVisualSource.Check);
                };
            }
            return _checkCtrl;
        }

        //检查控件是否可见
        private bool IsCheckCtrlVisible
        {
            get
            {
                if (this.docPnlBottom.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
                {
                    if (this.controlContainerBottom.Controls.Count > 0)
                    {
                        if (this.controlContainerBottom.Controls[0] is HydroCheckResultCtrl)
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
        }

        //显示检查控件
        private void ShowCheckCtrl(HydroCheckResult checkResult)
        {
            if (checkResult == null)
            {
                return;
            }
            var checkCtrl = GetCheckCtrl();
            if (!IsCheckCtrlVisible)
            {
                this.controlContainerBottom.Controls.Clear();
                this.controlContainerBottom.Controls.Add(checkCtrl);
                this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
                this.docPnlBottom.Text = "检查结果";
                this.docPnlBottom.Height = 350;
            }
            checkCtrl.SetBindingData(checkResult);
        }

        //显示检查控件
        private void ShowCheckCtrl()
        {
            var checkResult = GetCheckResult();
            ShowCheckCtrl(checkResult);
        }

        //检查
        private void barBtnCheck_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var checkResult = _hydroInfo.Check();
            ShowCheckCtrl(checkResult);
        }

        #endregion 模型检查

        #region 模型计算

        #region 计算结果

        //计算结果辅助类
        private SimulationCalcuResultHelper _calcuResultHelper = null;

        //获取计算结果辅助类
        private SimulationCalcuResultHelper GetCalcuResultHelper()
        {
            if (_calcuResultHelper == null)
            {
                var workingHelper = GetWorkingHelper();
                _calcuResultHelper = new SimulationCalcuResultHelper(workingHelper);
            }
            return _calcuResultHelper;
        }

        #endregion

        #region 计算失败

        //计算失败控件
        private HydroCalcuFailedCtrl _calcuFailedCtrl = null;

        //获取计算失败控件
        private HydroCalcuFailedCtrl GetCalcuFailedCtrl()
        {
            if (_calcuFailedCtrl == null)
            {
                _calcuFailedCtrl = new HydroCalcuFailedCtrl();
                _calcuFailedCtrl.Dock = DockStyle.Fill;
            }
            return _calcuFailedCtrl;
        }

        //计算失败控件是否可见
        private bool IsCalcuFailedCtrlVisible
        {
            get
            {
                if (this.docPnlBottom.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
                {
                    if (this.controlContainerBottom.Controls.Count > 0)
                    {
                        if (this.controlContainerBottom.Controls[0] is HydroCalcuFailedCtrl)
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
        }

        //显示计算失败控件
        private void ShowCalcuFailedCtrl(HydroCalcuResult calcuResult)
        {
            if (_hydroInfo == null)
            {
                return;
            }
            if (calcuResult == null)
            {
                return;
            }
            if (calcuResult.Succeed)
            {
                return;
            }
            var calcuFailedCtrl = GetCalcuFailedCtrl();
            if (!IsCalcuFailedCtrlVisible)
            {
                this.controlContainerBottom.Controls.Clear();
                this.controlContainerBottom.Controls.Add(calcuFailedCtrl);
                this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
                this.docPnlBottom.Text = "计算失败原因";
                this.docPnlBottom.Height = 350;
            }
            calcuFailedCtrl.SetBindingData(calcuResult.FailedList);
        }

        #endregion 计算失败

        #region 计算警告

        //计算警告控件
        private HydroCalcuWarningCtrl _calcuWarningCtrl = null;

        //获取计算警告控件
        private HydroCalcuWarningCtrl GetCalcuWarningCtrl()
        {
            if (_calcuWarningCtrl == null)
            {
                _calcuWarningCtrl = new HydroCalcuWarningCtrl();
                _calcuWarningCtrl.Dock = DockStyle.Fill;
                _calcuWarningCtrl.HydroClickEvent += (code) =>
                {
                    var visualListHelper = GetVisualListHelper();
                    var visual = visualListHelper.GetVisual(code);
                    SelectVisual(visual, eSimulationVisualSource.Warning);
                };
            }
            return _calcuWarningCtrl;
        }

        //计算警告控件是否可见
        private bool IsCalcuWarningCtrlVisible
        {
            get
            {
                if (this.docPnlBottom.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
                {
                    if (this.controlContainerBottom.Controls.Count > 0)
                    {
                        if (this.controlContainerBottom.Controls[0] is HydroCalcuWarningCtrl)
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
        }

        //显示计算警告控件
        private void ShowCalcuWarningCtrl(HydroCalcuResult calcuResult)
        {
            if (_hydroInfo == null)
            {
                return;
            }
            if (calcuResult == null)
            {
                return;
            }
            if (!calcuResult.Succeed)
            {
                return;
            }
            var calcuWaringCtrl = GetCalcuWarningCtrl();
            if (!IsCalcuWarningCtrlVisible)
            {
                this.controlContainerBottom.Controls.Clear();
                this.controlContainerBottom.Controls.Add(calcuWaringCtrl);
                this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
                this.docPnlBottom.Text = "计算警告";
                this.docPnlBottom.Height = 350;
            }
            var visualListHelper = GetVisualListHelper();
            var allVisualDict = visualListHelper.GetVisualDict();
            calcuWaringCtrl.SetBindingData(calcuResult.WainingList, allVisualDict);
        }

        #endregion 计算警告

        #region 计算标签

        //计算标签辅助类
        private SimulationCalcuResultLabelHelper _calcuResultLabelHelper = null;

        //获取计算标签辅助类
        private async Task<SimulationCalcuResultLabelHelper> GetCalcuResultLabelHelper()
        {
            if (_calcuResultLabelHelper == null)
            {
                var calcuResultHelper = GetCalcuResultHelper();
                var bimfaceCtrl = await GetBimfaceCtrl();
                _calcuResultLabelHelper = new SimulationCalcuResultLabelHelper(calcuResultHelper, bimfaceCtrl);
            }
            return _calcuResultLabelHelper;
        }

        //设置计算标签是否显示
        private async void barCkCalcu_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            var calcuResultLabelHelper = await GetCalcuResultLabelHelper();
            calcuResultLabelHelper.Visible = this.barCkCalcu.Checked;
            calcuResultLabelHelper.Set();
        }

        #endregion 计算标签

        #endregion

        #region 导出INP

        //导出INP文件
        private void barBtnExportInp_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var fileName = FileDialogHelper.SaveInp("导出Inp文件");
            if (string.IsNullOrEmpty(fileName))
            {
                return;
            }
            var netWork = Yw.Hydro.ParseHelper.ToNetwork(_hydroInfo);
            var result = netWork.ToInpString();
            File.WriteAllText(fileName, result);
            TipFormHelper.ShowSucceed("导出成功");
        }

        #endregion 导出INP

        #region 水泵列表

        //性能曲线
        private void PumpFeat()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var pumps = _hydroInfo.Pumps;
            if (pumps == null || pumps.Count < 1)
            {
                XtraMessageBox.Show("无水泵信息");
                return;
            }
            var dlg = new SimulationPumpFeatDlg();
            dlg.SaveEvent += async (list) =>
            {
                pumps.ForEach(x => x.UpdateWorkingInfo(list));
                var visualVmListHelper = GetVisualVmListHelper();
                visualVmListHelper.UpdateProperty(pumps.Select(x => x as Yw.Model.HydroVisualInfo).ToList());
                SelectVisual(_visual, eSimulationVisualSource.None);
                var gradingHelper = await GetGradingHelper();
                gradingHelper.Set();
            };
            dlg.SetBindingData(_hydroInfo);
            dlg.ShowDialog();
        }

        //性能曲线
        private void barBtnPumpCurve_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            PumpFeat();
        }

        //并联模拟
        private void PumpParallel()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var pumps = _hydroInfo.Pumps;
            if (pumps == null || pumps.Count < 1)
            {
                XtraMessageBox.Show("无水泵信息");
                return;
            }
            var dlg = new SimulationPumpParallelDlg();
            dlg.SaveEvent += async (list) =>
            {
                list?.ForEach(x =>
                {
                    var pump = pumps.Find(t => t.Code == x.Code);
                    if (pump != null)
                    {
                        pump.LinkStatus = x.LinkStatus;
                        pump.SpeedRatio = x.SpeedRatio;
                    }
                });
                var visualVmListHelper = GetVisualVmListHelper();
                visualVmListHelper.UpdateProperty(pumps.Select(x => x as Yw.Model.HydroVisualInfo).ToList());
                SelectVisual(_visual, eSimulationVisualSource.None);
                var gradingHelper = await GetGradingHelper();
                gradingHelper.Set();
            };
            dlg.SetBindingData(_hydroInfo);
            dlg.ShowDialog();
        }

        //并联模拟
        private void barBtnPumpParallel_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            PumpParallel();
        }

        #endregion 水泵列表

        #region 压力切换

        //计算压力是否为绝对压力
        private bool _calcuPressModeIsHead = false;

        //计算结果压力切换
        private void barToggleSwitchPress_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            _calcuPressModeIsHead = !this.barToggleSwitchPress.Checked;
            this.barToggleSwitchPress.Caption = _calcuPressModeIsHead ? "绝对压力" : "自由压力";
            var workingHelper = GetWorkingHelper();
            workingHelper.ResetResult(_calcuPressModeIsHead);
            UpdateVisualListCtrl();
            UpdatePropertyCtrl();
        }

        #endregion 压力切换

        #region 评价规则

        //评价规则辅助类
        private SimulationEvaluationHelper _evaluationHelper = null;

        //获取评价规则辅助类
        private SimulationEvaluationHelper GetEvaluationHelper()
        {
            if (_evaluationHelper == null)
            {
                _evaluationHelper = new SimulationEvaluationHelper(_hydroInfo.ID);
            }
            return _evaluationHelper;
        }

        //获取评价规则列表
        private async Task<List<Yw.Vmo.HydroEvaluationVmo>> GetEvaluationList()
        {
            var helper = GetEvaluationHelper();
            return await helper.GetEvaluationList();
        }

        //设置评价规则列表
        private void SetEvaluationList(List<Yw.Vmo.HydroEvaluationVmo> allEvaluationList)
        {
            var helper = GetEvaluationHelper();
            helper.SetEvaluationList(allEvaluationList);
        }

        //显示评价窗体
        private void ShowEvaluationDlg()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var dlg = new SetHydroEvaluationModelDlg();
            dlg.SetBindingData(_hydroInfo.ID);
            dlg.ReloadDataEvent += (rhs) =>
            {
                SetEvaluationList(rhs);
            };
            dlg.ShowDialog();
        }

        //评价规则
        private void barBtnEvaluation_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            ShowEvaluationDlg();
        }

        #endregion

        #region 水力计算

        //计算
        private async void Calcu()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var workingCheckedListHelper = GetWorkingCheckedListHelper();
            var allWorkingList = workingCheckedListHelper.GetWorkingList();
            var monitorValueHelper = GetMonitorValueHelper();
            var allMonitorValueList = await monitorValueHelper.GetAll();
            var dlg = new SetHydroWorkingDlg();
            dlg.SetBindingData(_hydroInfo, allWorkingList, allMonitorValueList);
            dlg.HydroViewEvent += (visual) =>
            {
                SelectVisual(visual, eSimulationVisualSource.Calcu);
            };
            dlg.HydroCalcuEvent += async (vm) =>
            {
                _hydroInfo.UpdateWorkingInfo(vm.WorkingInfo);
                allMonitorValueList.UpdateMonitorValue(vm.MonitorInfo);

                var hydroInfo = _hydroInfo.Adapt<Yw.Model.HydroModelInfo>();

                var working = new HydroWorkingVmo();
                working.ModelID = vm.ModelID;
                working.Name = vm.Name;
                working.WorkingInfo = JsonHelper.Object2Json(vm.WorkingInfo);
                var useWorkingMonitorInfo = vm.MonitorInfo?.Where(x => x.PropValue.HasValue).ToList();
                if (useWorkingMonitorInfo != null && useWorkingMonitorInfo.Count > 0)
                {
                    working.MonitorInfo = JsonHelper.Object2Json(useWorkingMonitorInfo);
                }
                working.SortCode = vm.SortCode;
                working.Description = vm.Description;

                var workingHelper = GetWorkingHelper();
                //校验
                var checkResult = _hydroInfo.Check();
                if (!checkResult.Succeed)
                {
                    ShowCheckCtrl(checkResult);
                    workingHelper.InitialData(hydroInfo, working, checkResult, null);
                    TipFormHelper.ShowError("校验失败，请检查后重试");
                    return;
                }

                var isHead = _calcuPressModeIsHead;
                var allEvaluationList = await GetEvaluationList();

                WaitFormHelper.ShowWaitForm(this, "正在计算分析中，请稍候...");
                await Task.Delay(3000);
                var calcuResult = _hydroInfo.Calcu(isHead, allEvaluationList);
                WaitFormHelper.HideWaitForm();
                workingHelper.InitialData(hydroInfo, working, checkResult, calcuResult);
                if (calcuResult.Succeed)
                {
                    if (calcuResult.WainingList != null && calcuResult.WainingList.Count > 0)
                    {
                        ShowCalcuWarningCtrl(calcuResult);
                    }
                    this.barBtnAddWorking.Enabled = true;
                    this.barBtnExportWord.Enabled = true;
                    TipFormHelper.ShowSucceed("计算成功！");
                }
                else
                {
                    ShowCalcuFailedCtrl(calcuResult);
                    TipFormHelper.ShowError("计算失败！");
                }

                #region 视图列表

                var visualVmListHelper = GetVisualVmListHelper();
                visualVmListHelper.UpdateCalcuProperty(calcuResult);

                #endregion 视图列表

                #region 当前构件

                SelectVisual(_visual, eSimulationVisualSource.Calcu);

                #endregion 当前构件

                #region 构件明细

                UpdateVisualListCtrl();

                #endregion 构件明细

                #region 颜色分级

                var gradingHelper = await GetGradingHelper();
                gradingHelper.Set();

                #endregion 颜色分级

                #region 计算标签

                var calcuResultLabelHelper = await GetCalcuResultLabelHelper();
                calcuResultLabelHelper.Set();

                #endregion 计算标签
            };
            dlg.ShowDialog();
        }

        //水力计算
        private void barBtnCalcu_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            Calcu();
        }

        #endregion 水力计算

        #region 导出报告

        //创建打印信息
        private async Task<SimulationPrintViewModel> CreatePrintInfo()
        {
            if (_project == null)
            {
                return default;
            }
            if (_hydroInfo == null)
            {
                return default;
            }

            #region 工况列表

            var allWorkingList = GetCheckedWorkingList();
            if (allWorkingList == null || allWorkingList.Count < 1)
            {
                var working = GetWorking();
                if (working == null)
                {
                    TipFormHelper.ShowWarn("请计算或选择工况后重试！");
                    return default;
                }
                allWorkingList = new List<HydroWorkingVmo>() { working };
            }

            #endregion 工况列表

            #region 选择节点

            var selectedNode = GetSelectNode();
            if (selectedNode == null)
            {
                return default;
            }

            #endregion 选择节点

            var vm = new SimulationPrintViewModel();

            #region 项目

            vm.Project = new SimulationPrintProjectViewModel(_project);
            if (_hydroInfo == null)
            {
                return vm;
            }

            #endregion 项目

            #region 水泵列表

            vm.PumpList = _hydroInfo.Pumps?.Select(x =>
                {
                    var pump = new SimulationPrintPumpViewModel(x);
                    return pump;
                }).ToList();

            #endregion 水泵列表

            #region 附加信息

            var allMonitorList = await GetMonitorList();
            var allEvaluationList = await GetEvaluationList();

            #endregion 附加信息

            #region 基础模型

            var baseHydroInfo = _hydroInfo;
            if (_scheme != null)
            {
                baseHydroInfo = await GetModelEvent?.Invoke(null);
            }
            var baseHydroInfoRhs = baseHydroInfo.Adapt<Yw.Model.HydroModelInfo>();

            #endregion 基础模型

            #region 遍历工况

            vm.WorkingList = new List<SimulationPrintWorkingViewModel>();
            foreach (var working in allWorkingList)
            {
                baseHydroInfoRhs.UpdateWorkingInfo(working.WorkingInfo);
                var calcuResult = baseHydroInfoRhs.Calcu(_calcuPressModeIsHead, allEvaluationList);

                var printWorking = new SimulationPrintWorkingViewModel(working);
                vm.WorkingList.Add(printWorking);

                //精度评估
                printWorking.Accuracy = HydroAccuracyHelper.Create(baseHydroInfoRhs, allMonitorList, working, calcuResult, _calcuPressModeIsHead, allEvaluationList);
                //水泵分析
                printWorking.PumpAnaly = HydroPumpAnalyHelper.Create(baseHydroInfoRhs, working, calcuResult, _calcuPressModeIsHead, allEvaluationList);
                //监测分析
                printWorking.MonitorAnaly = HydroMonitorAnalyHelper.Create(baseHydroInfoRhs, allMonitorList, working, calcuResult, _calcuPressModeIsHead, allEvaluationList);
                //能耗分析
                printWorking.EnergyAnaly = HydroEnergyAnalyHelper.Create(baseHydroInfoRhs, working, calcuResult, _calcuPressModeIsHead, allEvaluationList);
                //损失统计
                printWorking.LossStatistics = HydroLossStatisticsHelper.Create(baseHydroInfoRhs, working, calcuResult, _calcuPressModeIsHead, allEvaluationList);
                //损失曲线
                printWorking.LossCurve = HydroLossCurveHelper.Create(baseHydroInfoRhs, working, selectedNode, calcuResult, _calcuPressModeIsHead, allEvaluationList);
            }

            #endregion 遍历工况

            #region 方案处理

            if (_scheme != null)
            {
                var hydroInfo = _hydroInfo;
                var hydroInfoRhs = hydroInfo.Adapt<Yw.Model.HydroModelInfo>();
                vm.Scheme = new SimulationPrintSchemeViewModel(_scheme);
                foreach (var working in allWorkingList)
                {
                    hydroInfoRhs.UpdateWorkingInfo(working.WorkingInfo);
                    var calcuResult = hydroInfoRhs.Calcu(_calcuPressModeIsHead, allEvaluationList);

                    var printWorking = new SimulationPrintWorkingViewModel(working);
                    vm.Scheme.WorkingList.Add(printWorking);

                    //精度评估
                    printWorking.Accuracy = HydroAccuracyHelper.Create(hydroInfoRhs, allMonitorList, working, calcuResult, _calcuPressModeIsHead, allEvaluationList);
                    //水泵分析
                    printWorking.PumpAnaly = HydroPumpAnalyHelper.Create(hydroInfoRhs, working, calcuResult, _calcuPressModeIsHead, allEvaluationList);
                    //监测分析
                    printWorking.MonitorAnaly = HydroMonitorAnalyHelper.Create(hydroInfoRhs, allMonitorList, working, calcuResult, _calcuPressModeIsHead, allEvaluationList);
                    //能耗分析
                    printWorking.EnergyAnaly = HydroEnergyAnalyHelper.Create(hydroInfoRhs, working, calcuResult, _calcuPressModeIsHead, allEvaluationList);
                    //损失统计
                    printWorking.LossStatistics = HydroLossStatisticsHelper.Create(hydroInfoRhs, working, calcuResult, _calcuPressModeIsHead, allEvaluationList);
                    //损失曲线
                    printWorking.LossCurve = HydroLossCurveHelper.Create(hydroInfoRhs, working, selectedNode, calcuResult, _calcuPressModeIsHead, allEvaluationList);
                }
            }

            #endregion 方案处理

            return vm;
        }

        //导出word
        private async void barBtnExportWord_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            var printInfo = await CreatePrintInfo();
            var printDlg = new HStation.WinFrmUI.SimulationCommonReportDlg();
            printDlg.SetBindingData(printInfo);
            printDlg.ShowDialog();
            /*    if (_visual == null)
                {
                    SelectInputSource();
                    if (_visual == null)
                    {
                        TipFormHelper.ShowWarn("请选择构件后重试！");
                        return;
                    }
                }
                HydroVisualInfo visual = _visual;
                if (_visual is HydroLinkInfo linkInfo)
                {
                    var visualListHelper = GetVisualListHelper();
                    visual = visualListHelper.GetVisual(linkInfo.StartCode);
                }

                var allMonitorList = await GetMonitorList();
                var working = GetWorking();
                var calcuResult = GetCalcuResult();

                var dlg = new SimulationWorkingReportDlg();
                dlg.ReloadDataEvent += (vm) =>
                {
                    var fileName = FileDialogHelper.SaveWordDoc("导出Word报告");
                    if (string.IsNullOrEmpty(fileName))
                    {
                        return;
                    }
                    var reportHelper = new HStation.ReportFile.SimulationWorkingReportHelper();
                    reportHelper.Create(fileName, vm);
                    TipFormHelper.ShowInfo("导出成功！");
                };
                dlg.SetBindingData(_project, _hydroInfo, allMonitorList, working, calcuResult, visual);
                dlg.ShowDialog();*/
        }

        #endregion 导出报告

        #region 当前工况

        //工况辅助类
        private SimulationWorkingHelper _workingHelper = null;

        //获取工况辅助类
        private SimulationWorkingHelper GetWorkingHelper()
        {
            if (_workingHelper == null)
            {
                _workingHelper = new SimulationWorkingHelper();
            }
            return _workingHelper;
        }

        //获取工况
        private HydroWorkingVmo GetWorking()
        {
            var workingHelper = GetWorkingHelper();
            return workingHelper.Working;
        }

        //获取检查结果
        private HydroCheckResult GetCheckResult()
        {
            var workingHelper = GetWorkingHelper();
            return workingHelper.CheckResult;
        }

        //获取计算结果
        private HydroCalcuResult GetCalcuResult()
        {
            var workingHelper = GetWorkingHelper();
            return workingHelper.CalcuResult;
        }

        //新增工况
        private void AddWorking()
        {
            var workingHelper = GetWorkingHelper();
            if (workingHelper.Working == null)
            {
                TipFormHelper.ShowWarn("尚未计算，请计算后重试！");
                return;
            }
            var dlg = new AddHydroWorkingDlg();
            dlg.SetBindingData(workingHelper.Working);
            dlg.ReloadDataEvent += (rhs) =>
            {
                this.barBtnAddWorking.Enabled = false;
                workingHelper.ResetWorking(rhs);
                UpdateWorkingCheckedList(rhs, false);
                this.AppendWorkingEvent?.Invoke(rhs);
            };
            dlg.ShowDialog();
        }

        //增加工况
        private void barBtnAddWorking_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            AddWorking();
        }

        #endregion 当前工况

        #region 选择工况

        //工况选择列表辅助类
        private SimulationWorkingCheckedListHelper _workingCheckedListHelper = null;

        //获取工况元组辅助类
        private SimulationWorkingCheckedListHelper GetWorkingCheckedListHelper()
        {
            if (_workingCheckedListHelper == null)
            {
                _workingCheckedListHelper = new SimulationWorkingCheckedListHelper();
                _workingCheckedListHelper.InitialData(_allWorkingCheckedListDict);
            }
            return _workingCheckedListHelper;
        }

        //获取工况字典
        private Dictionary<HydroWorkingVmo, bool> GetWorkingDict()
        {
            var helper = GetWorkingCheckedListHelper();
            return helper.GetWorkingDict();
        }

        //获取工况列表
        private List<HydroWorkingVmo> GetWorkingList()
        {
            var helper = GetWorkingCheckedListHelper();
            return helper.GetWorkingList();
        }

        //获取选择工况列表
        private List<HydroWorkingVmo> GetCheckedWorkingList()
        {
            var helper = GetWorkingCheckedListHelper();
            return helper.GetCheckedWorkingList();
        }

        //更新工况选择列表
        public void UpdateWorkingCheckedList(HydroWorkingVmo working)
        {
            var helper = GetWorkingCheckedListHelper();
            helper.Update(working);
        }

        //更新工况选择列表
        public void UpdateWorkingCheckedList(HydroWorkingVmo working, bool hasChecked)
        {
            var helper = GetWorkingCheckedListHelper();
            helper.Update(working, hasChecked);
        }

        //移除工况选择列表
        public void RemoveWorkingCheckedList(HydroWorkingVmo working)
        {
            var helper = GetWorkingCheckedListHelper();
            helper.Remove(working);
        }

        /// <summary>
        /// 重载工况选择列表
        /// </summary>
        public void ReloadWorkingCheckedList(Dictionary<HydroWorkingVmo, bool> dict)
        {
            var helper = GetWorkingCheckedListHelper();
            helper.InitialData(dict);
        }

        //管理工况
        private void barBtnMgrWorking_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            var dict = GetWorkingDict();
            var dlg = new HydroWorkingMgrDlg();
            dlg.ReloadDataEvent += (dict) =>
            {
                this.ReloadWorkingEvent?.Invoke(dict);
            };
            dlg.UpdateDataEvent += (rhs) =>
            {
                this.UpdateWorkingEvent?.Invoke(rhs);
            };
            dlg.ApplyDataEvent += async (rhs) =>
            {
                _hydroInfo.UpdateWorkingInfo(rhs.WorkingInfo);
                var monitorValueHelper = GetMonitorValueHelper();
                var allMonitorValueList = await monitorValueHelper.GetAll();
                allMonitorValueList.UpdateMonitorValue(rhs.MonitorInfo);
                var gradingHelper = await GetGradingHelper();
                gradingHelper.Set();
            };
            dlg.DeleteDataEvent += (rhs) =>
            {
                this.RemoveWorkingEvent?.Invoke(rhs);
            };
            dlg.SetBindingData(dict);
            dlg.ShowDialog();
        }

        #endregion 选择工况

        #region 监测分析

        //监测分析列表控件
        private HydroMonitorAnalyListCtrl _monitorAnalyListCtrl = null;

        //获取监测分析列表控件
        private HydroMonitorAnalyListCtrl GetMonitorAnalyListCtrl()
        {
            if (_monitorAnalyListCtrl == null)
            {
                _monitorAnalyListCtrl = new HydroMonitorAnalyListCtrl();
                _monitorAnalyListCtrl.Dock = DockStyle.Fill;
                _monitorAnalyListCtrl.HydroViewEvent += (code) =>
                {
                    var visual = GetVisual(code);
                    SelectVisual(visual, eSimulationVisualSource.Monitor);
                };
            }
            return _monitorAnalyListCtrl;
        }

        //监测分析列表控件是否可见
        private bool IsMonitorAnalyListCtrlVisible
        {
            get
            {
                if (this.docPnlBottom.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
                {
                    if (this.controlContainerBottom.Controls.Count > 0)
                    {
                        if (this.controlContainerBottom.Controls[0] is HydroMonitorAnalyListCtrl)
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
        }

        //显示监测分析列表控件
        private async void ShowMonitorAnalyListCtrl()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var allWorkingList = GetCheckedWorkingList();
            if (allWorkingList == null || allWorkingList.Count < 1)
            {
                var workingHelper = GetWorkingHelper();
                if (!workingHelper.Initialized)
                {
                    TipFormHelper.ShowWarn("请计算后重试！");
                    return;
                }
            }

            var monitorAnalyListCtrl = GetMonitorAnalyListCtrl();
            if (!IsMonitorAnalyListCtrlVisible)
            {
                this.controlContainerBottom.Controls.Clear();
                this.controlContainerBottom.Controls.Add(monitorAnalyListCtrl);
                this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
                this.docPnlBottom.Text = "监测分析";
                this.docPnlBottom.Height = 350;
            }

            var allMonitorList = await GetMonitorList();
            var isHead = _calcuPressModeIsHead;
            var allEvaluationList = await GetEvaluationList();

            if (allWorkingList == null || allWorkingList.Count < 1)
            {
                var workingHelper = GetWorkingHelper();
                monitorAnalyListCtrl.SetBindingData(workingHelper.HydroInfo, allMonitorList, workingHelper.Working, workingHelper.CalcuResult, isHead, allEvaluationList);
            }
            else
            {
                monitorAnalyListCtrl.SetBindingData(_hydroInfo, allMonitorList, allWorkingList, isHead, allEvaluationList);
            }
        }

        //监测分析
        private void barBtnWorkingMonitorAnaly_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            ShowMonitorAnalyListCtrl();
        }

        #endregion

        #region 工况分析

        //选择进口水源
        private void SelectInputSource()
        {
            var sources = GetSourceList();
            if (sources != null)
            {
                if (sources.Count == 1)
                {
                    SelectVisual(sources[0], eSimulationVisualSource.None);
                }
                else
                {
                    var source = sources.FirstOrDefault(x => x.Flags.Contains(HStation.Xhs.Flags.进口));
                    if (source != null)
                    {
                        SelectVisual(source, eSimulationVisualSource.None);
                    }
                }
            }
        }

        //获取选择节点
        private HydroNodeInfo GetSelectNode()
        {
            if (_visual == null)
            {
                SelectInputSource();
                if (_visual == null)
                {
                    TipFormHelper.ShowWarn("请选择构件后重试！");
                    return null;
                }
            }
            HydroVisualInfo visual = _visual;
            if (_visual is HydroLinkInfo linkInfo)
            {
                var visualListHelper = GetVisualListHelper();
                visual = visualListHelper.GetVisual(linkInfo.StartCode);
            }
            return visual as HydroNodeInfo;
        }

        //精度评估
        private async void barBtnAccuracy_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (_hydroInfo == null)
            {
                return;
            }

            var allMonitorList = await GetMonitorList();
            if (allMonitorList == null || allMonitorList.Count < 1)
            {
                TipFormHelper.ShowWarn("请设置监测点后重试！");
                return;
            }

            var isHead = _calcuPressModeIsHead;
            var allEvaluationList = await GetEvaluationList();

            var workingList = GetCheckedWorkingList();
            if (workingList == null || workingList.Count < 1)
            {
                var allMonitorValueList = await GetMonitorValueList();
                allMonitorValueList = allMonitorValueList?.Where(x => x.PropValue.HasValue).ToList();
                if (allMonitorValueList == null || allMonitorValueList.Count < 1)
                {
                    TipFormHelper.ShowWarn("请设置监测值后，重新计算！");
                    return;
                }

                var workingHelper = GetWorkingHelper();
                if (!workingHelper.Initialized)
                {
                    TipFormHelper.ShowWarn("请计算后重试！");
                    return;
                }
                var dlg = new HydroAccuracyDlg();
                dlg.SetBindingData(workingHelper.HydroInfo, allMonitorList, workingHelper.Working, workingHelper.CalcuResult, isHead, allEvaluationList);
                dlg.ShowDialog();
                return;
            }

            var workingDlg = new HydroAccuracyWorkingDlg();
            workingDlg.SetBindingData(_hydroInfo, allMonitorList, workingList, isHead, allEvaluationList);
            workingDlg.ShowDialog();
        }

        //水泵分析
        private async void barBtnPumpAnaly_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var isHead = _calcuPressModeIsHead;
            var allEvaluationList = await GetEvaluationList();

            var workingList = GetCheckedWorkingList();
            if (workingList == null || workingList.Count < 1)
            {
                var workingHelper = GetWorkingHelper();
                if (!workingHelper.Initialized)
                {
                    TipFormHelper.ShowWarn("请计算后重试！");
                    return;
                }
                var dlg = new SimulationPumpAnalyDlg();
                dlg.SetBindingData(workingHelper.HydroInfo, workingHelper.Working, workingHelper.CalcuResult, isHead, allEvaluationList);
                dlg.ShowDialog();
                return;
            }

            var workingDlg = new SimulationPumpAnalyWorkingDlg();
            workingDlg.SetBindingData(_hydroInfo, workingList, isHead, allEvaluationList);
            workingDlg.ShowDialog();
        }

        //能效分析
        private async void barBtnEnergyAnaly_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (_hydroInfo == null)
            {
                return;
            }

            var isHead = _calcuPressModeIsHead;
            var allEvaluationList = await GetEvaluationList();

            var workingList = GetCheckedWorkingList();
            if (workingList == null || workingList.Count < 1)
            {
                var workingHelper = GetWorkingHelper();
                if (!workingHelper.Initialized)
                {
                    TipFormHelper.ShowWarn("请计算后重试！");
                    return;
                }
                var dlg = new SimulationEnergyAnalyDlg();
                dlg.SetBindingData(workingHelper.HydroInfo, workingHelper.Working, workingHelper.CalcuResult, isHead, allEvaluationList);
                dlg.ShowDialog();
                return;
            }
            var workingDlg = new SimulationEnergyAnalyWorkingDlg();
            workingDlg.SetBindingData(_hydroInfo, workingList, isHead, allEvaluationList);
            workingDlg.ShowDialog();
        }

        //损失统计
        private async void barBtnWorkingLossStatistics_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var hydroInfo = _hydroInfo.Adapt<Yw.Model.HydroModelInfo>();
            var isHead = _calcuPressModeIsHead;
            var allEvaluationList = await GetEvaluationList();

            var workingList = GetCheckedWorkingList();
            if (workingList == null || workingList.Count < 1)
            {
                var workingHelper = GetWorkingHelper();
                if (!workingHelper.Initialized)
                {
                    TipFormHelper.ShowWarn("请计算后重试！");
                    return;
                }
                var dlg = new HydroLossStatisticsDlg();
                dlg.SetBindingData(hydroInfo, workingHelper.Working, workingHelper.CalcuResult, isHead, allEvaluationList);
                dlg.ShowDialog();
                return;
            }

            var workingDlg = new HydroLossStatisticsWorkingDlg();
            workingDlg.SetBindingData(hydroInfo, workingList, isHead, allEvaluationList);
            workingDlg.ShowDialog();
        }

        //综合分析
        private async void barBtnWorkingAnaly_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (_hydroInfo == null)
            {
                return;
            }

            var selectNode = GetSelectNode();
            if (selectNode == null)
            {
                return;
            }

            var allMonitorList = await GetMonitorList();
            var isHead = _calcuPressModeIsHead;
            var allEvaluationList = await GetEvaluationList();

            var workingList = GetCheckedWorkingList();
            if (workingList == null || workingList.Count < 1)
            {
                var workingHelper = GetWorkingHelper();
                if (!workingHelper.Initialized)
                {
                    TipFormHelper.ShowWarn("请计算后重试！");
                    return;
                }
                var dlg = new SimulationMultiAnalyDlg();
                dlg.SetBindingData(workingHelper.HydroInfo, allMonitorList, workingHelper.Working, selectNode, workingHelper.CalcuResult, isHead, allEvaluationList);
                dlg.ShowDialog();
                return;
            }

            var workingDlg = new SimulationMultiAnalyWorkingDlg();
            workingDlg.SetBindingData(_hydroInfo, allMonitorList, workingList, selectNode, isHead, allEvaluationList);
            workingDlg.ShowDialog();
        }

        #endregion

        #region 损失曲线

        //损失曲线交互控件
        private HydroLossCurveInteropCtrl _lossCurveInteropCtrl = null;

        //获取损失曲线交互控件
        private HydroLossCurveInteropCtrl GetLossCurveInteropCtrl()
        {
            if (_lossCurveInteropCtrl == null)
            {
                _lossCurveInteropCtrl = new HydroLossCurveInteropCtrl();
                _lossCurveInteropCtrl.Dock = DockStyle.Fill;
                _lossCurveInteropCtrl.HydroClickEvent += (code) =>
                {
                    var visual = GetVisual(code);
                    SelectVisual(visual, eSimulationVisualSource.None);
                };
                _lossCurveInteropCtrl.HydroSpecialDisplayEvent += (list) =>
                {
                    _bimfaceCtrl?.SetLogicOutlineGlowEffect(list);
                };
                _lossCurveInteropCtrl.HydroCancelSpecialDisplayEvent += () =>
                {
                    _bimfaceCtrl?.RemoveLogicOutlineGlowEffect();
                };
            }
            return _lossCurveInteropCtrl;
        }

        //损失曲线控件是否可见
        private bool IsLossCurveInteropCtrlVisible
        {
            get
            {
                if (this.docPnlBottom.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
                {
                    if (this.controlContainerBottom.Controls.Count > 0)
                    {
                        if (this.controlContainerBottom.Controls[0] is HydroLossCurveInteropCtrl)
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
        }

        //显示损失曲线控件
        private void ShowLossCurveInteropCtrl
            (
                Yw.Model.HydroModelInfo hydroInfo,
                HydroWorkingVmo working,
                HydroNodeInfo node,
                HydroCalcuResult calcuResult = null,
                bool isHead = false,
                List<HydroEvaluationVmo> allEvaluationList = null
            )
        {
            var ctrl = GetLossCurveInteropCtrl();
            if (!IsLossCurveInteropCtrlVisible)
            {
                this.controlContainerBottom.Controls.Clear();
                this.controlContainerBottom.Controls.Add(ctrl);
                this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
                this.docPnlBottom.Text = "损失曲线";
                this.docPnlBottom.Height = 350;
            }
            ctrl.SetBindingData(hydroInfo, working, node, calcuResult, isHead, allEvaluationList);
        }

        //损失曲线
        private async void barBtnLossCurve_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            var node = GetSelectNode();
            if (node == null)
            {
                return;
            }

            var isHead = _calcuPressModeIsHead;
            var allEvaluationList = await GetEvaluationList();

            var workingList = GetCheckedWorkingList();
            if (workingList == null || workingList.Count < 1)
            {
                var workingHelper = GetWorkingHelper();
                if (!workingHelper.Initialized)
                {
                    TipFormHelper.ShowWarn("请计算后重试！");
                    return;
                }
                ShowLossCurveInteropCtrl(workingHelper.HydroInfo, workingHelper.Working, node, workingHelper.CalcuResult, isHead, allEvaluationList);
                return;
            }

            var dlg = new HydroLossCurveMultiWorkingDlg();
            dlg.SetBindingData(_hydroInfo, workingList, node, _calcuPressModeIsHead, allEvaluationList);
            dlg.ShowDialog();
        }

        #endregion 损失曲线

        #region 方案管理

        //更新方案
        private void UpdateScheme()
        {
            if (_scheme == null)
            {
                return;
            }
            if (_hydroInfo == null)
            {
                return;
            }

            var dlg = new EditXhsSchemeDlg();
            dlg.SetBindingData(_scheme, _hydroInfo);
            dlg.ReloadDataEvent += (rhs) =>
            {
                _scheme = rhs;
                this.PageTitle.Caption = $"模拟方案\r\n{_scheme.Name}";
                UpdatePageTitle(this.PageGuid, this.PageTitle);
                this.UpdateSchemeEvent?.Invoke(_scheme);
            };
            dlg.ShowDialog();
        }

        //编辑方案
        private void barBtnEditScheme_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            UpdateScheme();
        }

        //删除方案
        private async void DeleteScheme()
        {
            var bol = XtraMessageBox.Show("请问是否删除当前方案？", "询问", MessageBoxButtons.YesNo) == DialogResult.Yes;
            if (!bol)
            {
                return;
            }
            if (_scheme == null)
            {
                return;
            }
            var relation = await BLLFactory<Yw.BLL.HydroModelRelation>.Instance
                .GetDefaultByObjectTypeAndObjectIDOfPurpose(HStation.Xhs.DataType.XhsScheme, _scheme.ID, HStation.Xhs.Purpose.Simulation);
            if (relation == null)
            {
                TipFormHelper.ShowError("水力模拟方案删除失败，请重试！");
                return;
            }
            if (!await BLLFactory<Yw.BLL.HydroModelInfo>.Instance.DeleteByID(relation.ModelID))
            {
                TipFormHelper.ShowError("水力模拟方案删除失败，请重试！");
                return;
            }

            if (!await BLLFactory<HStation.BLL.XhsScheme>.Instance.DeleteByID(_scheme.ID))
            {
                TipFormHelper.ShowError("水力模拟方案删除失败，请重试！");
                return;
            }
            this.RemoveSchemeEvent?.Invoke(_scheme);
            TipFormHelper.ShowSucceed("水力模拟方案删除成功！");
            ClosePage(this.PageGuid);
        }

        //删除方案
        private void barBtnDeleteScheme_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            DeleteScheme();
        }

        #endregion 方案管理


    }
}