using Yw.Model;

namespace HStation.WinFrmUI
{
    /// <summary>
    /// 项目模拟属性控件
    /// </summary>
    public partial class SimulationPropertyCtrl : DevExpress.XtraEditors.XtraUserControl
    {
        public SimulationPropertyCtrl()
        {
            InitializeComponent();
            this.hydroVisualPropertyCtrl1.MatchingDbEvent += HydroVisualPropertyCtrl1_MatchingDbEvent;
            this.hydroVisualPropertyCtrl1.SetCurveEvent += HydroVisualPropertyCtrl1_SetCurveEvent;

            this.hydroVisualPropertyCtrl1.HydroViewEvent += HydroVisualPropertyCtrl1_HydroViewEvent;
            this.hydroVisualPropertyCtrl1.BlinkLinkNodeEvent += HydroVisualPropertyCtrl1_BlinkLinkNodeEvent;
            this.hydroVisualPropertyCtrl1.PropertyValueChangedEvent += HydroVisualPropertyCtrl1_PropertyValueChangedEvent;
            this.hydroVisualPropertyCtrl1.MarkPropertyValueChangedEvent += HydroVisualPropertyCtrl1_MarkPropertyValueChangedEvent;
            this.hydroVisualPropertyCtrl1.GradingPropertyValueChangedEvent += HydroPVisualPropertyCtrl1_GradingPropertyValueChangedEvent;
            this.hydroVisualPropertyCtrl1.FlowDirectionPropertyValueChangedEvent+=HydroVisualPropertyCtrl1_FlowDirectionPropertyValueChangedEvent;
        }



        #region 事件集合

        /// <summary>
        /// 构件查看事件
        /// </summary>
        public event Action<HydroVisualInfo> HydroViewEvent;
        /// <summary>
        /// 强调连接组件事件
        /// 第一个参数为组件
        /// 第二个参数为连接节点Code
        /// </summary>
        public event Action<HydroLinkInfo, string> BlinkLinkNodeEvent;
        /// <summary>
        /// 属性值改变事件
        /// </summary>
        public event Action<HydroVisualInfo> PropertyValueChangedEvent;
        /// <summary>
        /// 标注属性值改变事件
        /// </summary>
        public event Action<HydroVisualInfo> MarkPropertyValueChangedEvent;
        /// <summary>
        /// 分级属性值改变事件
        /// </summary>
        public event Action<HydroVisualInfo> GradingPropertyValueChangedEvent;
        /// <summary>
        /// 流向属性值改变事件
        /// </summary>
        public event Action<HydroVisualInfo> FlowDirectionPropertyValueChangedEvent;

        private HydroChangeHelper _changeHelper = null;//改变辅助类
        private HydroPropStatusHelper _propStatusHelper = null;//属性状态辅助类

        #endregion

        /// <summary>
        /// 初始化数据
        /// </summary>
        public void InitialData
            (
                HydroChangeHelper changeHelper,
                HydroPropStatusHelper propStatusHelper
            )
        {
            _changeHelper = changeHelper;
            _propStatusHelper = propStatusHelper;
            this.hydroVisualPropertyCtrl1.InitialData(changeHelper, propStatusHelper);
        }

        #region 属性赋值

        /// <summary>
        /// 允许编辑
        /// </summary>
        public bool AllowEdit
        {
            get { return this.hydroVisualPropertyCtrl1.AllowEdit; }
            set { this.hydroVisualPropertyCtrl1.AllowEdit = value; }
        }

        /// <summary>
        /// 选择对象
        /// </summary>
        public HydroVisualViewModel SelectedObject
        {
            get { return this.hydroVisualPropertyCtrl1.SelectedObject; }
            set { this.hydroVisualPropertyCtrl1.SelectedObject = value; }
        }

        /// <summary>
        /// 计算结果
        /// </summary>
        public Func<HydroCalcuResult> CalcuResult { get; set; }

        #endregion

        #region 属性更新

        /// <summary>
        /// 重新载入数据
        /// </summary>
        public void UpdateData()
        {
            this.hydroVisualPropertyCtrl1?.UpdateData();
        }

        /// <summary>
        /// 更新行，样式不变
        /// </summary>
        public void UpdateRows()
        {
            this.hydroVisualPropertyCtrl1?.UpdateRows();
        }

        /// <summary>
        /// 更新属性
        /// </summary>
        public void UpdateProperty()
        {
            var vm = this.hydroVisualPropertyCtrl1.SelectedObject;
            if (vm == null)
            {
                return;
            }
            vm.UpdateProperty();
            this.hydroVisualPropertyCtrl1.UpdateRows();
        }

        #endregion

        #region 事件实现

