using DevExpress.Utils;
using DevExpress.XtraEditors;
using DevExpress.XtraGrid.Views.Grid;
using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;


//编辑原始的性能曲线
namespace IStation.WinFrmUI.Curve
{
    public partial class CurveExpressEditCtrl : DevExpress.XtraEditors.XtraUserControl
    {
        public CurveExpressEditCtrl()
        {
            InitializeComponent();
            InitializeGridView();

            this.curveExpressEditChart.OnDefinePointChanged += FeatCurvesDispCtrl1_OnDefinePointChanged;
        }

        private void InitializeGridView()
        {
            this.gridView1.OptionsFind.FindNullPrompt = "检索";
            this.gridView1.OptionsSelection.MultiSelect = false;
            this.gridView1.OptionsMenu.EnableColumnMenu = true;

            this.gridView1.OptionsSelection.EnableAppearanceFocusedCell = false;
            this.gridView1.Appearance.HeaderPanel.TextOptions.HAlignment = DevExpress.Utils.HorzAlignment.Center;
            this.gridView1.Appearance.Row.TextOptions.HAlignment = DevExpress.Utils.HorzAlignment.Center;
            this.gridView1.FocusRectStyle = DrawFocusRectStyle.RowFullFocus;
            this.gridView1.OptionsCustomization.AllowFilter = true;
            this.gridView1.OptionsCustomization.AllowSort = true;
            this.gridView1.OptionsCustomization.AllowQuickHideColumns = false;
            this.gridView1.OptionsView.ShowAutoFilterRow = false;
            this.gridView1.OptionsView.ShowFilterPanelMode = DevExpress.XtraGrid.Views.Base.ShowFilterPanelMode.Never;
            this.gridView1.OptionsView.NewItemRowPosition = NewItemRowPosition.None;
            this.gridView1.OptionsView.ShowGroupPanel = false;
            this.gridView1.OptionsClipboard.AllowCopy = DefaultBoolean.True;
            this.gridView1.OptionsBehavior.Editable = true;
            this.gridView1.OptionsBehavior.ReadOnly = false;

            this.gridView1.OptionsView.EnableAppearanceOddRow = true;
            this.gridView1.OptionsView.EnableAppearanceEvenRow = true;
            this.gridView1.Appearance.OddRow.BackColor = Color.White;
            this.gridView1.Appearance.EvenRow.BackColor = Color.FromArgb(244, 248, 251);

            int height = 30;
            this.gridView1.RowHeight = height;
            this.gridView1.ColumnPanelRowHeight = height;
            this.gridView1.GroupRowHeight = height;
            this.gridView1.BestFitColumns();

            this.gridView1.OptionsView.ShowIndicator = true;
            this.gridView1.IndicatorWidth = height;
            this.gridView1.CustomDrawRowIndicator += (sender, e) =>
            {
                if (e.Info.IsRowIndicator && e.RowHandle >= 0)
                {
                    e.Info.DisplayText = (e.RowHandle + 1).ToString().Trim();
                    e.Appearance.TextOptions.HAlignment = DevExpress.Utils.HorzAlignment.Far;
                }
            };
            this.gridView1.BorderStyle = DevExpress.XtraEditors.Controls.BorderStyles.NoBorder;
        }




        Model.eCurveFitType _fitTypeQH = Model.eCurveFitType.CubicCurve;
        Model.eCurveFitType _fitTypeQE = Model.eCurveFitType.CubicCurve;
        Model.eCurveFitType _fitTypeQP = Model.eCurveFitType.CubicCurve;

        private List<Model.CurvePoint> _pointsQH = null;
        private List<Model.CurvePoint> _pointsQE = null;
        private List<Model.CurvePoint> _pointsQP = null;

        private List<Model.CurvePoint> _fitCurvePoints = null;

        Model.eFeatCurveType _editCurveType = Model.eFeatCurveType.QH;


