using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace BasicOperation.TreeNodeUtils
{
    public class TreeNodeHelper
    {
        public static List<TreeNode> ToList(TreeNodeCollection nodes)
        {
            List<TreeNode> list = new List<TreeNode>();
            foreach (TreeNode node in ToIEnumerable(nodes))
                list.Add(node);
            return list;
        }
        public static IEnumerable<TreeNode> ToIEnumerable(TreeNodeCollection nodes)
        {
            foreach (TreeNode c1 in nodes)
            {
                yield return c1;
                foreach (TreeNode c2 in ToIEnumerable(c1.Nodes))
                {
                    yield return c2;
                }
            }
        }

        /// <summary>
        /// 找到更改的TreeNode 包括增加，删除，修改
        /// </summary>
        /// <param name="originNodes"></param>
        /// <param name="currentNodes"></param>
        /// <returns></returns>
        public static List<KeyValuePair<TreeNode, string>> FindModify(List<TreeNode> originNodes,List<TreeNode> currentNodes)
        {
            var res = new List<KeyValuePair<TreeNode, string>>();

            return res;
        }

        /// <summary>
        /// 层次遍历树节点
        /// </summary>
        /// <param name="nodes"></param>
        public static void LevelTraversal(TreeNodeCollection nodes)
        {
            if (nodes == null)
            {
                return;
            }

            var queue = new Queue<TreeNode>();
            foreach (TreeNode node in nodes)
            {
                queue.Enqueue(node);
            }

            while (queue.Count > 0)
            {
                // 出队
                var one = queue.Dequeue();
                // 访问
                Debug.WriteLine(one.Level + "  " + one.Text.ToString());
                // 子节点入队
                foreach (TreeNode subNode in one.Nodes)
                {
                    queue.Enqueue(subNode);
                }
            }
        }

        public static void LevelTraversal(TreeNode node)
        {
            if (node == null)
            {
                return;
            }

            var queue = new Queue<TreeNode>();

            queue.Enqueue(node);


            while (queue.Count > 0)
            {
                // 出队
                var one = queue.Dequeue();
                // 访问
                Debug.WriteLine(one.Level + "  " + one.Text.ToString());
                // 子节点入队
                foreach (TreeNode subNode in one.Nodes)
                {
                    queue.Enqueue(subNode);
                }
            }
        }

        public static void LevelTraversalFunc(TreeNode node,Func<TreeNode,int> visitFunc)
        {
            if (node == null)
            {
                return;
            }

            var queue = new Queue<TreeNode>();

            queue.Enqueue(node);


            while (queue.Count > 0)
            {
                // 出队
                var one = queue.Dequeue();
                // 访问
                //Debug.WriteLine(one.Level + "  " + one.Text.ToString());
                visitFunc(one);
                // 子节点入队
                foreach (TreeNode subNode in one.Nodes)
                {
                    queue.Enqueue(subNode);
                }
            }
        }

        /// <summary>
        /// 深度非递归遍历树节点
        /// </summary>
        /// <param name="nodes"></param>
        public static List<TreeNode> DeepTraversal(TreeNodeCollection nodes)
        {
            var res = new List<TreeNode>();

            if (nodes == null)
            {
                return res;
            }

            var stack = new Stack<TreeNode>();

            // 倒序入栈
            for (int i = 0; i < nodes.Count; i++)
            {
                stack.Push(nodes[nodes.Count - i - 1]);
            }

            while (stack.Count > 0)
            {
                // 出栈
                var oneNode = stack.Pop();

                // 访问
                //Debug.WriteLine(oneNode.Level + " " + oneNode.Text.ToString());
                res.Add(oneNode);

                // 倒序入栈
                for (int j = 0; j < oneNode.Nodes.Count; j++)
                {
                    stack.Push(oneNode.Nodes[oneNode.Nodes.Count - j - 1]);
                }
            }

            return res;
        }

        public static void DeepTraversal(TreeNode node)
        {
            if (node == null)
            {
                return;
            }

            var stack = new Stack<TreeNode>();


            stack.Push(node);


            while (stack.Count > 0)
            {
                var oneNode = stack.Pop();

                Debug.WriteLine(oneNode.Level + " " + oneNode.Text.ToString());

                for (int j = 0; j < oneNode.Nodes.Count; j++)
                {
                    stack.Push(oneNode.Nodes[oneNode.Nodes.Count - j - 1]);
                }
            }
        }
    }
}