using DevExpress.XtraEditors;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Yw.Geometry;
using Yw.Pump;
using Yw.Vmo;
using Yw.WinFrmUI.Phart;

namespace HStation.WinFrmUI
{
    public partial class SimulationPumpSingleWorkingChartCtrl : DevExpress.XtraEditors.XtraUserControl
    {
        public SimulationPumpSingleWorkingChartCtrl()
        {
            InitializeComponent();
            this.pumpWorkingViewChart1.RunPointSelectedEvent += PumpWorkingViewChart1_RunPointSelectedEvent;
        }

        private HydroWorkingVmo _working = null;
        private Yw.Model.HydroModelInfo _hydroInfo = null;
        private List<HydroMonitorVmo> _allMonitorList = null;
        private Dictionary<string, HydroCalcuVisualResult> _allCalcuResultVisualDict = null;

        /// <summary>
        /// 绑定数据
        /// </summary>
        public void SetBindingData
            (
                HydroWorkingVmo working,
                Yw.Model.HydroModelInfo hydroInfo,
                List<HydroMonitorVmo> allMonitorList,
                HydroCalcuResult calcuResult
            )
        {
            var allCalcuResultVisualDict = calcuResult.GetVisualDict();
            SetBindingData(working, hydroInfo, allMonitorList, allCalcuResultVisualDict);
        }

        /// <summary>
        /// 绑定数据
        /// </summary>
        public void SetBindingData
            (
                HydroWorkingVmo working,
                Yw.Model.HydroModelInfo hydroInfo,
                List<HydroMonitorVmo> allMonitorList,
                Dictionary<string, HydroCalcuVisualResult> allCalcuResultVisualDict
            )
        {
            _working = working;
            _hydroInfo = hydroInfo;
            _allMonitorList = allMonitorList;
            _allCalcuResultVisualDict = allCalcuResultVisualDict;
            var vm = CreateViewModel();
            SetBindingData(vm);
        }

        /// <summary>
        /// 绑定数据
        /// </summary>
        public void SetBindingData(PumpWorkingViewViewModel vm)
        {
            this.pumpWorkingViewChart1.SetBindingData(vm);
            if (vm != null && vm.Items != null)
            {
                var item = vm.Items.FirstOrDefault();
                SetCurrent(item);
            }
            this.barCkE.Checked = this.pumpWorkingViewChart1.QEVisible;
        }

        //创建
        private PumpWorkingViewViewModel CreateViewModel()
        {
            if (_working == null)
            {
                return default;
            }
            if (_hydroInfo == null)
            {
                return default;
            }
            if (_allCalcuResultVisualDict == null || _allCalcuResultVisualDict.Count < 1)
            {
                return default;
            }
            var vm = new PumpWorkingViewViewModel();
            vm.Id = _working.ID.ToString();
            vm.Name = _working.Name;
            vm.CurveName = $"装置线";
            vm.Color = Color.Black;

            var head = _hydroInfo.GetHead();
            var pipeQ = _hydroInfo.GetPipeQ(_allCalcuResultVisualDict);
            var pipeH = _hydroInfo.GetPipeHead(_allCalcuResultVisualDict);

            vm.StartH = head;
            vm.PipeQ = pipeQ ?? 0;
            vm.PipeH = pipeH ?? 0;

            if (_hydroInfo.Pumps != null && _hydroInfo.Pumps.Count > 0)
            {
                var pumps = _hydroInfo.Pumps.Where(x => x.LinkStatus == Yw.Hydro.PumpStatus.Open).ToList();
                if (pumps.Count > 0)
                {
                    vm.Items = new List<PumpWorkingViewItemViewModel>();
                    foreach (var pump in pumps)
                    {
                        var vmItem = new PumpWorkingViewItemViewModel();
                        vm.Items.Add(vmItem);
                        vmItem.Id = pump.Code;
                        vmItem.Name = pump.Name;
                        vmItem.CurveName = pump.Name;
                        vmItem.Color = HydroPumpCurveColorHelper.GetRandomColor(pumps.IndexOf(pump));
                        var calcuResult = _allCalcuResultVisualDict?.GetValue(pump.Code) as HydroCalcuPumpResult;
                        if (calcuResult != null)
                        {
                            vmItem.Q = calcuResult.CalcuQ ?? 0;
                            vmItem.H = calcuResult.CalcuH ?? 0;
                            vmItem.P = calcuResult.CalcuP;
                            vmItem.E = calcuResult.CalcuE;
                        }
                        vmItem.Hz = Math.Round(pump.SpeedRatio * pump.RatedHz, 1);
                        vmItem.N = pump.RatedN.HasValue ? Math.Round(pump.SpeedRatio * pump.RatedN.Value, 1) : 0;


                        var curveqh = _hydroInfo.Curves?.Find(x => x.Code == pump.CurveQH);
                        if (curveqh != null)
                        {
                            var qh_pts = curveqh.CurveData?.Select(x => new Yw.Geometry.Point2d(x.X, x.Y)).ToList();
                            if (qh_pts != null && qh_pts.Count > 3)
                            {
                                var qh_run_pts = qh_pts.GetQHPointListByN(pump.RatedHz, vmItem.Hz);
                                vmItem.CurveQH = new CubicSpline2d(qh_run_pts);
                            }
                        }

                        var curveqp = _hydroInfo.Curves?.Find(x => x.Code == pump.CurveQP);
                        if (curveqp != null)
                        {
                            var qp_pts = curveqp.CurveData?.Select(x => new Yw.Geometry.Point2d(x.X, x.Y)).ToList();
                            if (qp_pts != null && qp_pts.Count > 3)
                            {
                                var qp_run_pts = qp_pts.GetQPPointListByN(pump.RatedHz, vmItem.Hz);
                                vmItem.CurveQP = new CubicSpline2d(qp_run_pts);
                            }
                        }

                        var curveqe = _hydroInfo.Curves?.Find(x => x.Code == pump.CurveQE);
                        if (curveqe != null)
                        {
                            var qe_pts = curveqe.CurveData?.Select(x => new Yw.Geometry.Point2d(x.X, x.Y)).ToList();
                            if (qe_pts != null && qe_pts.Count > 3)
                            {
                                var qe_run_pts = qe_pts.GetQEPointListByN(pump.RatedHz, vmItem.Hz);
                                vmItem.CurveQE = new CubicSpline2d(qe_run_pts);
                            }
                        }

                    }
                }
            }

            return vm;
        }

        //设置当前
        private void SetCurrent(PumpWorkingViewItemViewModel item)
        {
            if (item != null)
            {
                this.barTxtPump.EditValue = item.Name;
                this.barTxtQ.EditValue = $"{Math.Round(item.Q, 1)}m³/h";
                this.barTxtH.EditValue = $"{Math.Round(item.H, 2)}m";
                this.barTxtP.EditValue = $"{Math.Round(item.P ?? 0, 1)}kW";
                this.barTxtE.EditValue = $"{Math.Round(item.E ?? 0, 1)}%";
            }
        }

        private void PumpWorkingViewChart1_RunPointSelectedEvent(PumpWorkingViewItemViewModel obj)
        {
            SetCurrent(obj);
        }

        private void barCkE_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            this.pumpWorkingViewChart1.QEVisible = this.barCkE.Checked;
        }

        private void barBtnCoord_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            this.pumpWorkingViewChart1.SetChartAxis();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="fileName"></param>
        public void ExportToImage(string fileName)
        {
            this.pumpWorkingViewChart1.ExportToImage(fileName);
        }

    }
}