        /// <summary>
        /// 初始化数据
        /// </summary>
        public void SetBindingData()
        {
            _pointsQH = null;
            _pointsQE = null;
            _pointsQP = null;

            _fitCurvePoints = new List<Model.CurvePoint>();
            this.bindingSource1.DataSource = _fitCurvePoints;
        }


        /// <summary>
        /// 初始化数据
        /// </summary> 
        public void SetBindingData(Model.CurveExpress curveQH,
                                   Model.CurveExpress curveQE,
                                   Model.CurveExpress curveQP)
        {
            if (curveQH == null)
                return;
            List<Model.CurvePoint> qhPoints, qePoints = null, qpPoints = null;

            if (curveQH.DefinePoints != null)
                qhPoints = curveQH.DefinePoints;
            else
                qhPoints = curveQH.GetFitPoints(12);

            _fitTypeQH = curveQH.FitType;
            if (curveQE != null)
            {
                _fitTypeQE = curveQE.FitType;
                if (curveQE.DefinePoints != null)
                    qePoints = curveQE.DefinePoints;
                else
                    qePoints = curveQE.GetFitPoints(12);
            }

            if (curveQP != null)
            {
                _fitTypeQP = curveQP.FitType;
                if (curveQP?.DefinePoints != null)
                    qpPoints = curveQP.DefinePoints;
                else
                    qpPoints = curveQP.GetFitPoints(12);
            }

            SetBindingData(qhPoints, qePoints, qpPoints, _fitTypeQH, _fitTypeQE, _fitTypeQP);
        }


        /// <summary>
        /// 初始化数据
        /// </summary> 
        public void SetBindingData(List<Model.CurvePoint> pointsQH,
                                   List<Model.CurvePoint> pointsQE,
                                   List<Model.CurvePoint> pointsQP,
                                   Model.eCurveFitType fitTypeQH,
                                   Model.eCurveFitType fitTypeQE,
                                   Model.eCurveFitType fitTypeQP)
        {

            _fitCurvePoints = new List<Model.CurvePoint>();
            this.bindingSource1.DataSource = _fitCurvePoints;

            _pointsQH = null;
            _pointsQE = null;
            _pointsQP = null;


            if (pointsQH == null || pointsQH.Count < 4)
            {
                this.curveExpressEditChart.InitialChartData();
                return;
            }

            _pointsQH = pointsQH;
            _pointsQE = pointsQE;
            _pointsQP = pointsQP;

            _fitTypeQH = fitTypeQH;
            _fitTypeQE = fitTypeQE;
            _fitTypeQP = fitTypeQP;


            this.cmbCurveType.Properties.Items.Clear();
            this.cmbCurveType.Properties.Items.Add("流量扬程曲线");
            if (_pointsQE != null && _pointsQE.Count > 3)
                this.cmbCurveType.Properties.Items.Add("流量效率曲线");
            if (_pointsQP != null && _pointsQP.Count > 3)
                this.cmbCurveType.Properties.Items.Add("流量功率曲线");
            this.cmbCurveType.SelectedIndex = 0;

            this.curveExpressEditChart.SetBindingData(_pointsQH, _pointsQE, _pointsQP, _fitTypeQH, _fitTypeQE, _fitTypeQP);

            ReloadCurvePoints();
        }

        //性能曲线点修改事件
        private void FeatCurvesDispCtrl1_OnDefinePointChanged(Model.eFeatCurveType type, List<Model.CurvePoint> points)
        {
            _fitCurvePoints.Clear();
            switch (_editCurveType)
            {
                case Model.eFeatCurveType.QH:
                    {
                        _pointsQH = points;
                        foreach (Model.CurvePoint pt in _pointsQH)
                            _fitCurvePoints.Add(new Model.CurvePoint(pt.X, pt.Y));
                    }
                    break;
                case Model.eFeatCurveType.QE:
                    {
                        _pointsQE = points;
                        foreach (Model.CurvePoint pt in _pointsQE)
                            _fitCurvePoints.Add(new Model.CurvePoint(pt.X, pt.Y));
                    }
                    break;
                case Model.eFeatCurveType.QP:
                    {
                        _pointsQP = points;
                        foreach (Model.CurvePoint pt in _pointsQP)
                            _fitCurvePoints.Add(new Model.CurvePoint(pt.X, pt.Y));
                    }
                    break;
            }
            this.bindingSource1.ResetBindings(false);
        }


