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 static System.Windows.Forms.VisualStyles.VisualStyleElement;
using System.Windows.Forms.DataVisualization.Charting;

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using MathNet.Numerics.LinearAlgebra.Double; // 引入 Math.NET Numerics 库进行多项式拟合
using MathNet.Numerics;
using System.IO;
using System.Xml.Serialization;
using System.Xml.Linq;
using CloudWaterNetwork.建模;
using static System.Windows.Forms.LinkLabel;
using Series = System.Windows.Forms.DataVisualization.Charting.Series;
using System.Drawing.Imaging;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.Status;
using System.Reflection;

namespace CloudWaterNetwork.建模
{
   
    public static class PointsExtansion
    {
        public static int FindNearest(this DataPointCollection dataPoints, double x)
        {
            var dataPoints_sort = dataPoints.ToList();
            dataPoints_sort.Sort((a, b) => { return a.XValue > b.XValue ? 1 : -1; });

            for (int i = 0; i < dataPoints_sort.Count; i++)
            {

                if (dataPoints_sort[i].XValue > x)
                {
                    if (i == 0) return i;
                    var left = x - dataPoints_sort[i - 1].XValue;
                    var right = dataPoints_sort[i].XValue - x;
                    if (right < left)
                        return i;
                    else
                        return i - 1;
                }
            }
            return dataPoints_sort.Count - 1;
        }
    }
    public enum FactoryType
    {
        水厂,
        泵站
    }
    public enum PumpType
    {
        调速泵,
        定速泵
    }
    public class Dataset
    {
        public Dataset(string name)
        {
            Name = name;
        }
        public Dataset()
        {

        }

        public string Name { get; set; }
        public List<PointF> Data { get; set; } = new List<PointF>();

        public int degree { get { return 2; } }

        public List<double> ForumParams = null;

        public DenseVector coefficients = null; // 存储多项式系数

        public double ErrNum { get { return -1; } }

        private int stepNum { get { return 50; } }

        private double step { get { return (range_X.Max - range_X.Min) / stepNum; } }
        /// <summary>
        /// 不需要读取
        /// </summary>
        public string Legend
        {
            get
            {
                switch (Name)
                {
                    case "流量扬程曲线":
                        return "Legend1";
                    case "流量功率曲线":
                        return "Legend1";
                    case "流量效率曲线":
                        return "Legend1";

                }
                return "Legend1";
            }
        }

        public AxisType axisType
        {
            get {
                switch(Name)
                {
                    case "流量扬程曲线":
                        return AxisType.Primary;
                    default:
                        return AxisType.Secondary;

                }
            }
        }

        public void CurveFit()
        {
            if (!HasData)
            {
                IsFitted= false;
                return;
            }

            coefficients = Fit.Polynomial(Data.Select(p => (double)p.X).ToArray(), Data.Select(p => (double)p.Y).ToArray(), degree);

            if (range_X == null)
            {
                range_X = new Range(9999999, -9999999);
                Data.ForEach(p=> {
                    if (range_X.Min > p.X) range_X.Min = p.X;
                    if (range_X.Max<p.X) range_X.Max = p.X;
                    });
            }
            IsFitted = true;
        }
        public double Evaluate(double x)

        {
            if (!IsFitted) return ErrNum;
            // 计算多项式在点 x 处的取值
            double y = 0;
            for (int i = 0; i < coefficients.Count; i++)
            {
                y += coefficients[i] * Math.Pow(x, i);
            }
            return y;
        }

