using dict_py_Inner;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing.Design;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CloudWaterNetwork
{
    [Serializable]
    public class Repeater : Link
    {

        [Category("1、基本信息")]
        [DisplayName("对象前缀名称")]
        [Browsable(true)]
        /// <summary>
        /// 模板ID
        /// </summary>
        public string NetworkPreName { get; set; }

        [Category("1、基本信息")]
        [DisplayName("显示名称")]
        [Browsable(true)]
        /// <summary>
        /// 模板ID
        /// </summary>
        public string NetworkShowName { get; set; }




        [Category("1、基本信息")]
        [DisplayName("前缀最小序号")]
        [Browsable(true)]
        /// <summary>
        /// 模板ID
        /// </summary>
        public int NetworkPreStartNum { get; set; } = 1;


        [Category("1、基本信息")]
        [DisplayName("前缀正序")]
        [Browsable(true)]
        /// <summary>
        /// 模板ID
        /// </summary>
        public bool NetworkIsAscNum { get; set; } = true;



        [Category("2、参数")]
        [DisplayName("模板ID")]
        [Browsable(true)]
        [Editor(typeof(TemplatePropertyEditor), typeof(UITypeEditor))]

        /// <summary>
        /// 模板ID
        /// </summary>
        public string TemplateID { get; set; }


        [Category("2、参数")]
        [DisplayName("模板名称")]
        [Browsable(true)]
        public string TempName => Global.Templates.GetTemplate(TemplateID)?.名称;

        public Template template = null;

        [NonSerialized]
        public Network netList = null;

     

        public Node StartNode_inner;

        public Node EndNode_inner;


        public bool isLoadded = false;



        [Category("2、参数")]
        [DisplayName("重复次数")]
        [Browsable(true)]
        /// <summary>
        /// 重复次数
        /// </summary>
        public int RepeatTimes { get; set; }




        [Category("2、参数")]
        [DisplayName("海森威廉系数")]
        [Browsable(false)]
        public float Roughness { get; set; }
        [Category("2、参数")]
        [DisplayName("局部阻力系数")]
        [Browsable(false)]
        public float MinorLoss { get; set; }
        [Category("1、基本信息")]
        [DisplayName("长度")]
        [Browsable(false)]
        public float Length { get; set; }

        [Category("1、基本信息")]
        [DisplayName("口径")]
        [Browsable(false)]
        public float Diameter { get; set; }


        [Category("2、参数")]
        [DisplayName("显示状态")]
        [Browsable(true)]
        public RepeatStatus Status { get; set; }


        public bool Load(int MaxLevel, dict param, Dictionary<TemplateType, bool> viewModel,bool viewMode =true)
        {

            if (template == null)
            {
                template = Global.Templates.GetTemplate(TemplateID);
                if (template == null)
                {
                    return false;
                }
                template.loadInpFile();
                template.network.MapObjects.ForEach(o => 
                { 
                    if (o.Level > MaxLevel)
                        o.Visible = false; 
                    else 
                        o.Visible = true; 
                });
                Network net = template.network;
                net.StartPoint = net.GetNode(template.Node1)[0];
                net.EndPoint = net.GetNode(template.Node2)[0];

            }


            if (!viewMode)
            {
                Status = RepeatStatus.收起;
            }
            else if (viewModel != null)
            {
                if(viewModel[template.Type])
                    Status = RepeatStatus.显示;
                else
                    Status = RepeatStatus.收起;
            }
            else
            {
                Status = RepeatStatus.显示;
            }
            
                
            if (param.Contains("层数") && param["层数"]>0 && template.Type==TemplateType.楼层模板)
            {
                RepeatTimes =(int) param["层数"];
            }
            
            if (Status==RepeatStatus.收起)
            {
                return false;
            }
            PointF3D basepoint = StartNode.ToPointF3D();
            netList = new Network();
            for (int i = 0; i < RepeatTimes; i++)
            {
                Network net = template.network.CreateNew(basepoint);
                int index = GetIndex(i);

                net.Name = NetworkPreName + (index==0?"":index.ToString("00"));
                net.StartPoint = net.GetNode(template.Node1)[0];
                net.EndPoint = net.GetNode(template.Node2)[0];
                if (template.Type==TemplateType.楼层模板)
                    ChangeNetbyParam(net, param);
                if (i == 0) StartNode_inner = net.StartPoint;
                EndNode_inner = net.EndPoint;
                net.LoadRepeaters(MaxLevel, param, viewModel);
                net.Rename();
                netList.Add(net);
                basepoint = netList.EndPoint.ToPointF3D();
            }
            return true;
        }
        void ChangeNetbyParam(Network net,dict param)
        {
            if (param.Contains("层高") && param["层高"] > 0 && net.StartPoint!=null && net.EndPoint!=null)
            {
                var currentHeight = Math.Abs(net.StartPoint.Elev - net.EndPoint.Elev);
                var k = (float)param["层高"] / currentHeight;
                net.Nodes.ForEach(n=>n.Elev=(n.Elev-net.StartPoint.Elev) * k + net.StartPoint.Elev);
            }

            if (param.Contains("入户管长") && param["入户管长"] > 0 &&  net.StartPoint != null && net.EndPoint != null)
            {
                Dictionary<Node, float> Distance = new Dictionary<Node, float>();
                CalcDistance(net, net.StartPoint, Distance);
                float sumDistance = 0;
                net.meters.ForEach(m => sumDistance += Distance[m]);
                float avgDistance = sumDistance / net.meters.Count;
                var k= (float)param["入户管长"] / avgDistance;
                net.Nodes.ForEach(n =>
                {
                    n.X = (n.X - net.StartPoint.X) * k + net.StartPoint.X;
                    n.Y = (n.Y - net.StartPoint.Y) * k + net.StartPoint.Y;
                });
            }
            if (param.Contains("户数") && template.Type == TemplateType.楼层模板)
            {
                var MaxLevel =(int) param["户数"];
                net.MapObjects.ForEach(o =>
                {
                    if (o.Level > MaxLevel)
                        o.Visible = false;
                    else
                        o.Visible = true;
                });
            }


        }



        public static void CalcDistance(Network net, Node startNode, Dictionary<Node, float> Distance)
        {
            // 定义 visited 字典记录已访问过的节点和待访问的节点队列
            
            Queue<Node> queue = new Queue<Node>();

            // 标记起始节点为已访问，并加入队列
            Distance[startNode] = 0;
            queue.Enqueue(startNode);

            // 不断从队列中取出节点进行访问，直到队列为空
            while (queue.Count > 0)
            {
                // 取出队首节点并输出
                Node node = queue.Dequeue();
                //Console.WriteLine(node.Name);

                // 遍历当前节点的所有未访问邻居节点，并标记为已访问
                foreach (Link link in net.Links)
                {
                    if (link.StartNode == node )
                    {
                        var node1 = link.EndNode;
                        var dis = Distance[node] + (float)Math.Sqrt(Math.Pow(node.X - node1.X, 2) + Math.Pow(node.Y - node1.Y, 2));
                        if (!Distance.ContainsKey(node1) || Distance[node1] > dis)
                        Distance[link.EndNode] = dis;
                        queue.Enqueue(link.EndNode);
                    }
                    else if (link.EndNode == node && !Distance.ContainsKey(link.StartNode))
                    {
                        var node1 = link.StartNode;
                        var dis = Distance[node] + (float)Math.Sqrt(Math.Pow(node.X - node1.X, 2) + Math.Pow(node.Y - node1.Y, 2));
                        if (!Distance.ContainsKey(node1) || Distance[node1] > dis)
                            Distance[link.StartNode] = dis;
                        queue.Enqueue(link.StartNode);
                    }
                }
            }
        }

        public int GetIndex(int i)
        {
            int index = 0;
            if (NetworkIsAscNum)
            {
                index = NetworkPreStartNum + i;
            }
            else
            {
                index = RepeatTimes - 1 - i + NetworkPreStartNum;
            }

            return index;
        }



        // 重写ToString()方法以便将阀门属性转换为字符串
        public override string ToString()
        {
            return $"{ID}\t{Node1}\t{Node2}\t{TemplateID}\t{RepeatTimes}\t{Status}\t{NetworkPreName}\t{NetworkPreStartNum}\t{NetworkIsAscNum}\t{NetworkShowName}\t";
        }
        public enum RepeatStatus
        {
            收起,
            显示
        }
    }

}