        //编辑性能曲线类型修改
        private void cmbCurveType_SelectedIndexChanged(object sender, EventArgs e)
        {
            string curveType = cmbCurveType.SelectedItem.ToString();
            if (string.Equals("流量扬程曲线", curveType))
            {
                _editCurveType = Model.eFeatCurveType.QH;
            }
            else if (string.Equals("流量效率曲线", curveType))
            {
                _editCurveType = Model.eFeatCurveType.QE;

            }
            else if (string.Equals("流量功率曲线", curveType))
            {
                _editCurveType = Model.eFeatCurveType.QP;
            }
            ReloadCurvePoints();
        }

        //单元格修改后触发
        private void gridView1_CellValueChanged(object sender, DevExpress.XtraGrid.Views.Base.CellValueChangedEventArgs e)
        {
            var points = _fitCurvePoints.Select(x => new Model.CurvePoint(x)).ToList();
            switch (_editCurveType)
            {
                case Model.eFeatCurveType.QH:
                    {
                        _pointsQH = points;
                    }
                    break;
                case Model.eFeatCurveType.QE:
                    {

                        _pointsQE = points;
                    }
                    break;
                case Model.eFeatCurveType.QP:
                    {

                        _pointsQP = points;
                    }
                    break;
            }
            ReloadCurvePoints();
        }

        //按钮点击事件
        private void buttonEdit_ButtonClick(object sender, DevExpress.XtraEditors.Controls.ButtonPressedEventArgs e)
        {
            if (e.Button.Tag == null)
                return;
            var tag = e.Button.Tag.ToString();
            switch (tag)
            {
                case "Delete": DeletePoint(); break;
                case "InsertPoint": InsertPoint(); break;
                case "ReloadCalcu": ReloadCalcu(); break;
            }
        }


        /// <summary>
        /// 刷新数据
        /// </summary>
        private void ReloadCurvePoints()
        {
            _fitCurvePoints.Clear();
            switch (_editCurveType)
            {
                case Model.eFeatCurveType.QH:
                    {
                        foreach (Model.CurvePoint pt in _pointsQH)
                            _fitCurvePoints.Add(new Model.CurvePoint(pt.X, pt.Y));
                    }
                    break;
                case Model.eFeatCurveType.QE:
                    {
                        foreach (Model.CurvePoint pt in _pointsQE)
                            _fitCurvePoints.Add(new Model.CurvePoint(pt.X, pt.Y));
                    }
                    break;
                case Model.eFeatCurveType.QP:
                    {
                        foreach (Model.CurvePoint pt in _pointsQP)
                            _fitCurvePoints.Add(new Model.CurvePoint(pt.X, pt.Y));
                    }
                    break;
            }
            var list = _fitCurvePoints?.Select(x => new Model.CurvePoint(x.X, x.Y)).ToList();
            this.curveExpressEditChart.UpdateCurve(_editCurveType, list);
            this.bindingSource1.ResetBindings(false);
        }

        //删除点
        private void DeletePoint()
        {
            var row = this.gridView1.GetFocusedRow() as Model.CurvePoint;
            if (row == null)
                return;
            if (XtraMessageBox.Show("是否删除此点？", "提示信息", MessageBoxButtons.YesNo, MessageBoxIcon.Information) != DialogResult.Yes)
                return;
            _fitCurvePoints.Remove(row);
            this.bindingSource1.ResetBindings(false);

            var points = new List<Model.CurvePoint>();
            foreach (var curvePoint in _fitCurvePoints)
            {
                var x = curvePoint.X;
                var y = curvePoint.Y;
                points.Add(new Model.CurvePoint(x, y));
            }
            switch (_editCurveType)
            {
                case Model.eFeatCurveType.QH: _pointsQH = points.ToList(); break;
                case Model.eFeatCurveType.QE: _pointsQE = points.ToList(); break;
                case Model.eFeatCurveType.QP: _pointsQP = points.ToList(); break;
            }

            this.curveExpressEditChart.UpdateCurve(_editCurveType, points);
        }


