namespace IStation.Algorithm
{
    /// <summary>
    /// 分析泵项
    /// </summary>
    public class AnaPumpItem
    {
        public AnaPumpItem() { }
        public AnaPumpItem(Pump rhs)
        {
            this.ID = rhs.ID;
            this.Name = rhs.Name;
            this.Code = rhs.Code;
            this.IsBp = rhs.IsBp;
            this.Qr = rhs.Qr;
            this.Hr = rhs.Hr;
            this.Nr = rhs.Nr;
            this.Pr = rhs.Pr;
            this.Er = rhs.Er;
            if (rhs.CurveQH != null && rhs.CurveQP != null)
            {
                this.CurveQH = rhs.CurveQH.Clone();
                this.CurveQP = rhs.CurveQP.Clone();
                this.AllowCalc = true;
            }
        }

        public AnaPumpItem(Pump rhs, double freDef, double freMin, double freMax, double freSpace) : this(rhs)
        {
            this.CalcFrequencyItems(freDef, freMin, freMax, freSpace);
        }

        public int ID { get; set; }
        public string Code { get; set; }
        public string Name { get; set; }
        public double Qr { get; set; }
        public double Hr { get; set; }
        public double Nr { get; set; }
        public double Pr { get; set; }
        public double Er { get; set; }
        public bool IsBp { get; set; }
        public Curve.CurveExpress CurveQH { get; set; }
        public Curve.CurveExpress CurveQP { get; set; }
        public List<AnaPumpFreItem> AnaFrequencyItems { get; set; }
        public bool AllowCalc { get; set; }

        void CalcFrequencyItems(double freDef, double freMin, double freMax, double freSpace)
        {
            if (!this.AllowCalc)
                return;

            this.AnaFrequencyItems = new List<AnaPumpFreItem>();
            //var freItemDef = new AnaFrequencyItem();
            //freItemDef.Frequency = freMax;
            //freItemDef.CurveQH = this.CurveQH.Clone();
            //freItemDef.CurveQP = this.CurveQP.Clone();
            //this.AnaFrequencyItems.Add(freItemDef);
            for (double fre = freMax; fre >= freMin; fre -= freSpace)
            {
                var freItem = new AnaPumpFreItem();
                freItem.Frequency = fre;
                freItem.CurveQH = Curve.PumpCalculateHelper.CalculateSimilarQH(this.CurveQH, freDef, fre);
                freItem.CurveQP = Curve.PumpCalculateHelper.CalculateSimilarQP(this.CurveQP, freDef, fre);
                this.AnaFrequencyItems.Add(freItem);
            }
        }
    }

    /// <summary>
    /// 分析泵变频项
    /// </summary>
    public class AnaPumpFreItem
    {
        public double Frequency { get; set; }
        public Curve.CurveExpress CurveQH { get; set; }
        public Curve.CurveExpress CurveQP { get; set; }
    }

    /// <summary>
    /// 调度分析辅助类
    /// </summary>
    public class SchedulingAnaHelper
    {
        double _frequency_def = 50;
        double _frequency_min = 25;
        double _frequency_max = 50;
        double _frequency_space = 0.1;//频率间隔  

        DAL.ScheduleCombine _dal = new DAL.ScheduleCombine();
        DAL.ScheduleCombineLog _dalLog = new DAL.ScheduleCombineLog();
        DAL.ScheduleAnaLog _dalAnaLog = new DAL.ScheduleAnaLog();


        #region TableName
        string _tableFrePumpTag = "B";
        string _tableFixPumpTag = "G";
        string _tableSpaceMark = "_";

        string GetTableName(List<AnaPumpItem> pumpItems)
        {
            var tableName = string.Empty;
            var count = pumpItems.Count;
            pumpItems = pumpItems.OrderBy(p => p.ID).ToList();
            for (int i = 0; i < count; i++)
            {
                var pumpItem = pumpItems[i];
                tableName += GetTableName(pumpItem);
                if ((i + 1) != count)
                {
                    tableName += _tableSpaceMark;
                }
            }
            return tableName;
        }

