namespace PBS.Console.Test
{
    using System;
    using System.Collections.Generic;

    public class WaterDistributionSystem1
    {
        #region 核心算法类
        public class ModelConfig
        {
            public int NodeCount { get; set; }      // 节点总数
            public int TotalRuns { get; set; }      // 总计算次数
            public double MinDemand { get; set; }   // 最小总需水量(m³/h)
            public double MaxDemand { get; set; }   // 最大总需水量(m³/h)
            public List<(double min, double max)> NodeLimits { get; set; } = new(); // 节点水量限制
        }

        public class SimulationResult
        {
            public double TotalDemand { get; set; }
            public double[] NodeDemands { get; }
            public DateTime Timestamp { get; }

            public SimulationResult(int nodeCount)
            {
                NodeDemands = new double[nodeCount];
                Timestamp = DateTime.Now;
            }
        }

        public class DemandGenerator
        {
            private readonly ModelConfig _config;
            private readonly Random _rand = new();

            public DemandGenerator(ModelConfig config) => _config = config;

            // 生成需求矩阵（符合规范[6](@ref)的线性递增策略）
            public List<SimulationResult> GenerateDemandMatrix()
            {
                var results = new List<SimulationResult>(_config.TotalRuns);
                double step = (_config.MaxDemand - _config.MinDemand) / (_config.TotalRuns - 1);

                for (int i = 0; i < _config.TotalRuns; i++)
                {
                    double currentDemand = _config.MinDemand + step * i;
                    results.Add(GenerateDemandSet(currentDemand));
                }
                return results;
            }

            // 单个需求集生成算法（包含节点约束[4](@ref)）
            private SimulationResult GenerateDemandSet(double totalDemand)
            {
                var result = new SimulationResult(_config.NodeCount);
                double remaining = totalDemand;

                // 第一阶段：分配最小需求
                for (int i = 0; i < _config.NodeCount; i++)
                {
                    result.NodeDemands[i] = _config.NodeLimits[i].min;
                    remaining -= result.NodeDemands[i];
                }

                // 第二阶段：加权随机分配剩余水量（遗传算法优化思路[1](@ref)）
                double[] weights = GenerateWeights();
                double weightSum = Sum(weights);

                for (int i = 0; i < _config.NodeCount && remaining > 0; i++)
                {
                    double allocatable = Math.Min(
                        remaining * (weights[i] / weightSum),
                        _config.NodeLimits[i].max - result.NodeDemands[i]
                    );

                    result.NodeDemands[i] += allocatable;
                    remaining -= allocatable;
                }

                // 第三阶段：误差修正（确保总和精确）
                if (remaining > 0)
                {
                    int index = _rand.Next(_config.NodeCount);
                    result.NodeDemands[index] = Math.Min(
                        result.NodeDemands[index] + remaining,
                        _config.NodeLimits[index].max
                    );
                }

                result.TotalDemand = Sum(result.NodeDemands);
                return result;
            }

            // 生成遗传算法权重（参考[1,3](@ref)）
            private double[] GenerateWeights()
            {
                double[] weights = new double[_config.NodeCount];
                for (int i = 0; i < weights.Length; i++)
                {
                    weights[i] = _rand.NextDouble() * 0.8 + 0.2; // 20%基础权重+随机变异
                }
                return weights;
            }

            private static double Sum(double[] arr)
            {
                double sum = 0;
                foreach (var v in arr) sum += v;
                return sum;
            }
        }
        #endregion

        //#region 使用示例
        //public static void Main()
        //{
        //    var config = new ModelConfig
        //    {
        //        NodeCount = 5,
        //        TotalRuns = 10,
        //        MinDemand = 50,
        //        MaxDemand = 500,
        //        NodeLimits = new List<(double, double)> {
        //        (0, 100), (10, 150), (5, 80), (20, 200), (0, 120)
        //    }
        //    };

        //    var generator = new DemandGenerator(config);
        //    var results = generator.GenerateDemandMatrix();