        //插入点
        private void InsertPoint()
        {
            var dlg = new Curve.InputXYDialog();
            List<Model.CurvePoint> points = null;
            switch (_editCurveType)
            {
                case Model.eFeatCurveType.QH:
                    {
                        dlg.SetLabelX("Q");
                        dlg.SetLabelY("H");
                        points = _pointsQH;
                    }
                    break;
                case Model.eFeatCurveType.QE:
                    {
                        dlg.SetLabelX("Q");
                        dlg.SetLabelY("E");
                        points = _pointsQE;
                    }
                    break;
                case Model.eFeatCurveType.QP:
                    {
                        dlg.SetLabelX("Q");
                        dlg.SetLabelY("P");
                        points = _pointsQP;
                    }
                    break;
            }
            if (dlg.ShowDialog() != DialogResult.OK)
                return;

            points.Add(new Model.CurvePoint(dlg.X, dlg.Y));
            ReloadCurvePoints();
        }

        //重新计算
        private void ReloadCalcu()
        {
            if (_fitCurvePoints == null)
                return;
            bool isFromZero = false;
            if (_pointsQH.Last().X > 20)
            {
                if (_pointsQH.First().X < 1)
                    isFromZero = true;
            }
            else
            {
                if (_pointsQH.First().X < 0.3)
                    isFromZero = true;
            }
            if (_editCurveType == Model.eFeatCurveType.QE)
            {
                _pointsQE = LxpFeatCurveHelper.CalculateE_AlignPointP(_fitTypeQH, _fitTypeQP, _pointsQH, _pointsQP, isFromZero);
            }
            else if (_editCurveType == Model.eFeatCurveType.QP)
            {

                double ref_zero_power = -1;
                if (_pointsQP != null && _pointsQE.Count > 0)
                {
                    ref_zero_power = _pointsQP.First().Y;
                }
                _pointsQP = LxpFeatCurveHelper.CalculateP_AlignPointE(_fitTypeQH, _fitTypeQE, _pointsQH, _pointsQE, IStation.Model.ConstantParas.WaterDensity, ref_zero_power, isFromZero);
            }
            ReloadCurvePoints();
        }


        /// <summary>
        /// 设置曲线坐标
        /// </summary>
        public void SetCoordinateByDialog()
        {
            this.curveExpressEditChart.SetChartAxis();
        }



        /// <summary>
        /// 获取点信息
        /// </summary>
        /// <param name="pointsQH"></param>
        /// <param name="pointsQE"></param>
        /// <param name="pointsQP"></param>
        /// <returns></returns>
        public bool GetPoints(out List<Model.CurvePoint> pointsQH,
                                     out List<Model.CurvePoint> pointsQE,
                                     out List<Model.CurvePoint> pointsQP,
                                     out Model.eCurveFitType fitTypeQH,
                                     out Model.eCurveFitType fitTypeQE,
                                     out Model.eCurveFitType fitTypeQP)
        {
            pointsQH = _pointsQH?.ToList();
            pointsQE = _pointsQE?.ToList();
            pointsQP = _pointsQP?.ToList();
            fitTypeQH = _fitTypeQH;
            fitTypeQE = _fitTypeQE;
            fitTypeQP = _fitTypeQP;
            if (pointsQH == null || pointsQH.Count < 4)
            {
                XtraMessageBox.Show("点数过少!");
                return false;
            }

            return true;
        }


    }
}