        string GetTableName(AnaPumpItem pumpItem)
        {
            return (pumpItem.IsBp ? _tableFrePumpTag : _tableFixPumpTag) + pumpItem.ID;
        }

        #endregion

        /// <summary>
        /// 分析泵组合
        /// </summary>
        /// <param name="pumps">泵列表</param>
        /// <returns></returns>
        public bool AnaPumpCombine(List<Pump> pumps)
        {
            if (pumps == null || pumps.Count < 1)
                return false;
            var fre_def = _frequency_def;
            var anaPumpItems = new List<AnaPumpItem>();
            foreach (var pump in pumps)
            {
                if (pump.IsBp)
                {
                    //变频泵
                    var anaPump = new AnaPumpItem(pump, fre_def, _frequency_min, _frequency_max, _frequency_space);
                    if (anaPump.AllowCalc)
                        anaPumpItems.Add(anaPump);
                }
                else
                {
                    //固频泵
                    var anaPump = new AnaPumpItem(pump);
                    if (anaPump.AllowCalc)
                        anaPumpItems.Add(anaPump);
                }
            }

            if (anaPumpItems.Count < 1)
                return false;

            InsertAnaLog("开始分析");
            var maxRunCount = 3;
            var anaPumpItemsArray = anaPumpItems.ToArray();
            for (int runCount = 1; runCount <= maxRunCount; runCount++)
            {
                var pumpCombineList = PermutationAndCombination<AnaPumpItem>.GetCombination(anaPumpItemsArray, runCount);
                for (int i = 0; i < pumpCombineList.Count; i++)
                {
                    var anaPumps = pumpCombineList[i].ToList();
                    var runFalg = GetTableName(anaPumps);
                    var scheduleCombineList = GetScheduleCombineList(runFalg, anaPumps);

                }


            }
            InsertAnaLog("分析完毕");
            return true;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="runFlag"></param>
        /// <param name="anaPumps"></param>
        /// <returns></returns>
        private List<Model.ScheduleCombine> GetScheduleCombineList(string runFlag, List<AnaPumpItem> anaPumps)
        {
            if (anaPumps == null || anaPumps.Count < 2)
                return default;
            if (anaPumps.Exists(x => !x.AllowCalc))
                return default;
            List<AnaPumpFreItem> pump1, pump2, pump3;
            var parallelHelper = new ParallelConnectionHelper();

            var list = new List<Model.ScheduleCombine>();
            var pumpCount = anaPumps.Count;
            switch (pumpCount)
            {
                case 1:
                    {
                        pump1 = anaPumps[0].AnaFrequencyItems;
                        foreach (var freItem in pump1)
                        {
                            var scheduleCombine = new Model.ScheduleCombine();
                            scheduleCombine.RunFlag = runFlag;
                            scheduleCombine.RunCount = pumpCount;
                            scheduleCombine.RunHZ = $"{freItem.Frequency}";
                            scheduleCombine.CurveQH = freItem.CurveQH;
                            scheduleCombine.CurveQP = freItem.CurveQP;
                            scheduleCombine.AnaStatus = false;
                            list.Add(scheduleCombine);
                        }
                    }
                    break;
                case 2:
                    {
                        pump1 = anaPumps[0].AnaFrequencyItems;
                        pump2 = anaPumps[1].AnaFrequencyItems;
                        for (int pump1Index = 0; pump1Index < pump1.Count; pump1Index++)
                        {
                            for (int pump2Index = 0; pump2Index < pump2.Count; pump2Index++)
                            {
                                var freItem1 = pump1[pump1Index];
                                var freItem2 = pump2[pump2Index];

                                parallelHelper.ClearCurve();
                                parallelHelper.AddCurve(freItem1.CurveQH, freItem1.CurveQP);
                                parallelHelper.AddCurve(freItem2.CurveQH, freItem2.CurveQP);
                                var allowParallel = parallelHelper.CalculateParallel(out List<CurvePoint> pointQH, out List<CurvePoint> pointQE, out List<CurvePoint> pointQP);
                                if (!allowParallel)
                                    continue;

                                var scheduleCombine = new Model.ScheduleCombine();
                                scheduleCombine.RunFlag = runFlag;
                                scheduleCombine.RunCount = pumpCount;
                                scheduleCombine.RunHZ = $"{freItem1.Frequency},{freItem2.Frequency}";
                                scheduleCombine.CurveQH = FitHelper.BuildCurveExpress(pointQH);
                                scheduleCombine.CurveQP = FitHelper.BuildCurveExpress(pointQP);
                                scheduleCombine.AnaStatus = false;
                                list.Add(scheduleCombine);
                            }
                        }
                    }
                    break;
                case 3:
                    {
                        pump1 = anaPumps[0].AnaFrequencyItems;
                        pump2 = anaPumps[1].AnaFrequencyItems;
                        pump3 = anaPumps[2].AnaFrequencyItems;
                        for (int pump1Index = 0; pump1Index < pump1.Count; pump1Index++)
                        {
                            for (int pump2Index = 0; pump2Index < pump2.Count; pump2Index++)
                            {
                                for (int pump3Index = 0; pump3Index < pump3.Count; pump3Index++)
                                {
                                    var freItem1 = pump1[pump1Index];
                                    var freItem2 = pump2[pump2Index];
                                    var freItem3 = pump3[pump3Index];

                                    parallelHelper.ClearCurve();
                                    parallelHelper.AddCurve(freItem1.CurveQH, freItem1.CurveQP);
                                    parallelHelper.AddCurve(freItem2.CurveQH, freItem2.CurveQP);
                                    parallelHelper.AddCurve(freItem3.CurveQH, freItem3.CurveQP);
                                    var allowParallel = parallelHelper.CalculateParallel(out List<CurvePoint> pointQH, out List<CurvePoint> pointQE, out List<CurvePoint> pointQP);
                                    if (!allowParallel)
                                        continue;

                                    var scheduleCombine = new Model.ScheduleCombine();
                                    scheduleCombine.RunFlag = runFlag;
                                    scheduleCombine.RunCount = pumpCount;
                                    scheduleCombine.RunHZ = $"{freItem1.Frequency},{freItem2.Frequency},{freItem3.Frequency}";
                                    scheduleCombine.CurveQH = FitHelper.BuildCurveExpress(pointQH);
                                    scheduleCombine.CurveQP = FitHelper.BuildCurveExpress(pointQP);
                                    scheduleCombine.AnaStatus = false;
                                    list.Add(scheduleCombine);

                                }
                            }
                        }
                    }
                    break;
                default: break;
            }
            return list;
        }


        /// <summary>
        /// 插入分析日志
        /// </summary>
        /// <param name="info"></param> 
        private void InsertAnaLog(string info)
        {
            var entity = new Entity.ScheduleAnaLog(info);
            _dalAnaLog.Insert(entity);
        }

    }

