using System;
using System.Collections.Generic;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Collections.Generic.Hierarchy;
using Chernobyl.Event;
using Chernobyl.Utility;

namespace Chernobyl.Collections.Generic.Graph
{
    /// <summary>
    /// A type used to maintain bi-directional connections between nodes in a
    /// graph.
    /// </summary>
    /// <typeparam name="TNode">The vertice reference types that
    /// make up the types contained in the network.</typeparam>
    public class Connections<TNode> : Collection<TNode>
        where TNode : class 
    {
        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="Connections{TNode}" /> class.
        /// </summary>
        /// <param name="connected">The instance whose connections are being 
        /// held by <c>this</c>.</param>
        /// <param name="getConnections">The method used to get the connection 
        /// <see cref="ICollection{T}"/> from a <typeparamref name="TNode"/> 
        /// type. This method will be used to add/remove the <paramref name="connected"/>
        /// to/from the connected <typeparamref name="TNode"/>.</param>
        /// <exception cref="ArgumentNullException">Thrown if any of the parameters
        /// provided are null.</exception>
        public Connections(TNode connected, Func<TNode, ICollection<TNode>> getConnections)
        {
            connected.ThrowIfNull("parent");
            getConnections.ThrowIfNull("getChildren");

            _connected = connected;
            _getConnections = getConnections;
            
            _implementation = new DecoratingEventList<TNode>();
            _implementation.ItemsAdded += OnItemsAdded;
            _implementation.ItemsRemoved += OnItemsRemoved;
        }

        /// <summary>
        /// The implementation of this <see cref="ICollection{T}" />.
        /// </summary>
        protected override ICollection<TNode> Implementation
        {
            get { return _implementation; }
        }

        /// <summary>
        /// Invoked when an item is added to this <see cref="ICollection{T}"/>.
        /// This method ensures that the new <typeparamref name="TNode"/>
        /// intances are also connected to the <see cref="_connected"/>.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="ItemsEventArgs{TNode}"/> instance 
        /// containing the event data.</param>
        void OnItemsAdded(object sender, ItemsEventArgs<TNode> e)
        {
            // If the parent node isn't already in this node, add it.
            foreach (TNode node in e.Items)
            {
                ICollection<TNode> nodeConnections = _getConnections(node);
                if (nodeConnections.Contains(_connected) == false)
                    nodeConnections.Add(_connected);
            }
        }

        /// <summary>
        /// Invoked when an item is remove from this <see cref="ICollection{T}"/>.
        /// This method ensures that the old <typeparamref name="TNode"/>
        /// intances are also disconnected from the <see cref="_connected"/>.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="ItemsEventArgs{TNode}"/> instance 
        /// containing the event data.</param>
        void OnItemsRemoved(object sender, ItemsEventArgs<TNode> e)
        {
            // Remove the parent connection from the 
            foreach (TNode node in e.Items)
                _getConnections(node).Remove(_connected);
        }

        /// <summary>
        /// The instance whose connections are being held by <c>this</c>.
        /// </summary>
        readonly TNode _connected;

        /// <summary>
        /// The method used to get the connection <see cref="ICollection{T}"/> 
        /// from a <typeparamref name="TNode"/> type. This method will be used 
        /// to add/remove the <see cref="_connected"/> to/from the connected 
        /// <typeparamref name="TNode"/>.
        /// </summary>
        readonly Func<TNode, ICollection<TNode>> _getConnections;

        /// <summary>
        /// The backing field to <see cref="Implementation"/>.
        /// </summary>
        readonly IEventCollection<TNode> _implementation;
    }

    /// <summary>
    /// A type used to maintain bi-directional connections between 
    /// <see cref="INode"/> instances in a graph. This type 
    /// performs the same job as <see cref="Connections{TNode}"/> but is easier 
    /// to create for <see cref="INode"/> types.
    /// </summary>
    public class NodeConnections : Connections<INode>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="HierarchalChildren{T}"/> class.
        /// </summary>
        /// <param name="connected">The instance whose connections are being 
        /// held by <c>this</c>.</param>
        public NodeConnections(INode connected)
            : base(connected, connection => connection.Connections)
        { }
    }
}