using System;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Event;

namespace Chernobyl.Collections.Generic.Hierarchy
{
    /// <summary>
    /// Extension and other general methods that are used to help with the
    /// creation of types that form parent/child hierarchies.
    /// </summary>
    public static class TreeExtensions
    {
        /// <summary>
        /// A type that can be assigned to an event. Specifically it is designed
        /// to be assigned to an event that is invoked when instances are added
        /// to a child collection (such as the event
        /// <see cref="IEventEnumerable{T}.ItemsAdded"/>. When the event handler
        /// method <see cref="OnChildrenAdded"/> is invoked, all of the added 
        /// items have their parent set to the parent specified in this type's
        /// constructor.
        /// </summary>
        /// <typeparam name="TParent">The type of the parent.</typeparam>
        /// <typeparam name="TChild">The type of the child.</typeparam>
        public class Parenter<TParent, TChild>
        {
            /// <summary>
            /// Initializes a new instance of the 
            /// <see cref="Parenter{TParent, TChild}"/> class.
            /// </summary>
            /// <param name="parent">The parent that is to be set on each of the
            /// <typeparamref name="TChild"/> instances that this type is
            /// notified of.</param>
            /// <param name="setParent">A method that is able to set the parent 
            /// of a <typeparamref name="TChild"/> type. The first argument passed
            /// to the method is the parent, the second argument is the parent to 
            /// be set.</param>
            public Parenter(TParent parent, Action<TParent, TChild> setParent)
            {
                _parent = parent;
                _setParent = setParent;
            }

            /// <summary>
            /// Performs an implicit conversion from 
            /// <see cref="TreeExtensions.Parenter{TParent, TChild}"/> 
            /// to <see cref="EventHandler{T}"/>. This operator allows this
            /// type to be implicitly assigned to an event.
            /// </summary>
            /// <param name="parenter">The 
            /// <see cref="TreeExtensions.Parenter{TParent, TChild}"/> to convert.</param>
            /// <returns>The result of the conversion.</returns>
            public static implicit operator EventHandler<ItemsEventArgs<TChild>>(Parenter<TParent, TChild> parenter)
            {
                return parenter.OnChildrenAdded;
            }

            /// <summary>
            /// An event handler that is should be invoked when the
            /// <typeparamref name="TParent"/> type specified in the constructor
            /// of this instance gains a new <typeparamref name="TChild"/>. 
            /// This method sets the parent of the instances specified in
            /// <paramref name="e"/>.
            /// </summary>
            /// <param name="sender">The instance that generated the event.</param>
            /// <param name="e">The <see cref="ItemsEventArgs{ITerritory}"/>
            /// instance containing the event data.</param>
            public void OnChildrenAdded(object sender, ItemsEventArgs<TChild> e)
            {
                foreach (TChild child in e.Items)
                    _setParent(_parent, child);
            }

            /// <summary>
            /// The parent that is to be set on each of the
            /// <typeparamref name="TChild"/> instances that this type is
            /// notified of.
            /// </summary>
            TParent _parent;

            /// <summary>
            /// A method that is able to set the parent of a 
            /// <typeparamref name="TChild"/> type. The first argument passed
            /// to the method is the parent, and the second argument is the child
            /// to be set on that parent.
            /// </summary>
            Action<TParent, TChild> _setParent;
        }

        /// <summary>
        /// A type that can be assigned to an event. Specifically it is designed
        /// to be assigned to an event that is invoked when instances are removed
        /// from child collection (such as the event
        /// <see cref="IEventEnumerable{T}.ItemsRemoved"/>. When the event handler
        /// method <see cref="OnChildrenRemoved"/> is invoked, all of the added 
        /// items have their parent set to null but only if their parent is the
        /// parent specified in this type's constructor.
        /// </summary>
        /// <typeparam name="TParent">The type of the parent. This type must be
        /// a reference type</typeparam>
        /// <typeparam name="TChild">The type of the child.</typeparam>
        public class Unparenter<TParent, TChild> where TParent : class
        {
            /// <summary>
            /// Initializes a new instance of the
            /// <see cref="Unparenter{TParent, TChild}"/> class.
            /// </summary>
            /// <param name="parent">The parent of the <typeparamref name="TChild"/>
            /// instances that this type is notified of.</param>
            /// <param name="setParent">A method that is able to set the parent 
            /// of a <typeparamref name="TChild"/> type. The first argument passed
            /// to the method is the parent, the second argument is the parent to 
            /// be set.</param>
            /// <param name="getParent">A method that is able to get the parent 
            /// of a <typeparamref name="TChild"/> type. The argument passed to 
            /// the method is the child whose parent is to be returned.</param>
            public Unparenter(TParent parent, Action<TParent, TChild> setParent,
                              Func<TChild, TParent> getParent)
            {
                _parent = parent;
                _setParent = setParent;
                _getParent = getParent;
            }

            /// <summary>
            /// Performs an implicit conversion from 
            /// <see cref="TreeExtensions.Parenter{TParent, TChild}"/> 
            /// to <see cref="EventHandler{T}"/>. This operator allows this
            /// type to be implicitly assigned to an event.
            /// </summary>
            /// <param name="parenter">The 
            /// <see cref="TreeExtensions.Unparenter{TParent, TChild}"/> to convert.</param>
            /// <returns>The result of the conversion.</returns>
            public static implicit operator EventHandler<ItemsEventArgs<TChild>>(Unparenter<TParent, TChild> parenter)
            {
                return parenter.OnChildrenRemoved;
            }

