using System;
using System.Collections.Generic;
using System.Linq;

namespace IStation.Model
{
    /// <summary>
    /// 曲线计算辅助类
    /// </summary>
    public class CurveCalcuHelper
    {
        #region 计算效率

        /// <summary>
        /// 计算效率
        /// </summary>
        /// <param name="q"> 瞬时流量 m³/h</param>
        /// <param name="h"> 扬程 m</param>
        /// <param name="p"> 功率 kw</param>
        /// <param name="ρ"> 密度 kg/m^3</param>
        /// <param name="g"> 重力加速度 m/s^2</param>
        /// <returns>百分数</returns>
        public static double CalculateE(double q, double h, double p, double ρ, double g)
        {
            q = q / 3600;
            p = p * 1000;
            double e = 0;
            if (p < 0.1)
                return e;
            e = ρ * g * q * h / p;
            return Math.Round(e * 100, 2);
        }

        /// <summary>
        /// 计算效率
        /// </summary>
        /// <param name="q"> 瞬时流量 m³/h</param>
        /// <param name="h"> 扬程 m</param>
        /// <param name="p"> 功率 kw</param>
        /// <returns>百分数</returns>
        public static double CalculateE(double q, double h, double p)
        {
            return CalculateE(q, h, p, ConstantParas.WaterDensity, ConstantParas.g);
        }

        /// <summary>
        /// 计算效率
        /// </summary>
        /// <param name="q"> 瞬时流量 m³/h</param>
        /// <param name="h"> 扬程 m</param>
        /// <param name="p"> 功率 kw</param>
        /// <param name="ρ"> 密度 kg/m^3</param>
        /// <returns>百分数</returns>
        public static double CalculateE(double q, double h, double p, double ρ)
        {
            return CalculateE(q, h, p, ρ, ConstantParas.g);
        }

        #endregion

        #region 计算功率

        /// <summary>
        /// 计算功率
        /// </summary>
        /// <param name="q">瞬时流量 m³/h</param>
        /// <param name="h">扬程 m</param>
        /// <param name="e">效率 百分数</param>
        /// <param name="ρ">密度kg/m³</param>
        /// <param name="g">重力加速度 m/s²</param>
        /// <returns>kw</returns>
        public static double CalculateP(double q, double h, double e, double ρ, double g)
        {
            q = q / 3600;
            e = e / 100;
            double p = 0;
            if (e < 0.01)
                return p;
            p = ρ * g * q * h / e;
            p = p / 1000;//换算成kw
            if (p < 2)
                return Math.Round(p, 4);
            if (p < 30)
                return Math.Round(p, 3);
            if (p < 100)
                return Math.Round(p, 2);
            return Math.Round(p, 1);

        }

        /// <summary>
        /// 计算功率
        /// </summary>
        /// <param name="q">瞬时流量 m³/h</param>
        /// <param name="h">扬程 m</param>
        /// <param name="e">效率 百分数</param>
        /// <param name="ρ">密度kg/m³</param>
        /// <returns>kw</returns>
        public static double CalculateP(double q, double h, double e, double ρ)
        {
            return CalculateP(q, h, e, ρ, ConstantParas.g);
        }

        /// <summary>
        /// 计算功率
        /// </summary>
        /// <param name="q">瞬时流量 m³/h</param>
        /// <param name="h">扬程 m</param>
        /// <param name="e">效率 百分数</param>
        /// <returns>kw</returns>
        public static double CalculateP(double q, double h, double e)
        {
            return CalculateP(q, h, e, ConstantParas.WaterDensity, ConstantParas.g);
        }

        #endregion

        #region Mpa<=>m

        /// <summary>
        /// Mpa=>m
        /// </summary>
        public static double Mpa2M(double mpa)
        {
            return mpa * ConstantParas.WaterDensity / ConstantParas.g;
        }

        /// <summary>
        /// m=>Mpa
        /// </summary>
        public static double M2Mpa(double m)
        {
            return m * ConstantParas.g / ConstantParas.WaterDensity;
        }


        #endregion

        #region 计算用电量

        /// <summary>
        /// 计算用电量
        /// </summary>
        /// <param name="p">功率kw</param>
        /// <param name="t">时间h</param>
        /// <returns>kw*h</returns>
        public static double CalculateD(double p, double t)
        {
            return p * t;
        }

        #endregion

        #region 计算累积流量

        /// <summary>
        /// 计算累积流量
        /// </summary>
        /// <param name="q">瞬时流量m³/h</param>
        /// <param name="t">时间h</param>
        /// <returns>m³</returns>
        public static double CalculateQt(double q, double t)
        {
            return q * t;
        }

        #endregion

        #region 计算能耗

