Zero/ZeroLevel/Services/Trees/ItemFieldToTreeConverter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using ZeroLevel.Services.Collections;

namespace ZeroLevel.Services.Trees
{
    /// <summary>
    /// Выполняет преобразование набора элементов в дерево (в набор ветвей)
    /// </summary>
    /// <typeparam name="T">Тип элемента</typeparam>
    /// <typeparam name="TKey">Тип связующих компонентов элемента</typeparam>
    public class ItemFieldToTreeConverter<T, TKey>
    {
        #region Inner classes
        private struct BranchTestResult
        {
            public bool HasInteraction;
            public NodeBranch NewBranch;
        }

        private struct Node
        {
            public T Value;
            public TKey In;
            public TKey Out;

            internal Node Clone()
            {
                return new Node
                {
                    In = this.In,
                    Out = this.Out,
                    Value = this.Value
                };
            }

            public bool Eq(Node other, Func<T, T, bool> comparer, Func<TKey, TKey, bool> key_comparer)
            {
                if (ReferenceEquals(this, other))
                    return true;
                return comparer(this.Value, other.Value) &&
                    key_comparer(this.In, other.In) &&
                    key_comparer(this.Out, other.Out);
            }

            public override int GetHashCode()
            {
                return this.Value?.GetHashCode() ?? 0 ^ this.In.GetHashCode() ^ this.Out.GetHashCode();
            }
        }

        private class NodeBranch
        {
            private List<Node> _nodes = new List<Node>();
            private readonly Func<TKey, TKey, bool> _key_comparer;
            private readonly Func<T, T, bool> _comparer;
            public IEnumerable<Node> Nodes
            {
                get
                {
                    return _nodes;
                }
            }

            public NodeBranch(Node first, Func<T, T, bool> comparer, Func<TKey, TKey, bool> key_comparer)
            {
                _nodes.Add(first);
                _key_comparer = key_comparer;
                _comparer = comparer;
            }

            public NodeBranch(IEnumerable<Node> nodes, Func<T, T, bool> comparer, Func<TKey, TKey, bool> key_comparer)
            {
                _nodes.AddRange(nodes);
                _key_comparer = key_comparer;
                _comparer = comparer;
            }

            public List<T> Extract()
            {
                return _nodes.Select(n => n.Value).ToList();
            }

            public BranchTestResult Test(Node node)
            {
                var result = new BranchTestResult { HasInteraction = false, NewBranch = null };
                if (_key_comparer(_nodes.Last().Out, node.In))
                {
                    _nodes.Add(node);
                    result.HasInteraction = true;
                }
                else if (_key_comparer(_nodes.First().In, node.Out))
                {
                    _nodes.Insert(0, node);
                    result.HasInteraction = true;
                }
                else
                {
                    for (int i = 0; i < _nodes.Count; i++)
                    {
                        var current = _nodes[i];
                        if (_key_comparer(current.Out, node.In))
                        {
                            var list = _nodes.Take(i + 1).ToList();
                            list.Add(node);
                            result.NewBranch = new NodeBranch(list, _comparer, _key_comparer);
                            result.HasInteraction = true;
                            break;
                        }
                        else if (_key_comparer(current.In, node.Out))
                        {
                            var list = _nodes.Skip(i).ToList();
                            list.Insert(0, node);
                            result.NewBranch = new NodeBranch(list, _comparer, _key_comparer);
                            result.HasInteraction = true;
                            break;
                        }
                    }
                }
                return result;
            }
            /// <summary>
            /// Проверка возможности объединения с другой ветвью, если текущая является ее началом или продолжением
            /// </summary>
            public bool TryJoin(NodeBranch other)
            {
                if (other == null)
                {
                    return false;
                }
                if (this._nodes.First().Eq(other._nodes.Last(), _comparer ,_key_comparer))
                {
                    this._nodes = other._nodes.Union(this._nodes).ToList();
                    return true;
                }
                else if (this._nodes.Last().Eq(other._nodes.First(), _comparer, _key_comparer))
                {
                    this._nodes = this._nodes.Union(other._nodes).ToList();
                    return true;
                }
                return false;
            }

            public override bool Equals(object obj)
            {
                return this.Equals(obj as NodeBranch);
            }

            public override int GetHashCode()
            {
                return this._nodes.GetEnumHashCode();
            }

            public bool Equals(NodeBranch other)
            {
                if (other == null)
                    return false;
                if (ReferenceEquals(this, other))
                    return true;

                return this._nodes.OrderingEquals(other._nodes);
            }
        }
        #endregion