        //    // 输出验证
        //    foreach (var r in results)
        //    {
        //        Console.WriteLine($"Total: {r.TotalDemand:F2} | Nodes: {string.Join(", ", r.NodeDemands)}");
        //    }
        //}
        //#endregion
    }


    public class WaterDistributionSystemHelper
    {
        public class Config
        {
            public int NodeCount { get; set; }      // 节点总数
            public int TotalRuns { get; set; }      // 计算次数
            public double MinDemand { get; set; }   // 最小总需水量(m³/h)
            public double MaxDemand { get; set; }   // 最大总需水量(m³/h)
            public List<(double min, double max)> NodeLimits { get; set; } = new(); // 节点水量限制
        }

        public class AllocationResult
        {
            public double TotalDemand { get; set; }
            public double[] NodeDemands { get; }
            public DateTime Timestamp { get; }

            public AllocationResult(int nodeCount)
            {
                NodeDemands = new double[nodeCount];
                Timestamp = DateTime.Now;
            }
        }

        public class DemandAllocator
        {
            private readonly Config _config;
            private readonly Random _rand = new();

            public DemandAllocator(Config config)
            {
                ValidateConfig(config);
                _config = config;
            }

            public List<AllocationResult> GenerateAllocationMatrix()
            {
                var results = new List<AllocationResult>(_config.TotalRuns);
                double step = (_config.MaxDemand - _config.MinDemand) / (_config.TotalRuns - 1);

                // 根据GB50015规范考虑未预见水量[6](@ref)
                for (int i = 0; i < _config.TotalRuns; i++)
                {
                    double currentDemand = _config.MinDemand + step * i;
                    results.Add(GenerateAllocation(currentDemand));
                }
                return results;
            }

            private AllocationResult GenerateAllocation(double totalDemand)
            {
                var result = new AllocationResult(_config.NodeCount);
                double remaining = totalDemand;

                // 第一阶段：分配最低需水量（符合设计秒流量规范[7](@ref)）
                for (int i = 0; i < _config.NodeCount; i++)
                {
                    result.NodeDemands[i] = _config.NodeLimits[i].min;
                    remaining -= result.NodeDemands[i];
                }

                // 第二阶段：遗传算法式加权分配（参考专利[5](@ref)）
                double[] weights = GenerateGeneticWeights();
                double weightSum = Sum(weights);

                for (int i = 0; i < _config.NodeCount && remaining > 0; i++)
                {
                    double allocatable = Math.Min(
                        remaining * (weights[i] / weightSum),
                        _config.NodeLimits[i].max - result.NodeDemands[i]
                    );

                    result.NodeDemands[i] += allocatable;
                    remaining -= allocatable;
                }

                // 第三阶段：误差修正（确保总和精确）
                if (remaining > 0)
                {
                    int index = _rand.Next(_config.NodeCount);
                    result.NodeDemands[index] = Math.Min(
                        result.NodeDemands[index] + remaining,
                        _config.NodeLimits[index].max
                    );
                }

                result.TotalDemand = Sum(result.NodeDemands);
                return result;
            }

            // 遗传算法权重生成（20%基础权重+随机变异[3](@ref)）
            private double[] GenerateGeneticWeights()
            {
                double[] weights = new double[_config.NodeCount];
                for (int i = 0; i < weights.Length; i++)
                {
                    weights[i] = _rand.NextDouble() * 0.8 + 0.2;
                }
                return weights;
            }

            private static double Sum(double[] arr)
            {
                double sum = 0;
                foreach (var v in arr) sum += v;
                return sum;
            }

            private void ValidateConfig(Config config)
            {
                double totalMin = 0;
                foreach (var limit in config.NodeLimits)
                {
                    totalMin += limit.min;
                    if (limit.min < 0 || limit.max < limit.min)
                        throw new ArgumentException("节点限制值无效");
                }
                if (totalMin > config.MaxDemand)
                    throw new ArgumentException("总最小需求超过最大设定值");
            }
        }

    }
}