    ///// <summary>
    ///// 数据库
    ///// </summary>
    //public class _dalAnaLog
    //{
    //    /// <summary>
    //    /// 连接配置
    //    /// </summary>
    //    public static ConnectionConfig ConnectionConfig
    //    {
    //        get
    //        {

    //            var filePath = DAL._dalAnaLogInitial._dalAnaLogFilePath;
    //            if (!System.IO.File.Exists(filePath))
    //            {
    //                DAL._dalAnaLogInitial.InitTables();
    //            }

    //            var config = new ConnectionConfig()
    //            {
    //                ConnectionString = $"DataSource={filePath}",
    //                IsAutoCloseConnection = true,
    //                _dalAnaLogType = SqlSugar._dalAnaLogType.Sqlite
    //            };
    //            return config;
    //        }
    //    }



    //    /// <summary>
    //    /// 大批量插入
    //    /// </summary>
    //    public static bool BulkInserts()
    //    {
    //        //if (list == null || list.Count < 1)
    //        //    return default;
    //        //var entities = Models2Entities(list);
    //        //using (SqlSugarClient db = new SqlSugarClient(ConnectionConfig))
    //        //{
    //        //    ///自己来制定定义的规则
    //        //    db.CurrentConnectionConfig.ConfigureExternalServices.SplitTableService = new RunFlagSubTableService();
    //        //    db.CodeFirst
    //        //        .SplitTables()//标识分表
    //        //        .InitTables<ScheduleCombine>(); //程序启动时加这一行,如果一张表没有会初始化一张