        /// <summary>
        /// 计算千吨能耗
        /// </summary>
        /// <param name="p">功率kW</param>
        /// <param name="q">瞬时流量m³/h</param>
        /// <returns>kW·h/km³</returns>
        public static double CalculateWP(double p, double q)
        {
            if (q < 0.1)
                return 0;
            return p / q * 1000;
        }

        /// <summary>
        /// 计算单位能耗
        /// </summary>
        /// <param name="p">功率kW</param>
        /// <param name="q">瞬时流量m³/h</param>
        /// <param name="h">扬程m</param>
        /// <returns>kW·h/km³</returns>
        public static double CalculateUWP(double p, double q, double h)
        {
            if (q < 0.1)
                return default;
            if (h < 0.1)
                return default;
            return p / q / h * 1000;
        }

        #endregion

        #region 计算其他压力 nsx 20220504
        /// <summary>
        /// 计算其他压力
        /// </summary>
        /// <param name="q">流量 m³/h  </param>
        /// <param name="inletPipeDia">进口管径 mm </param>
        /// <param name="outletPipeDia">出口管径 mm </param>
        /// <param name="inletElevation">进口标高 m </param>
        /// <param name="outletElevation">出口标高 m </param>
        /// <returns></returns>
        public static double CalculateOtherPress(double? q, double? inletPipeDia, double? outletPipeDia, double? inletElevation, double? outletElevation)
        {
            if (q == null || q.Value < 0.05)
            {
                if (outletElevation == null || inletElevation == null)
                    return 0;
                return outletElevation.Value - inletElevation.Value;
            }

            double flow = q.Value;
            double inPipeV = 0;
            if (inletPipeDia != null && inletPipeDia.Value > 0.1)
            {
                // 流速计算 pipeD =mm,pumpFlow=m3/p
                inPipeV = ConstantParas.OtherPressCoeff * flow / inletPipeDia.Value / inletPipeDia.Value;
            }

            double outPipeV = 0;
            if (outletPipeDia != null && outletPipeDia.Value > 0.1)
            {
                // 流速计算 rPipeD =mm,rPumpFlow=m3/p
                outPipeV = ConstantParas.OtherPressCoeff * flow / outletPipeDia.Value / outletPipeDia.Value;
            }

            double differV = (outPipeV * outPipeV - inPipeV * inPipeV) / ConstantParas.g / 2.0;

            if (outletElevation == null || inletElevation == null)
                return differV;

            return differV + outletElevation.Value - inletElevation.Value;
        }

        #endregion

        #region 计算50Hz时的值

        /// <summary>
        /// 根据频率计算 50hz流量
        /// </summary>
        /// <param name="q">瞬时流量 m³/h</param>
        /// <param name="hz">频率 kw</param>
        /// <returns></returns>
        public static double Calculate50QByHz(double q, double hz)
        {
            if (hz < 10 || hz > 49.9)
                return q;
            double f_ratio = 50 / hz;

            return q * f_ratio;
        }

        /// <summary>
        /// 根据频率计算 50hz扬程
        /// </summary>
        /// <param name="h">扬程 m</param>
        /// <param name="hz">频率 kw</param>
        /// <returns></returns>
        public static double Calculate50HByHz(double h, double hz)
        {
            if (hz < 10 || hz > 49.9)
                return h;
            double f_ratio = 50 / hz;
            return h * f_ratio * f_ratio;
        }

        /// <summary>
        /// 根据频率计算 50hz功率
        /// </summary>
        /// <param name="p">功率 kw</param>
        /// <param name="hz">频率 kw</param>
        /// <returns></returns>
        public static double CalculatePByHz(double p, double hz)
        {
            if (hz < 10 || hz > 49.9)
                return p;
            double f_ratio = 50 / hz;
            return p * f_ratio * f_ratio * f_ratio;
        }

        #endregion

        #region 相似换算

        /// <summary>
        /// 计算相似流量扬程曲线
        /// </summary>
        /// <param name="express">表达式</param>
        /// <param name="originHz">原始频率</param>
        /// <param name="changeHz">换算频率</param>
        /// <param name="pointNumber">拟合点数量</param>
        /// <returns></returns>
        public static CurveExpress CalculateSimilarQH(CurveExpress express, double originHz, double changeHz, int pointNumber = 12)
        {
            if (express == null)
                return null;
            if (changeHz < 1)
                return null;
            List<CurvePoint> fitPoints = null;
            if (express.DefinePoints != null && express.DefinePoints.Any())
                fitPoints = express.DefinePoints;
            else
                fitPoints = FitCurveHelper.GetFitPoints(express, pointNumber);

            var ratio = changeHz / originHz;
            var similarPoints = new List<CurvePoint>();
            foreach (CurvePoint fitPoint in fitPoints)
            {
                var similarPoint = new CurvePoint();
                similarPoint.X = fitPoint.X * ratio;
                similarPoint.Y = fitPoint.Y * ratio * ratio;
                similarPoints.Add(similarPoint);
            }
            return new CurveExpress(similarPoints, express.FitType);
        }

