using System.Data;
using Yw.Geometry;
using Yw.WinFrmUI.Phart;

namespace HStation.WinFrmUI.PhartRelation
{
    public partial class PumpParallelAnalyDlg : DevExpress.XtraBars.Ribbon.RibbonForm
    {
        public PumpParallelAnalyDlg()
        {
            InitializeComponent();
            this.IconOptions.Icon = Yw.WinFrmUI.GlobalParas.AppIcon;
            this.pumpSerialParallelChart.SetQeVisible(false);
            this.pumpParallelInfoCtrl1.SetEvent += (id, qh, qe, qp) =>
            {
                var list = this.pumpParallelInfoCtrl1.GetRunList();
                SetParallel(list);
            };
            this.pumpParallelInfoCtrl1.SetInfoEvent += (id, name, color) =>
            {
                this.pumpSerialParallelChart.Set(id, name, color);
            };

            this.pumpParallelInfoCtrl1.SetDesignPointEvent += (q, h) =>
            {
                this.pumpSerialParallelChart.SetDesignPoint(new Point2d(q, h));
            };

            this.pumpParallelInfoCtrl1.AddEvent += (vm) =>
            {
                var list = this.pumpParallelInfoCtrl1.GetRunList();
                SetParallel(list);
            };

            this.pumpParallelInfoCtrl1.DeleteEvent += (id) =>
            {
                var list = this.pumpParallelInfoCtrl1.GetRunList();
                SetParallel(list);
            };

            this.pumpSerialParallelChart.QueryPointChangedEvent += (id, pt) =>
            {
                this.pumpParallelInfoCtrl1.SetQueryInfo(id, pt);
            };
            this.pumpParallelInfoCtrl1.ResetEvent += () =>
            {
                var list = this.pumpParallelInfoCtrl1.GetRunList();
                SetParallel(list);
            };

            this.pumpParallelInfoCtrl1.SaveEvent += () =>
            {
                var run_list = this.pumpParallelInfoCtrl1.GetRunList();
                var list = new List<XhsSingleResultViewModel>();
                if (run_list != null && run_list.Any())
                {
                    foreach (var x in run_list)
                    {
                        var vm = new XhsSingleResultViewModel();
                        vm.ID = x.ID;
                        vm.Name = x.Name;
                        vm.Code = x.Code;
                        vm.IsBp = x.IsBp;
                        vm.RunStatus = x.RunStatus;
                        vm.CurrentHz = x.CurrentHz;
                        list.Add(vm);
                    }
                }
                var bol = this.ReloadDataEvent?.Invoke(list);
                if (bol.HasValue && bol.Value)
                {
                    this.Close();
                }
            };
        }

        private string _parallel_id = "parallel";
        public event Func<List<XhsSingleResultViewModel>, bool> ReloadDataEvent;
        

        /// <summary>
        /// 设置
        /// </summary>
        /// <param name="list"></param> 
        /// <returns></returns>
        public string SetBindingData(
            List<XhsSinglePumpViewModel> list)
        {
            if (list == null || !list.Any())
            {
                return "数据为空!";
            }

            var vm_list = new List<Yw.WinFrmUI.Phart.PumpSerialParallelInfoViewModel>();
            for (int i = 0; i < list.Count; i++)
            {
                var x = list[i];
                if (x.CurveQH == null || !x.CurveQH.Any())
                {
                    continue;
                }

                var vm = new Yw.WinFrmUI.Phart.PumpSerialParallelInfoViewModel();
                vm.ID = x.ID;
                vm.Id = x.ID.ToString();
                vm.Name = x.Name;
                vm.Code = x.Code;
                vm.IsBp = x.IsBp;
                vm.RatedN = x.RatedSpeed;
                vm.CurrentN = x.CurrentSpeed;
                vm.RunStatus = x.RunStatus;
                vm.CurrentHz = x.CurrentHz;
                var qh_pt_list = x.CurveQH.Select(x => new Yw.Geometry.Point2d(x.X, x.Y)).ToList();
                vm.CurveQH = new CubicSpline2d(qh_pt_list);
                if (x.CurveQE != null && x.CurveQE.Any())
                {
                    var qe_pt_list = x.CurveQE.Select(x => new Yw.Geometry.Point2d(x.X, x.Y)).ToList();
                    vm.CurveQE = new CubicSpline2d(qe_pt_list);
                }
                if (x.CurveQP != null && x.CurveQP.Any())
                {
                    var qp_pt_list = x.CurveQP.Select(x => new Yw.Geometry.Point2d(x.X, x.Y)).ToList();
                    vm.CurveQP = new CubicSpline2d(qp_pt_list);
                }

                vm.CalcuQ = x.CalcuQ;
                vm.CalcuH = x.CalcuH;
                vm.Color = GetRandomColor(i);
                vm.Calc();
                vm_list.Add(vm);

                if (!x.RunStatus)
                    continue;

                if (!x.CalcuQ.HasValue || !x.CalcuH.HasValue)
                    continue;
                var calc_flow = x.CalcuQ.Value;
                var calc_head = x.CalcuH.Value;

                var max_flow = vm.CurveQH.MaxX;
                var max_flow_head = vm.CurveQH.GetPointY(max_flow);

                var min_flow = vm.CurveQH.MinX;
                var min_flow_head = vm.CurveQH.GetPointY(min_flow);

                if (max_flow_head < calc_head && min_flow_head > calc_head)
                    continue;

                var extend_ratio = 1m;
                var extend_success = false;
                for (decimal num = 0.01m; num <= 5; num += 0.01m)
                {
                    extend_ratio += num;
                    var ex_pt_list = qh_pt_list.GetExpandFitPointList((double)extend_ratio);
                    var ex_x_array = ex_pt_list.GetInterPointsX(calc_head);
                    if (ex_x_array != null && ex_x_array.Any())
                    {
                        extend_success = true;
                        vm.ExtendRatio = Math.Round((double)extend_ratio * 100, 1);
                        vm.Calc();
                        break;
                    }
                }
                if (!extend_success)
                {

                }
            }

            this.pumpParallelInfoCtrl1.SetBindingData(vm_list, null);
            var run_list = this.pumpParallelInfoCtrl1.GetRunList();
            var msg = SetParallel(run_list); 
            if (!string.IsNullOrEmpty(msg))
            {
                return msg;
            }
            return string.Empty;
        }