    //        //    //大数据写入+表不存在会建表
    //        //    //自动找表大数据写入 
    //        //    return db.Fastest<Entity.ScheduleCombine>().SplitTable().BulkCopy(entities) > 0;
    //        //}

    //        return false;
    //    }

    //    /// <summary>
    //    /// 大批量插入
    //    /// </summary>
    //    public static bool BulkInserts(List<Model.ScheduleCombine> list)
    //    {
    //        if (list == null || !list.Any())
    //            return false;
    //        var entities = Models2Entities(list);
    //        if (entities == null || !entities.Any())
    //            return false;
    //        using (SqlSugarClient db = new SqlSugarClient(ConnectionConfig))
    //        {
    //            return db.Fastest<Entity.ScheduleCombine>().BulkCopy(entities) > 0;
    //        }
    //    }

    //    static List<Entity.ScheduleCombine> Models2Entities(List<Model.ScheduleCombine> modelList)
    //    {
    //        if (modelList == null || !modelList.Any())
    //            return default;
    //        var entities = new List<Entity.ScheduleCombine>();
    //        foreach (var model in modelList)
    //        {
    //            var entity = new Entity.ScheduleCombine();
    //            entity.RunFlag = model.RunFlag;
    //            entity.RunCount = model.RunCount;
    //            entity.RunHZ = model.RunHZ;
    //            entity.CurveQH = model.CurveQH?.ToJson();
    //            entity.CurveQP = model.CurveQP?.ToJson();
    //            entity.AnaStatus = model.AnaStatus;
    //            entities.Add(entity);
    //        }
    //        return entities;
    //    }

    //    /// <summary>
    //    /// 插入
    //    /// </summary>
    //    public static bool Insert(string info)
    //    {
    //        var log = new Entity.ScheduleAnaLog(info);
    //        using (SqlSugarClient db = new SqlSugarClient(ConnectionConfig))
    //        {
    //            return db.Insertable(log).ExecuteCommandIdentityIntoEntity();
    //        }
    //    }

    //    internal static object SplitHelper<T>()
    //    {
    //        throw new NotImplementedException();
    //    }
    //}

    ///// <summary>
    ///// 分表规则
    ///// </summary>
    //public class RunFlagSubTableService : ISplitTableService
    //{
    //    /// <summary>
    //    /// 获取所有的数据库中的表
    //    /// </summary>
    //    /// <param name="db"></param>
    //    /// <param name="EntityInfo"></param>
    //    /// <param name="tableInfos"></param>
    //    /// <returns></returns>
    //    /// <exception cref="NotImplementedException"></exception>
    //    public List<SplitTableInfo> GetAllTables(ISqlSugarClient db, EntityInfo EntityInfo, List<_dalAnaLogTableInfo> tableInfos)
    //    {
    //        List<SplitTableInfo> result = new List<SplitTableInfo>();
    //        foreach (var item in tableInfos)
    //        {
    //            if (item.Name.Contains("_Run_")) //区分标识如果不用正则符复杂一些，防止找错表
    //            {
    //                SplitTableInfo data = new SplitTableInfo()
    //                {
    //                    TableName = item.Name //要用item.name不要写错了
    //                };
    //                result.Add(data);
    //            }
    //        }
    //        return result.OrderBy(it => it.TableName).ToList();//打断点看一下有没有查出所有分表
    //    }