        private readonly Func<T, TKey> _inKeyExtractor;
        private readonly Func<T, TKey> _outKeyExtractor;
        private readonly Func<T, T, bool> _comparer;
        private readonly Func<TKey, TKey, bool> _key_comparer;
        /// <summary>
        /// Конструктор
        /// </summary>
        /// <param name="inKeyExtractor">Экстрактор входной связи элемента</param>
        /// <param name="outKeyExtractor">Экстрактор исходящей связи элемента</param>
        public ItemFieldToTreeConverter(Func<T, TKey> inKeyExtractor,
            Func<T, TKey> outKeyExtractor,
            Func<T, T, bool> comparer = null,
            Func<TKey, TKey, bool> key_comparer = null)
        {
            if (inKeyExtractor == null)
            {
                throw new ArgumentNullException(nameof(inKeyExtractor));
            }
            if (outKeyExtractor == null)
            {
                throw new ArgumentNullException(nameof(outKeyExtractor));
            }
            _inKeyExtractor = inKeyExtractor;
            _outKeyExtractor = outKeyExtractor;
            _comparer = comparer;
            _key_comparer = key_comparer ?? new Func<TKey, TKey, bool>((k1, k2) =>
            {
                if (k1 == null && k2 == null) return true;
                if (k1 == null) return false;
                if (k2 == null) return false;
                return k1.Equals(k2);
            });
        }
        /// <summary>
        /// Преобразование набора элементов к набору ветвей
        /// </summary>
        public IEnumerable<List<T>> Convert(IEnumerable<T> entries)
        {
            if (entries == null || entries.Any() == false)
            {
                return Enumerable.Empty<List<T>>();
            }
            var iterator = new SparseIterator<T>(entries);
            var result = new List<NodeBranch>();
            if (iterator.MoveNext() != -1)
            {
                result.Add(new NodeBranch(new Node
                {
                    Value = iterator.Current,
                    In = _inKeyExtractor(iterator.Current),
                    Out = _outKeyExtractor(iterator.Current)
                }, _comparer, _key_comparer));
                iterator.Exclude();
            }
            else
            {
                return Enumerable.Empty<List<T>>();
            }
            int index;
            var cachee = new Dictionary<int, Node>();
            while ((index = iterator.MoveNext()) != -1)
            {
                if (cachee.ContainsKey(index) == false)
                {
                    cachee.Add(index, new Node
                    {
                        Value = iterator.Current,
                        In = _inKeyExtractor(iterator.Current),
                        Out = _outKeyExtractor(iterator.Current)
                    });
                }
                var node = cachee[index];
                bool included = false;
                var include = new List<NodeBranch>();
                foreach (var branch in result)
                {
                    var tr = branch.Test(node);
                    if (tr.HasInteraction)
                    {
                        included = true;
                        if (tr.NewBranch != null)
                        {
                            include.Add(tr.NewBranch);
                        }
                    }
                }
                if (included == false)
                {
                    result.Add(new NodeBranch(node, _comparer, _key_comparer));
                }
                iterator.Exclude();
                if (include.Count > 0) result.AddRange(include);
            }
            // Проверить, если одна ветка является началом, или продолжением другой, выполнить склейки
            for (int i = 0; i < result.Count - 1; i++)
            {
                var left = result[i];
                for (int j = i + 1; j < result.Count; j++)
                {
                    var right = result[j];
                    if (IsNodeBrunchEquals(left, right) || left.TryJoin(right))
                    {
                        result.RemoveAt(j); j--;
                    }
                }
            }
            return result.Select(e => e.Extract());
        }

        private bool IsNodeBrunchEquals(NodeBranch first, NodeBranch second)
        {
            if (first == null && second == null)
                return true;
            if (first == null)
                return false;
            if (second == null)
                return false;
            if (_comparer == null)
                return first.Equals(second);
            if (ReferenceEquals(first, second))
                return true;

            var f_arr = first.Nodes.ToArray();
            var s_arr = second.Nodes.ToArray();
            if (f_arr.Length != s_arr.Length)
                return false;
            for (int i = 0; i < f_arr.Length; i++)
            {
                var fi = f_arr[i];
                var si = s_arr[i];
                if (_key_comparer(fi.In, si.In) == false) return false;
                if (_key_comparer(fi.Out, si.Out) == false) return false;
                if (_comparer(fi.Value, si.Value) == false) return false;
            }
            return true;
        }
    }
}