        private string SetParallel(List<Yw.WinFrmUI.Phart.PumpSerialParallelInfoViewModel> list)
        {
            var msg = "并联成功";
            this.pumpSerialParallelChart.Clear();
            if (list == null || !list.Any())
            {
                msg = "无数据";
                return msg;
            }
            else
            {
                if (list.Count < 2)
                {
                    msg = "并联失败";
                }
                else
                {
                    var vm_parallel = CalcParallel(list);
                    if (vm_parallel != null)
                    {
                        list.Add(vm_parallel);
                    }
                    else
                    {
                        msg = "并联失败";
                    }
                }
            }
            Set(list);
            this.barInfo.Caption = $"<b><color=red>{msg}</color></b>";
            return msg;

        }


        private Yw.WinFrmUI.Phart.PumpSerialParallelInfoViewModel CalcParallel(List<Yw.WinFrmUI.Phart.PumpSerialParallelInfoViewModel> list)
        {
            if (list == null || !list.Any())
            {
                return default;
            }

            var calc_bol = false;
            var line_name = "";
            List<Yw.Geometry.Point2d> calc_pt_qh_list;
            List<Yw.Geometry.Point2d> calc_pt_qe_list;
            List<Yw.Geometry.Point2d> calc_pt_qp_list;

            var helper = new Yw.WinFrmUI.Phart.PumpParallelConnectionHelper();
            list.ForEach(x => helper.Add(x.QhCalc, x.QpCalc));
            line_name = "并联曲线";
            calc_bol = helper.CalculateParallel(out calc_pt_qh_list, out calc_pt_qe_list, out calc_pt_qp_list);

            if (!calc_bol || calc_pt_qh_list.Count < 4)
            {
                return default;
            }
            double total_flow = list.Sum(x => x.CalcuQ ?? 0);
            double total_head = list.Average(x => x.CalcuH ?? 0);

            var qh = new Yw.Geometry.CubicSpline2d(calc_pt_qh_list);
            var qe = new Yw.Geometry.CubicSpline2d(calc_pt_qe_list);
            var qp = new Yw.Geometry.CubicSpline2d(calc_pt_qp_list);


            var vm_sp = new Yw.WinFrmUI.Phart.PumpSerialParallelInfoViewModel();
            vm_sp.Id = _parallel_id;
            vm_sp.Name = line_name;
            vm_sp.CurveQH = qh;
            vm_sp.CurveQE = qe;
            vm_sp.CurveQP = qp;

            vm_sp.QhCalc = qh;
            vm_sp.QeCalc = qe;
            vm_sp.QpCalc = qp;

            vm_sp.CalcuH = total_head;
            vm_sp.CalcuQ = total_flow;


            vm_sp.Color = Color.Black;
            vm_sp.IsBp = true;
            vm_sp.IsDefault = true;
            return vm_sp;

        }

        private void Set(List<Yw.WinFrmUI.Phart.PumpSerialParallelInfoViewModel> list)
        {
            if (list == null || !list.Any())
            {
                this.pumpSerialParallelChart.InitialChartData();
                return;
            }

            this.pumpSerialParallelChart.Add(list);
            var run_list = list.Where(x => x.RunStatus).ToList();
            if (run_list != null && run_list.Any())
            {
                double total_flow = run_list.Sum(x => x.CalcuQ ?? 0);
                double total_head = run_list.Average(x => x.CalcuH ?? 0);
                total_flow = Math.Round(total_flow, 1);
                total_head = Math.Round(total_head, 1);
                this.pumpParallelInfoCtrl1.SetDesignPoint(total_flow, total_head);
                this.pumpSerialParallelChart.CalcWorkPointByQ(total_flow);
            }

        }



        #region Color

        private List<Color> _color_array = new List<Color>()
        {
            Color.Red, Color.Blue, Color.Green,Color.DodgerBlue,
            Color.Fuchsia, Color.MidnightBlue,  Color.Maroon, Color.Aquamarine,
            Color.Bisque,Color.BurlyWood
        };

        /// <summary>
        /// 获取随机颜色
        /// </summary>
        /// <returns></returns>
        private Color GetRandomColor(int count)
        {
            if (count < _color_array.Count)
            {
                return _color_array[count];
            }

            var _random = new Random();
            int r = _random.Next(1, 256);
            int g = _random.Next(1, 256);
            int b = _random.Next(1, 256);
            return Color.FromArgb(r, g, b);
        }

        #endregion



    }
}