    //    /// <summary>
    //    /// 
    //    /// </summary>
    //    /// <param name="db"></param>
    //    /// <param name="entityInfo"></param>
    //    /// <param name="splitType"></param>
    //    /// <param name="entityValue"></param>
    //    /// <returns></returns>
    //    public object GetFieldValue(ISqlSugarClient db, EntityInfo entityInfo, SplitType splitType, object entityValue)
    //    {
    //        var splitColumn = entityInfo.Columns.FirstOrDefault(it => it.PropertyInfo.GetCustomAttribute<SplitFieldAttribute>() != null);
    //        return splitColumn.PropertyInfo.GetValue(entityValue, null);
    //    }

    //    /// <summary>
    //    /// 
    //    /// </summary>
    //    /// <param name="db"></param>
    //    /// <param name="EntityInfo"></param>
    //    /// <returns></returns>
    //    public string GetTableName(ISqlSugarClient db, EntityInfo EntityInfo)
    //    {
    //        return EntityInfo._dalAnaLogTableName + "_Run";
    //    }

    //    public string GetTableName(ISqlSugarClient db, EntityInfo EntityInfo, SplitType type)
    //    {
    //        return EntityInfo._dalAnaLogTableName + "_Run";
    //    }

    //    /// <summary>
    //    /// 确定生成数据库表的时候，表的名称
    //    /// </summary>
    //    /// <param name="db"></param>
    //    /// <param name="entityInfo"></param>
    //    /// <param name="splitType"></param>
    //    /// <param name="fieldValue"></param>
    //    /// <returns></returns>
    //    public string GetTableName(ISqlSugarClient db, EntityInfo entityInfo, SplitType splitType, object fieldValue)
    //    {
    //        return entityInfo._dalAnaLogTableName + "_Run_" + fieldValue.ToString();
    //    }
    //}

    ///// <summary>
    ///// 调度组合
    ///// </summary> 
    //[SplitTable(SplitType._Custom01)]
    //public class ScheduleCombine
    //{
    //    public ScheduleCombine() { }
    //    public ScheduleCombine(ScheduleCombine rhs)
    //    {
    //        this.Pump1 = rhs.Pump1;
    //        this.Pump2 = rhs.Pump2;
    //        this.Pump3 = rhs.Pump3;
    //        this.Head = rhs.Head;
    //        this.Flow = rhs.Flow;
    //        this.Power = rhs.Power;
    //        this.WP = rhs.WP;
    //        this.UWP = rhs.UWP;
    //    }

    //    public void Round()
    //    {
    //        this.Pump1 = Math.Round(this.Pump1, 1);
    //        this.Pump2 = Math.Round(this.Pump2, 1);
    //        this.Pump3 = Math.Round(this.Pump3, 1);
    //        this.Head = Math.Round(this.Head, 1);
    //        this.Flow = Math.Round(this.Flow, 1);
    //        this.Power = Math.Round(this.Power, 1);
    //        this.WP = Math.Round(this.WP, 1);
    //        this.UWP = Math.Round(this.UWP, 1);

    //    }

    //    /// <summary>
    //    /// 运行标志 (标志枚举)
    //    /// </summary>
    //    [SplitField]
    //    public string RunFlag { get; set; }

    //    /// <summary>
    //    /// 泵1
    //    /// </summary>
    //    public double Pump1 { get; set; }

    //    /// <summary>
    //    /// 泵2
    //    /// </summary>
    //    public double Pump2 { get; set; }

    //    /// <summary>
    //    /// 泵3
    //    /// </summary>
    //    public double Pump3 { get; set; }

    //    /// <summary>
    //    /// 扬程
    //    /// </summary>
    //    public double Head { get; set; }

    //    /// <summary>
    //    /// 总流量
    //    /// </summary>
    //    public double Flow { get; set; }

    //    /// <summary>
    //    /// 总功率
    //    /// </summary>
    //    public double Power { get; set; }

    //    /// <summary>
    //    /// 千吨水能耗 
    //    /// </summary>
    //    public double WP { get; set; }

    //    /// <summary>
    //    /// 单位能耗
    //    /// </summary>
    //    public double UWP { get; set; }

    //    /// <summary>
    //    /// 创建时间
    //    /// </summary>
    //    public DateTime CreateTime { get; set; } = DateTime.Now;


    //}
}