        /// <summary>
        /// 计算相似流量功率曲线
        /// </summary>
        /// <param name="express">表达式</param>
        /// <param name="originHz">原始频率</param>
        /// <param name="changeHz">换算频率</param>
        /// <param name="pointNumber">拟合点数量</param>
        /// <returns></returns>
        public static CurveExpress CalculateSimilarQP(CurveExpress express, double originHz, double changeHz, int pointNumber = 12)
        {
            if (express == null)
                return null;
            if (changeHz < 1)
                return null;
            List<CurvePoint> fitPoints = null;
            if (express.DefinePoints != null && express.DefinePoints.Any())
                fitPoints = express.DefinePoints;
            else
                fitPoints = FitCurveHelper.GetFitPoints(express, pointNumber);

            var ratio = changeHz / originHz;
            var similarPoints = new List<CurvePoint>();
            foreach (CurvePoint fitPoint in fitPoints)
            {
                var similarPoint = new CurvePoint();
                similarPoint.X = fitPoint.X * ratio;
                similarPoint.Y = fitPoint.Y * ratio * ratio * ratio;
                similarPoints.Add(similarPoint);
            }
            return new CurveExpress(similarPoints, express.FitType);
        }

        /// <summary>
        /// 计算相似流量效率曲线
        /// </summary>
        /// <param name="express">表达式</param>
        /// <param name="originHz">原始频率</param>
        /// <param name="changeHz">换算频率</param>
        /// <param name="pointNumber">拟合点数量</param>
        /// <returns></returns>
        public static CurveExpress CalculateSimilarQE(CurveExpress express, double originHz, double changeHz, int pointNumber = 12)
        {
            if (express == null)
                return null;
            if (changeHz < 1)
                return null;
            List<CurvePoint> fitPoints = null;
            if (express.DefinePoints != null && express.DefinePoints.Any())
                fitPoints = express.DefinePoints;
            else
                fitPoints = FitCurveHelper.GetFitPoints(express, pointNumber);

            var ratio = changeHz / originHz;
            var similarPoints = new List<CurvePoint>();
            foreach (CurvePoint fitPoint in fitPoints)
            {
                var similarPoint = new CurvePoint();
                similarPoint.X = fitPoint.X * ratio;
                similarPoint.Y = fitPoint.Y;
                similarPoints.Add(similarPoint);
            }
            return new CurveExpress(similarPoints, express.FitType);
        }


        /// <summary>
        /// 计算相似流量扬程点
        /// </summary>
        /// <param name="fitPoint">点</param>
        /// <param name="originHz">原始频率</param>
        /// <param name="changeHz">换算频率</param> 
        /// <returns></returns>
        public static CurvePoint CalculateSimilarQH(CurvePoint fitPoint, double originHz, double changeHz)
        {
            if (fitPoint == null)
                return null;
            if (changeHz < 1)
                return null;
            var ratio = changeHz / originHz;
            var similarPoint = new CurvePoint();
            similarPoint.X = fitPoint.X * ratio;
            similarPoint.Y = fitPoint.Y * ratio * ratio;
            return similarPoint;
        }

        /// <summary>
        /// 计算相似流量功率点
        /// </summary>
        /// <param name="express">点</param>
        /// <param name="originHz">原始频率</param>
        /// <param name="changeHz">换算频率</param> 
        /// <returns></returns>
        public static CurvePoint CalculateSimilarQP(CurvePoint fitPoint, double originHz, double changeHz)
        {
            if (fitPoint == null)
                return null;
            if (changeHz < 1)
                return null;
            var ratio = changeHz / originHz;
            var similarPoint = new CurvePoint();
            similarPoint.X = fitPoint.X * ratio;
            similarPoint.Y = fitPoint.Y * ratio * ratio * ratio;
            return similarPoint;
        }

        /// <summary>
        /// 计算相似流量效率点
        /// </summary>
        /// <param name="express">点</param>
        /// <param name="originHz">原始频率</param>
        /// <param name="changeHz">换算频率</param> 
        /// <returns></returns>
        public static CurvePoint CalculateSimilarQE(CurvePoint fitPoint, double originHz, double changeHz)
        {
            if (fitPoint == null)
                return null;
            if (changeHz < 1)
                return null;
            var ratio = changeHz / originHz;
            var similarPoint = new CurvePoint();
            similarPoint.X = fitPoint.X * ratio;
            similarPoint.Y = fitPoint.Y;

            return similarPoint;
        }
        #endregion
    }
}