        public double Evaluate_Solve(double y)
        {
            if (!IsFitted) return ErrNum;
            if (degree == 2) // 多项式次数
            {
                if (!is_Yvalue_validate(y)) return ErrNum;

                double a = coefficients[degree]; // 二次项系数
                double b = coefficients[degree - 1]; // 一次项系数
                double c = coefficients[0] - y; // 常数项系数减去给定的 y 值

                // 求解二次方程 ax^2 + bx + c = 0
                double delta = b * b - 4 * a * c;
                
                double x1 = (-b + Math.Sqrt(delta)) / (2 * a);
                double x2 = (-b - Math.Sqrt(delta)) / (2 * a);

                // 取两个解中符合实际情况的那个（可以根据具体应用场景来确定）
                double x = (x2 >= x1) ? x2 : x1;
                return x;
            }
            else
            {
                return ErrNum;
            }
        }
        public string getForum
        {
            get
            {
                // 生成多项式的字符串表示形式
                string polyStr = "y=";
                for (int i = coefficients.Count - 1; i >= 0; i--)
                {
                    if (coefficients[i] == 0) continue;
                    if (i == coefficients.Count - 1)
                    {
                        polyStr += coefficients[i].ToString() + "x^" + i;
                    }
                    else if (i == 1)
                    {
                        if (coefficients[i] > 0)
                        {
                            if (polyStr != "") polyStr += " + ";
                            polyStr += coefficients[i].ToString() + "x";
                        }
                        else
                        {
                            polyStr += " - " + (-coefficients[i]).ToString() + "x";
                        }
                    }
                    else if (i == 0)
                    {
                        if (coefficients[i] > 0)
                        {
                            if (polyStr != "") polyStr += " + ";
                            polyStr += coefficients[i].ToString();
                        }
                        else
                        {
                            polyStr += " - " + (-coefficients[i]).ToString();
                        }
                    }
                    else
                    {
                        if (coefficients[i] > 0)
                        {
                            if (polyStr != "") polyStr += " + ";
                            polyStr += coefficients[i].ToString() + "x^" + i;
                        }
                        else
                        {
                            polyStr += " - " + (-coefficients[i]).ToString() + "x^" + i;
                        }
                    }
                }
                if (polyStr == "") polyStr = "0";
                return polyStr;
            }
            
        }

        public double YMax
        {
            get
            {
                if (!IsFitted) return ErrNum;
                double a = coefficients[degree];
                double b = coefficients[degree - 1];
                double c = coefficients[0];
                double delta = b * b - 4 * a * c;
                double minExtremePoint = -b / (2 * a);    // 计算导函数的零点
                double maxValue = 0;
                if (a<0)

                     maxValue =- delta / (4 * a) + c;
                else
                     maxValue = a * minExtremePoint * minExtremePoint + b * minExtremePoint + c;    // 计算最小值
                return maxValue;
            }
        }
        public double YdataMax
        {
            get
            {
                double max = -99999;
                foreach(var p in Data)
                {
                    if (max < p.Y) max = p.Y;
                }
                return max;
            }
        }
        public bool is_Yvalue_validate(double y)
        {
            if (!IsFitted) return false;
            double a = coefficients[degree];
            if (a < 0)

                return y <= YMax;
            else
                return y >= YMax;
        }

        /// <summary>
        /// X显示的范围
        /// </summary>
        public Range range_X;


        /// <summary>
        /// Y显示的范围
        /// </summary>
        public Range range_Y;

        public bool HasData { get { return Data.Count >= 3; } }

        public bool IsFitted = false;
        public List<PointF> FittedCurve
        {
            get
            {
                List<PointF> doubles = new List<PointF>();
                for (double x = range_X.Min; x <= range_X.Max; x += step)
                {
                    double y = Evaluate(x);
                    //chart.Series[1].Points.AddXY(x, y);
                    doubles.Add(new PointF ((float) x,(float) y ));
                }
                return doubles;

            }

        }
        public List<PointF> FittedCurvebyRange(Range range)
        {
            List<PointF> doubles = new List<PointF>();
            
            if (range==null)
            {
                range = new Range();
                range.Min = range_X.Min;
                range.Max = range_X.Max;
            }
            var step = (range.Max - range.Min) / stepNum;
            for (double x = range.Min; x <= range.Max; x += step)
            {
                double y = Evaluate(x);
                //chart.Series[1].Points.AddXY(x, y);
                doubles.Add(new PointF((float)x, (float)y));
            }
            return doubles;
        }


    }
    public class Range
    {
        public Range()
        {

        }
        public Range(double Min,double Max)
        {
            this.Min = Min;
            this.Max = Max;
        }
        public double Max;
        public double Min;
        public double Len { get { return Max - Min; } }

        public static Range Union(Range a,Range b)
        {
            return new Range(a.Min < b.Min ? a.Min : b.Min, a.Max > b.Max ? a.Max : b.Max);
        }
        public bool isValid
        {
            get
            {
                return Min < Max;
            }
        }
    }
    public class Pump
    {
        public Pump()
        {
            Datasets = new Dictionary<string, Dataset>() {
                {"流量扬程曲线",new Dataset("流量扬程曲线") },
                {"流量功率曲线",new Dataset("流量功率曲线") },
                {"流量效率曲线",new Dataset("流量效率曲线") }

                //,new Dataset("流量功率曲线"),new Dataset("流量效率曲线") 
            };
        }
        public string Name { get; set; }
        public PumpType Type { get; set; }
        public Dictionary<string, Dataset> Datasets { get; set; }

