// ***********************************************************************
// Assembly         : Construction
// Author           : zjx
// Created          : 09-15-2020
//
// Last Modified By : zjx
// Last Modified On : 09-15-2020
// ***********************************************************************
// <copyright file="HierarchyHelp.cs" company="jindongfang">
// Copyright (c) jindongfang. All rights reserved.
// </copyright>
// <summary></summary>
// ***********************************************************************
using System;
using System.Collections.Generic;
using System.Linq;

namespace WellWorkDataUI
{
    /// <summary>
    /// Class HierarchyHelp.
    /// </summary>
    public static class HierarchyHelp
    {
        /// <summary>
        /// Loops the descendants.
        /// </summary>
        /// <typeparam name="T">T</typeparam>
        /// <param name="data">The data.</param>
        /// <param name="element">The element.</param>
        /// <param name="pred">The pred.</param>
        /// <param name="action">The action.</param>
        public static void LoopDescendants<T>(IEnumerable<T> data, T element, Func<T, T, bool> pred, Action<T, T> action)
        {
            foreach (T item in data)
            {
                if (pred(element, item))
                {
                    action(element, item);

                    LoopDescendants(data, item, pred, action);
                }
            }
        }

        /// <summary>
        /// Enums the descendants.
        /// </summary>
        /// <typeparam name="T">T</typeparam>
        /// <param name="data">The data.</param>
        /// <param name="element">The element.</param>
        /// <param name="pred">The pred.</param>
        /// <returns>IEnumerable&lt;T&gt;.</returns>
        public static IEnumerable<T> EnumDescendants<T>(IEnumerable<T> data, T element, Func<T, T, bool> pred)
        {
            foreach (T item in data)
            {
                if (pred(element, item))
                {
                    yield return item;

                    foreach (T item2 in EnumDescendants(data, item, pred))
                    {
                        yield return item2;
                    }
                }
            }
        }

        /// <summary>
        /// Enums the descendants.
        /// </summary>
        /// <typeparam name="T">T</typeparam>
        /// <param name="data">The data.</param>
        /// <param name="element">The element.</param>
        /// <param name="pred">The pred.</param>
        /// <returns>IEnumerable&lt;T&gt;.</returns>
        public static IEnumerable<T> EnumDescendantsWithElements<T>(IEnumerable<T> data, T element, Func<T, T, bool> pred)
        {
            yield return element;
            foreach (T item in data)
            {
                if (pred(element, item))
                {
                    yield return item;
                    foreach (T item2 in EnumDescendants(data, item, pred))
                    {
                        yield return item2;
                    }
                }
            }
        }

        /// <summary>
        /// Enums the descendants.
        /// </summary>
        /// <typeparam name="T">T</typeparam>
        /// <param name="data">The data.</param>
        /// <param name="elements">The elements.</param>
        /// <param name="pred">The pred.</param>
        /// <returns>IEnumerable&lt;T&gt;.</returns>
        public static IEnumerable<T> EnumDescendants<T>(IEnumerable<T> data, IEnumerable<T> elements, Func<T, T, bool> pred)
        {
            foreach (T element in elements)
            {
                foreach (T item in EnumDescendants(data, element, pred))
                {
                    yield return item;
                }
            }
        }

        /// <summary>
        /// Enums the descendants.
        /// </summary>
        /// <typeparam name="T">T</typeparam>
        /// <param name="data">The data.</param>
        /// <param name="elements">The elements.</param>
        /// <param name="pred">The pred.</param>
        /// <returns>IEnumerable&lt;T&gt;.</returns>
        public static IEnumerable<T> EnumDescendantsWithElements<T>(IEnumerable<T> data, IEnumerable<T> elements, Func<T, T, bool> pred)
        {
            foreach (T element in elements)
            {
                yield return element;

                foreach (T item in EnumDescendants(data, element, pred))
                {
                    yield return item;
                }
            }
        }

        /// <summary>
        /// Enums the ancestors.
        /// </summary>
        /// <typeparam name="T">T</typeparam>
        /// <param name="data">The data.</param>
        /// <param name="elements">The elements.</param>
        /// <param name="pred">The pred.</param>
        /// <returns>IEnumerable&lt;T&gt;.</returns>
        public static IEnumerable<T> EnumAncestorsWithElements<T>(IEnumerable<T> data, IEnumerable<T> elements, Func<T, T, bool> pred)
        {
            HashSet<T> set = new HashSet<T>();

            foreach (T item in elements)
            {
                T tmp = item;

                do
                {
                    set.Add(tmp);

                    tmp = data.FirstOrDefault(o => pred(o, tmp));
                }
                while (tmp != null);
            }

            return set;
        }
    }
}