namespace IStation.Test
{

    public class DynamicThresholdProcessorHelper
    {

        public static List<(int, double, double)> Filter(List<(int, double, double)> ptList)
        {
            var pressures = ptList.Select(p => p.Item3).ToList();

            // 计算统计量
            var (mean, stdDev) = CalculateStats(pressures);
            double skewness = CalculateSkewness(pressures);
            // 动态调整σ倍数
            double sigmaMultiplier = CalculateSigmaMultiplier(skewness);
            sigmaMultiplier = 3;//目前默认 标准差

            // 计算边界
            double lower = mean - sigmaMultiplier * stdDev;
            double upper = mean + sigmaMultiplier * stdDev;

            return ptList.Where(p => p.Item3 >= lower && p.Item3 <= upper).ToList();
        }


        public static List<PointViewModel> Filter(List<PointViewModel> ptList)
        {
            var pressures = ptList.Select(p => p.Y).ToList();

            // 计算统计量
            var (mean, stdDev) = CalculateStats(pressures);
            double skewness = CalculateSkewness(pressures);
            // 动态调整σ倍数
            double sigmaMultiplier = CalculateSigmaMultiplier(skewness);
            sigmaMultiplier = 3;//目前默认 标准差
             
            // 计算边界
            double lower = mean - sigmaMultiplier * stdDev;
            double upper = mean + sigmaMultiplier * stdDev;

            return ptList.Where(p => p.Y >= lower && p.Y <= upper).ToList();
        }

        public static List<PumpViewModel> Filter(List<PumpViewModel> ptList)
        {
            var pressures = ptList.Select(p => p.PressureDiff).ToList();

            // 计算统计量
            var (mean, stdDev) = CalculateStats(pressures);
            double skewness = CalculateSkewness(pressures);
            // 动态调整σ倍数
            double sigmaMultiplier = CalculateSigmaMultiplier(skewness);
            sigmaMultiplier = 3;//目前默认 标准差

            // 计算边界
            double lower = mean - sigmaMultiplier * stdDev;
            double upper = mean + sigmaMultiplier * stdDev;

            return ptList.Where(p => p.PressureDiff >= lower && p.PressureDiff <= upper).ToList();
        }

        public static List<Model.StationSignalRecord> Filter(List<Model.StationSignalRecord> ptList)
        {
            var pressures = ptList.Select(p => p.TotalPressure).ToList();

            // 计算统计量
            var (mean, stdDev) = CalculateStats(pressures);
            double skewness = CalculateSkewness(pressures);
            // 动态调整σ倍数
            double sigmaMultiplier = CalculateSigmaMultiplier(skewness);
            sigmaMultiplier = 3;//目前默认 标准差


            // 计算边界
            double lower = mean - sigmaMultiplier * stdDev;
            double upper = mean + sigmaMultiplier * stdDev;

            return ptList.Where(p => p.TotalPressure >= lower && p.TotalPressure <= upper).ToList();
        }


        public static List<Model.PumpSignalRecord> Filter(List<Model.PumpSignalRecord> ptList)
        {
            var pressures = ptList.Select(p => p.Head).ToList();

            // 计算统计量
            var (mean, stdDev) = CalculateStats(pressures);
            double skewness = CalculateSkewness(pressures);
            // 动态调整σ倍数
            double sigmaMultiplier = CalculateSigmaMultiplier(skewness);
            sigmaMultiplier = 3;//目前默认 标准差


            // 计算边界
            double lower = mean - sigmaMultiplier * stdDev;
            double upper = mean + sigmaMultiplier * stdDev;

            return ptList.Where(p => p.Head >= lower && p.Head <= upper).OrderBy(x => x.FlowRate).ToList();
        }


        // 核心统计计算
        public static (double mean, double stdDev) CalculateStats(List<double> values)
        {
            double mean = values.Average();
            double stdDev = Math.Sqrt(values.Sum(v => Math.Pow(v - mean, 2)) / (values.Count - 1));
            return (mean, stdDev);
        }

        // 偏度计算（Pearson's moment coefficient）
        private static double CalculateSkewness(List<double> values)
        {
            double mean = values.Average();
            double std = CalculateStats(values).stdDev;
            double sum = values.Sum(v => Math.Pow((v - mean) / std, 3));
            return (sum * values.Count) / ((values.Count - 1) * (values.Count - 2));
        }

        // 动态σ倍数计算规则
        private static double CalculateSigmaMultiplier(double skewness)
        {

            return skewness switch
            {
                > 1.0 => 2.0,    // 强正偏态
                > 0.5 => 2.5,
                > -0.5 => 3.0,   // 近似正态
                > -1.0 => 3.5,
                _ => 4.0    // 强负偏态
            };
        }

    }



}