        public string factoryName = "";

        public double 额定转速 { get; set; } = 1500;

        public double 额定流量 { get; set; } = 0;

        public double 额定扬程 { get; set; } = 0;

        public double 额定功率 { get; set; } = 75;




        public Dataset 流量扬程曲线 { get { return Datasets["流量扬程曲线"]; } }

        public Dataset 流量功率曲线 { get { return Datasets["流量功率曲线"]; } }

        public Dataset 流量效率曲线 { get { return Datasets["流量效率曲线"]; } }

      

        public void CurveFit()
        {

      
            foreach (var data in Datasets)
            {
                data.Value.Data.Sort((a, b) => a.X > b.X ? 1 : -1);
                if (data.Value.HasData) data.Value.CurveFit();
            }
            string basetype = "流量扬程曲线";
            string type = "";
            

            type = "流量效率曲线";
            var type1 = "流量功率曲线";
            if (Datasets[type].IsFitted)
            {
                List<PointF> points = new List<PointF>();
                List<PointF> points1 = new List<PointF>();

                foreach (var yc in Datasets[basetype].Data)
                {
                    float x= yc.X;
                    float y_扬程 = yc.Y;
                    float y_效率= (float)Datasets[type].Evaluate(x);
                    points.Add(new PointF(x, y_效率));
                    points1.Add(new PointF(x,x* y_扬程 / y_效率 /3.6f ));


                }
                Datasets[type].Data = points;
                Datasets[type1].Data = points1;
                Datasets[type1].CurveFit();
            }

            //type = "流量功率曲线";
            //if (Datasets[type].IsFitted)
            //{
            //    List<PointF> points = new List<PointF>();
            //    foreach (var x in Datasets[basetype].Data.Select(p => p.X))
            //    {
            //        points.Add(new PointF(x, (float)Datasets[type].Evaluate(x)));
            //    }
            //    Datasets[type].Data = points;

            //}
        }
       
        public void ShowInGrid(DataGridView dataGridView)
        {
            dataGridView.Rows.Clear();
            for (int i = 0; i < 流量扬程曲线.Data.Count; i++)
            {
                PointF p = 流量扬程曲线.Data[i];
                double y1 = 0, y2 = 0;
                if (流量功率曲线.IsFitted) y1 = 流量功率曲线.Data[i].Y;
                if (流量效率曲线.IsFitted) y2 = 流量效率曲线.Data[i].Y;
                dataGridView.Rows.Add(Math.Round(p.X,1), Math.Round(p.Y,2), Math.Round(y1,2), Math.Round(y2, 2));
            }
        }