            /// <summary>
            /// An event handler that is invoked when <typeparamref name="TParent"/>
            /// specified in the constructor of this instance loses a 
            /// <typeparamref name="TChild"/>. This method sets 
            /// the parent of the removed children (the instances specified in
            /// <paramref name="e"/>) to null if their parent is still set to
            /// the <typeparamref name="TParent"/> instance provided in this
            /// instances contructor.
            /// </summary>
            /// <param name="sender">The instance that generated the event.</param>
            /// <param name="e">The <see cref="ItemsEventArgs{ITerritory}"/> 
            /// instance containing the event data.</param>
            public void OnChildrenRemoved(object sender, ItemsEventArgs<TChild> e)
            {
                foreach (TChild child in e.Items.Where(territory => _getParent(territory) == _parent))
                    _setParent(null, child);
            }

            /// <summary>
            /// The parent of the <typeparamref name="TChild"/> instances that 
            /// this type is notified of.
            /// </summary>
            TParent _parent;

            /// <summary>
            /// A method that is able to set the parent of a 
            /// <typeparamref name="TChild"/> type. The first argument passed
            /// to the method is the parent, and the second argument is the child
            /// to be set on that parent.
            /// </summary>
            Action<TParent, TChild> _setParent;

            /// <summary>
            /// A method that is able to get the parent of a 
            /// <typeparamref name="TChild"/> type. The argument passed to the
            /// method is the child whose parent is to be returned.
            /// </summary>
            Func<TChild, TParent> _getParent;
        }

        /// <summary>
        /// A method that handles parenting for an <typeparamref name="TChild"/>.
        /// This method removes the <paramref name="child"/> from the
        /// <paramref name="currentParent"/> and adds the child to the
        /// <paramref name="newParent"/>. Before it does this, however, it
        /// performs checks to make sure the parenting is valid (i.e. that
        /// the parent is actually being changed and neither are null). This
        /// method is used primarily by types attempting to implement child/parent
        /// hierarchies.
        /// </summary>
        /// <typeparam name="TParent">The type of the parent. This type must be
        /// a reference type.</typeparam>
        /// <typeparam name="TChild">The type of the child.</typeparam>
        /// <param name="child">The instance that is to be removed from
        /// <paramref name="currentParent"/> child collection and added to the 
        /// child collection of <paramref name="newParent"/>.</param>
        /// <param name="currentParent">The instance that is currently the
        /// parent of <paramref name="child"/>. When this method returns, this
        /// argument will be equal to the <typeparamref name="TParent"/> that
        /// is now the parent of <paramref name="child"/>.</param>
        /// <param name="newParent">The instance that shall become the parent
        /// of <paramref name="child"/>.</param>
        /// <param name="getChildren">The method that can retrieve the children
        /// <see cref="ICollection{T}"/> of the <typeparamref name="TParent"/> type.
        /// The first argument passed to the method is the parent whose children
        /// are to be returned.</param>
        public static void GetParent<TParent, TChild>(TChild child, ref TParent currentParent, 
                                                      TParent newParent, Func<TParent, ICollection<TChild>> getChildren)
                                                      where TParent : class
        {
            if (currentParent != newParent)
            {
                TParent oldParent = currentParent;
                currentParent = newParent;

                if (oldParent != null)
                    getChildren(oldParent).Remove(child);

                if (currentParent != null && getChildren(currentParent).Contains(child) == false)
                    getChildren(currentParent).Add(child);
            }
        }

        /// <summary>
        /// This method handles the un-parenting of instances in
        /// <paramref name="currentChildren"/> from the <paramref name="parent"/>
        /// and the parenting of the children in <paramref name="newChildren"/>
        /// to the <paramref name="parent"/>. Before it does this, however, it
        /// performs checks to make sure that the parent is actually being
        /// changed. This method is used primarily by types attempting to 
        /// implement child/parent hierarchies.
        /// </summary>
        /// <typeparam name="TParent">The type of the parent. This type must be
        /// a reference type.</typeparam>
        /// <typeparam name="TChild">The type of the child.</typeparam>
        /// <param name="parent">The parent of the instances in
        /// <paramref name="currentChildren"/>.</param>
        /// <param name="currentChildren">The instances that are currently the
        /// children of <paramref name="parent"/>. When this method returns, this
        /// argument will be equal to the current children of 
        /// <paramref name="parent"/>.</param>
        /// <param name="newChildren">The instances that are to become the children
        /// of <paramref name="parent"/>.</param>
        /// <param name="getParent">A method that can retrieve the parent of a
        /// <typeparamref name="TChild"/>. The argument passed to the method is the
        /// child.</param>
        /// <param name="setParent">A method that can set the parent of a
        /// <typeparamref name="TChild"/>. The first argument passed to the method
        /// is the child, the second argument is the parent to be set.</param>
        public static void GetChildren<TParent, TChild>(TParent parent, ref ICollection<TChild> currentChildren,
                                                        ICollection<TChild> newChildren, Func<TChild, TParent> getParent,
                                                        Action<TChild, TParent> setParent)
                                                        where TParent : class
        {
            if (currentChildren != newChildren)
            {
                ICollection<TChild> oldChildren = currentChildren;
                currentChildren = newChildren;

                if (oldChildren != null)
                {
                    // This instance is no longer the parent of these children.
                    // Inform these new children of this.
                    foreach (TChild child in oldChildren.Where(child => getParent(child) == parent))
                        setParent(child, null);
                }

                if (currentChildren != null)
                {
                    // This instance is now the parent of these children.
                    // Inform these new children of this.
                    foreach (TChild child in currentChildren)
                        setParent(child, parent);
                }
            }
        }
    }
}