        //匹配Db
        private void HydroVisualPropertyCtrl1_MatchingDbEvent(HydroVisualViewModel vm)
        {
            if (vm == null)
            {
                return;
            }
            switch (vm.Vmo.Catalog)
            {
                case Yw.Hydro.ParterCatalog.Tank:
                    {
                        var tankViewModel = vm as HydroTankViewModel;
                        var input = HydroMatchingHelper.Create(tankViewModel);
                        var dlg = new AssetsTankSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(tankViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Waterbox:
                    {
                        var tankViewModel = vm as HydroTankViewModel;
                        var input = HydroMatchingHelper.Create(tankViewModel);
                        var dlg = new AssetsTankSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(tankViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Blunthead:
                    {
                        var bluntheadViewModel = vm as HydroBluntheadViewModel;
                        var input = HydroMatchingHelper.Create(bluntheadViewModel);
                        var dlg = new AssetsBluntheadSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(bluntheadViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Elbow:
                    {
                        var elbowViewModel = vm as HydroElbowViewModel;
                        var input = HydroMatchingHelper.Create(elbowViewModel);
                        var dlg = new AssetsElbowSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(elbowViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Threelink:
                    {
                        var threelinkViewModel = vm as HydroThreelinkViewModel;
                        var input = HydroMatchingHelper.Create(threelinkViewModel);
                        var dlg = new AssetsThreelinkSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(threelinkViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Fourlink:
                    {
                        var fourlinkViewModel = vm as HydroFourlinkViewModel;
                        var input = HydroMatchingHelper.Create(fourlinkViewModel);
                        var dlg = new AssetsFourlinkSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(fourlinkViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Meter:
                    {
                        var meterViewModel = vm as HydroMeterViewModel;
                        var input = HydroMatchingHelper.Create(meterViewModel);
                        var dlg = new AssetsMeterSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(meterViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Flowmeter:
                    {
                        var flowmeterViewModel = vm as HydroFlowmeterViewModel;
                        var input = HydroMatchingHelper.Create(flowmeterViewModel);
                        var dlg = new AssetsFlowmeterSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(flowmeterViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Pressmeter:
                    {
                        var pressmeterViewModel = vm as HydroPressmeterViewModel;
                        var input = HydroMatchingHelper.Create(pressmeterViewModel);
                        var dlg = new AssetsPressmeterSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(pressmeterViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Nozzle:
                    {
                        var nozzleViewModel = vm as HydroNozzleViewModel;
                        var input = HydroMatchingHelper.Create(nozzleViewModel);
                        var dlg = new AssetsSprinklerSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(nozzleViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Hydrant:
                    {
                        var hydrantViewModel = vm as HydroHydrantViewModel;
                        var input = HydroMatchingHelper.Create(hydrantViewModel);
                        var dlg = new AssetsHydrantSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(hydrantViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Cooling:
                    {
                        var coolingViewModel = vm as HydroCoolingViewModel;
                        var input = HydroMatchingHelper.Create(coolingViewModel);
                        var dlg = new AssetsCoolingSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(coolingViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Pipe:
                    {
                        var pipeViewModel = vm as HydroPipeViewModel;
                        var input = HydroMatchingHelper.Create(pipeViewModel);
                        var dlg = new AssetsPipeSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(pipeViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Pump:
                    {
                        var pumpViewModel = vm as HydroPumpViewModel;
                        var input = HydroMatchingHelper.Create(pumpViewModel.Vmo, pumpViewModel.HydroInfo);
                        var dlg = new SimulationPumpSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(pumpViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Valve:
                    {
                        var valveViewModel = vm as HydroValveViewModel;
                        var input = HydroMatchingHelper.Create(valveViewModel);
                        var dlg = new AssetsValveSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(valveViewModel, output, _changeHelper, _propStatusHelper);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Exchanger:
                    {
                        var exchangerViewModel = vm as HydroExchangerViewModel;
                        var input = HydroMatchingHelper.Create(exchangerViewModel);
                        var dlg = new AssetsExchangerSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(exchangerViewModel, output);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                case Yw.Hydro.ParterCatalog.Compressor:
                    {
                        var compressorViewModel = vm as HydroCompressorViewModel;
                        var input = HydroMatchingHelper.Create(compressorViewModel);
                        var dlg = new AssetsCompressorSingleMatchingDlg();
                        dlg.ReloadDataEvent += (output) =>
                        {
                            HydroMatchingHelper.Apply(compressorViewModel, output);
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                            this.PropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.MarkPropertyValueChangedEvent?.Invoke(vm.Vmo);
                            this.GradingPropertyValueChangedEvent?.Invoke(vm.Vmo);
                        };
                        dlg.SetBindingData(input);
                        dlg.ShowDialog();
                    }
                    break;

                default: break;
            }
        }

        //设置曲线
        private void HydroVisualPropertyCtrl1_SetCurveEvent(HydroVisualViewModel vm, string curve, string curveType)
        {
            if (vm == null)
            {
                return;
            }
            switch (curve)
            {
                case HydroCurve.Tank:
                    {
                        var tankViewModel = vm as HydroTankViewModel;
                        var curveInfo = tankViewModel.HydroInfo.Curves?.Find(x => x.Code == tankViewModel.VolCurve);
                        if (curveInfo != null)
                        {
                            if (long.TryParse(curveInfo.DbId, out long longDbId))
                            {
                                var dlg = new AssetsTankCurveVOLViewDlg();
                                dlg.SetBindingData(longDbId);
                                dlg.ShowDialog();
                            }
                        }
                    }
                    break;

                case HydroCurve.Pump:
                    {
                        var pumpViewModel = vm as HydroPumpViewModel;
                        var dlg = new SimulationSinglePumpFeatDlg();
                        dlg.SaveEvent += (working) =>
                        {
                            pumpViewModel.Vmo.LinkStatus = working.LinkStatus;
                            pumpViewModel.Vmo.SpeedRatio = working.CurrentHz / pumpViewModel.Vmo.RatedHz;
                            pumpViewModel.UpdateProperty();
                            this.hydroVisualPropertyCtrl1.UpdateRows();
                        };
                        dlg.SetBindingData(pumpViewModel, this.CalcuResult?.Invoke(), _changeHelper, _propStatusHelper);
                        dlg.ShowDialog();
                    }
                    break;

                case HydroCurve.Valve:
                    {
                        var valveViewModel = vm as HydroValveViewModel;
                        var curveInfo = valveViewModel.HydroInfo.Curves?.Find(x => x.Code == valveViewModel.CurveOL);
                        if (curveInfo != null)
                        {
                            if (long.TryParse(curveInfo.DbId, out long longDbId))
                            {
                                var dlg = new AssetsValveCurveViewDlg();
                                dlg.SetBindingData(longDbId);
                                dlg.ShowDialog();
                            }
                        }
                    }
                    break;

                case HydroCurve.Exchanger:
                    {
                        var exchangerViewModel = vm as HydroExchangerViewModel;
                        var curveInfo = exchangerViewModel.HydroInfo.Curves?.Find(x => x.Code == exchangerViewModel.CurveQL);
                        if (curveInfo != null)
                        {
                            if (long.TryParse(curveInfo.DbId, out long longDbId))
                            {
                                var dlg = new AssetsExchangerCurveQLViewDlg();
                                dlg.SetBindingData(longDbId);
                                dlg.ShowDialog();
                            }
                        }
                    }
                    break;

                case HydroCurve.Compressor:
                    {
                        var compressorViewModel = vm as HydroCompressorViewModel;
                        var curveInfo = compressorViewModel.HydroInfo.Curves?.Find(x => x.Code == compressorViewModel.CurveQL);
                        if (curveInfo != null)
                        {
                            if (long.TryParse(curveInfo.DbId, out long longDbId))
                            {
                                var dlg = new AssetsCompressorCurveQLViewDlg();
                                dlg.SetBindingData(longDbId);
                                dlg.ShowDialog();
                            }
                        }
                    }
                    break;

                default: break;
            }
        }

        #endregion

        #region 事件穿透

        //构件查看事件
        private void HydroVisualPropertyCtrl1_HydroViewEvent(HydroVisualViewModel vm)
        {
            this.HydroViewEvent?.Invoke(vm?.Vmo);
        }

        //强调连接节点
        private void HydroVisualPropertyCtrl1_BlinkLinkNodeEvent(HydroLinkViewModel vm, string linkNodeCode)
        {
            if (vm == null)
            {
                return;
            }
            if (string.IsNullOrEmpty(linkNodeCode))
            {
                return;
            }
            this.BlinkLinkNodeEvent?.Invoke(vm?.Vmo, linkNodeCode);
        }

        //属性发生改变
        private void HydroVisualPropertyCtrl1_PropertyValueChangedEvent(HydroVisualViewModel vm)
        {
            this.PropertyValueChangedEvent?.Invoke(vm?.Vmo);
        }

        //标注属性发生改变
        private void HydroVisualPropertyCtrl1_MarkPropertyValueChangedEvent(HydroVisualViewModel vm)
        {
            this.MarkPropertyValueChangedEvent?.Invoke(vm?.Vmo);
        }

        //分级属性发生改变
        private void HydroPVisualPropertyCtrl1_GradingPropertyValueChangedEvent(HydroVisualViewModel vm)
        {
            this.GradingPropertyValueChangedEvent?.Invoke(vm?.Vmo);
        }

        //流向属性发生改变
        private void HydroVisualPropertyCtrl1_FlowDirectionPropertyValueChangedEvent(HydroVisualViewModel obj)
        {
            this.FlowDirectionPropertyValueChangedEvent?.Invoke(obj?.Vmo);
        }

        #endregion


    }
}