        public void AddCurve(Chart chart, string type = "流量扬程曲线",bool onlyOne=false,Range Force_range_X=null)
        {
            Series series;
            List<PointF> Points;
            List<PointF> FittedCurve;

            string baseType =  "流量扬程曲线";
            string baseType2 = "流量效率曲线";
            if (onlyOne)
            {
                if (Datasets[type].IsFitted)
                {
                    FittedCurve = Datasets[type].FittedCurvebyRange(Force_range_X);
                    series = AddSeries("ChartArea1", SeriesChartType.Spline, Datasets[type].Legend, Datasets[type].axisType, $"{factoryName}_{Name}_{type}", FittedCurve, true);
                    chart.Series.Add(series);
                }
                
            }   
            else
            {
                Points = Datasets[type].Data;
                series = AddSeries("ChartArea1", SeriesChartType.Point, Datasets[type].Legend, Datasets[type].axisType, $"{type}点", Points, false);
                
                chart.Series.Add(series);
                var series0 = series;
                
                foreach (var data in Datasets)
                {
                    var type0 = data.Key;
                    if (!Datasets[type0].IsFitted) continue;
                    FittedCurve = Datasets[type0].FittedCurve;
                    series = AddSeries("ChartArea1", SeriesChartType.Spline, Datasets[type0].Legend, Datasets[type0].axisType, $"{factoryName}_{Name}_{type0}", FittedCurve, true);
                    chart.Series.Add(series);
                }

                if (chart.Series.Count==1&& series0.Points.Count == 0)
                {
                    series0.Points.Add(-2, -2);
                    series0.Points.Add(-1, -1);
                    series0.IsVisibleInLegend = true;
                    series0.YAxisType = AxisType.Primary;
                    chart.ChartAreas[0].AxisX.Minimum = 0;
                    chart.ChartAreas[0].AxisX.Maximum = 3000;
                    chart.ChartAreas[0].AxisY.Minimum = 0;
                    chart.ChartAreas[0].AxisY.Maximum = 50;
                    chart.ChartAreas[0].AxisY2.Minimum = 0;
                    chart.ChartAreas[0].AxisY2.Maximum = 100;
                    return;
                }
            }

            Range range_X = null;

            if (Force_range_X != null && Force_range_X.isValid)
            {
                range_X = Force_range_X;
            }               
            else if (Datasets[type].range_X!=null && Datasets[type].range_X.isValid)
            {
                range_X=Datasets[type].range_X;
            }
            else if (Datasets[baseType].range_X != null && Datasets[baseType].range_X.isValid)
            {
                range_X= Datasets[baseType].range_X;
            }
            else 
            {
                range_X = new Range(double.NaN, double.NaN);
                
            }

            chart.ChartAreas[0].AxisX.Minimum = range_X.Min;
            chart.ChartAreas[0].AxisX.Maximum = range_X.Max;

            if (Datasets[baseType].range_Y != null && Datasets[baseType].range_Y.isValid)
            {
                // 设置 X 轴的最大最小值
                chart.ChartAreas[0].AxisY.Minimum = Datasets[baseType].range_Y.Min;
                chart.ChartAreas[0].AxisY.Maximum = Datasets[baseType].range_Y.Max;
            }
            else
            {
                chart.ChartAreas[0].AxisY.Minimum = double.NaN;
                chart.ChartAreas[0].AxisY.Maximum = double.NaN;
            }



            if (type!=baseType && Datasets[type].range_Y != null)
            {
                // 设置 X 轴的最大最小值
                chart.ChartAreas[0].AxisY2.Minimum = Datasets[type].range_Y.Min;
                chart.ChartAreas[0].AxisY2.Maximum = Datasets[type].range_Y.Max;
            }
            else
            if (Datasets[baseType2].range_Y != null)
            {
                // 设置 X 轴的最大最小值
                chart.ChartAreas[0].AxisY2.Minimum = Datasets[baseType2].range_Y.Min;
                chart.ChartAreas[0].AxisY2.Maximum = Datasets[baseType2].range_Y.Max;
            }
            else
            {
                chart.ChartAreas[0].AxisY2.Minimum = 0;
                chart.ChartAreas[0].AxisY2.Maximum = 100;
            }
           




        }
        private Series AddSeries(string Area, SeriesChartType type, String Legend, AxisType axisType, String Name, List<PointF> Points, bool showLegend = true)
        {
            Series series = new Series();
            series.ChartArea = Area;
            series.ChartType = type;
            series.Legend = Legend;
            series.Name = Name;
            series.IsVisibleInLegend = showLegend;
            series.YAxisType = axisType;
            if (Points != null) Points.ForEach(p => series.Points.AddXY(p.X, p.Y));
            return series;
        }


    }
    public class Factory
    {
        public string Name { get; set; }
        public FactoryType Type { get; set; }
        public List<Pump> Pumps { get; set; }

        public void CurveFit()
        {
            foreach(var p in Pumps)
            {
                p.CurveFit();
            }
        }

    }
    public class FactoryList
    {
        public List<Factory> Factories { get; set; }

        public FactoryList()
        {
            Factories = new List<Factory>();
        }
        public void AddFactory(string name, FactoryType type)
        {
            Factories.Add(new Factory { Name = name, Type = type, Pumps = new List<Pump>() });
        }
        public Pump AddPump(Factory factory, string name, PumpType type)
        {
            Pump pump = new Pump { Name = name, Type = type, factoryName = factory.Name };
            factory.Pumps.Add(pump);
            return pump;
        }
        public void RemoveFactory(Factory factory)
        {
            Factories.Remove(factory);
        }
        private readonly string _filePath = "data.txt";
        private readonly string _bakPath = "bak\\";

        //public FactoryListFileManager(string filePath)
        //{
        //    _filePath = filePath;
        //}

        public void Save()
        {
            if (File.Exists(_filePath))
            {
                FileInfo fi=new FileInfo(_filePath);               
                if (!Directory.Exists(_bakPath)) Directory.CreateDirectory(_bakPath);
                string bakName = Path.Combine(_bakPath, $"data.txt_bak_{fi.LastWriteTime.ToString("yyyy_MM_dd_HH_mm_ss")}");
                File.Copy(_filePath, bakName, true);
            }
            

            var sb = new StringBuilder();
            foreach (var factory in Factories)
            {
                // 写入工厂信息
                sb.AppendLine($"Factory,{factory.Type},{factory.Name}");

                foreach (var pump in factory.Pumps)
                {
                    // 写入水泵信息
                    sb.AppendLine($"Pump,{pump.Type},{pump.Name},{pump.额定转速},{pump.额定流量},{pump.额定扬程},{pump.额定功率}");

                    foreach (var dataset in pump.Datasets)
                    {
                        // 写入数据集信息
                        sb.AppendLine($"Dataset,{dataset.Value.Name}");
                        if (dataset.Value.range_X!=null)
                        sb.AppendLine($"Dataset_Range_X,{dataset.Value.range_X.Min},{dataset.Value.range_X.Max}");
                        if (dataset.Value.range_Y != null)
                            sb.AppendLine($"Dataset_Range_Y,{dataset.Value.range_Y.Min},{dataset.Value.range_Y.Max}");
                        if (dataset.Value.Data != null)
                            foreach (var point in dataset.Value.Data)
                            {
                                // 写入数据点信息
                                sb.AppendLine($"{point.X},{point.Y}");
                            }
                    }


                }
            }

            // 将数据写入文件
            File.WriteAllText(_filePath, sb.ToString());
        }

        public void Load()
        {
            //var factoryList = new FactoryList();
            Factories.Clear();
            if (!File.Exists(_filePath))
            {
                return;
            }

            var currentFactory = default(Factory);
            var currentPump = default(Pump);
            var currentDataset = default(Dataset);

            foreach (var line in File.ReadAllLines(_filePath))
            {
                var fields = line.Split(',');

                switch (fields[0])
                {
                    case "Factory":
                        // 读取工厂信息
                        var factoryType = (FactoryType)Enum.Parse(typeof(FactoryType), fields[1]);
                        var factoryName = fields[2];
                        currentFactory = new Factory { Name = factoryName, Type = factoryType, Pumps = new List<Pump>() };
                        this.Factories.Add(currentFactory);
                        currentPump = null;
                        currentDataset = null;
                        break;

                    case "Pump":
                        // 读取水泵信息
                        var pumpType = (PumpType)Enum.Parse(typeof(PumpType), fields[1]);
                        var pumpName = fields[2];
                        currentPump = new Pump { Name = pumpName, Type = pumpType, factoryName = currentFactory.Name, 额定转速 = double.Parse(fields[3]), 额定流量 = double.Parse(fields[4]), 额定扬程 = double.Parse(fields[5]), 额定功率 = fields.Length >= 7 ? double.Parse(fields[6]) : 75 };

                        currentFactory.Pumps.Add(currentPump);
                        currentDataset = null;
                        break;

                    case "Dataset":
                        // 读取数据集信息
                        var datasetName = fields[1];
                        currentDataset = new Dataset { Name = datasetName, Data = new List<PointF>() };
                        currentPump.Datasets[currentDataset.Name] = currentDataset;
                        break;
                    case "Dataset_Range_X":
                        {
                            double d1 = 0; double d2 = 0;
                            if (double.TryParse(fields[1], out d1) && double.TryParse(fields[2], out d2))
                            {
                                currentDataset.range_X = new Range(d1, d2);
                            }

                            break;
                        }
                        
                    case "Dataset_Range_Y":
                        {
                            double d1 = 0; double d2 = 0;
                            if (double.TryParse(fields[1], out d1) && double.TryParse(fields[2], out d2))
                            {
                                currentDataset.range_Y = new Range(d1, d2);
                            }

                            break;
                        }
                    default:
                        // 读取数据点信息
                        var x = float.Parse(fields[0]);
                        var y = float.Parse(fields[1]);
                        currentDataset.Data.Add(new PointF(x, y));
                        break;
                }
            }

            CurveFit();
            //return factoryList;
        }



        public void CurveFit()
        {
            foreach (var f in Factories)
            {
                f.CurveFit();
            }
        }

    }
}