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

namespace Chernobyl.Collections.Generic.Hierarchy
{
    /// <summary>
    /// A type that is used to maintain a parent-child relationship between two
    /// objects.
    /// </summary>
    /// <typeparam name="TParent">The type whose children is held by this 
    /// <see cref="ICollection{T}"/>. This type must be a reference type because a
    /// value type would not work properly with this class (since you can't access
    /// the parent from <see cref="Children{TParent, TChild}"/>).</typeparam>
    /// <typeparam name="TChild">The type that is the value held by this 
    /// <see cref="ICollection{T}"/>.</typeparam>
    public class Children<TParent, TChild> : Collection<TChild>
        where TParent : class
    {
        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="Children{TParent, TChildren}" /> class.
        /// </summary>
        /// <param name="parent">The instance whose children is being held by
        /// <c>this</c>.</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>
        /// <exception cref="ArgumentNullException">Thrown if any of the parameters
        /// provided are null.</exception>
        public Children(TParent parent, Func<TChild, IDynamicContainer<TParent>> getParent)
            : this(parent, getParent, new DecoratingEventList<TChild>())
        {}

        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="Children{TParent, TChildren}"/> class.
        /// </summary>
        /// <param name="parent">The instance whose children is being held by 
        /// <c>this</c>.</param>
        /// <param name="implementation">The implementation of this 
        /// <see cref="ICollection{T}"/>.</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>
        /// <exception cref="ArgumentNullException">Thrown if any of the parameters
        /// provided are null.</exception>
        /// <exception cref="ArgumentException">Thrown if items are contained
        /// within <paramref name="implementation"/>.</exception>
        public Children(TParent parent, Func<TChild, IDynamicContainer<TParent>> getParent, IEventCollection<TChild> implementation)
        {
            parent.ThrowIfNull("parent");
            getParent.ThrowIfNull("getParent");
            implementation.ThrowIfNull("implementation");

            if(implementation.Any())
                throw new ArgumentException("The implementation provided cannot " +
                    "contain items.", "implementation");

            _parent = parent;
            _getParent = getParent;
            _implementation = implementation;

            _implementation.ItemsAdded += OnChildrenAdded;
            _implementation.ItemsRemoved += OnChildrenRemoved;
        }

        /// <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{TChild}"/>
        /// instance containing the event data.</param>
        void OnChildrenAdded(object sender, ItemsEventArgs<TChild> e)
        {
            foreach (TChild child in e.Items)
                _getParent(child).Value = _parent;
        }

        /// <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{TChild}"/> 
        /// instance containing the event data.</param>
        void OnChildrenRemoved(object sender, ItemsEventArgs<TChild> e)
        {
            foreach (TChild child in e.Items)
            {
                IDynamicContainer<TParent> parent = _getParent(child);
                if (parent.Value == _parent)
                    parent.Value = null;
            }
        }

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

        /// <summary>
        /// The instance whose children is being held by <c>this</c>.
        /// </summary>
        readonly TParent _parent;

        /// <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>
        readonly Func<TChild, IDynamicContainer<TParent>> _getParent;

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

    /// <summary>
    /// A type that is used to maintain a parent-child relationship between two
    /// <see cref="IHierarchal{T}"/> types. This type performs the same job as
    /// <see cref="Children{TParent, TChild}"/> but is easier to create for 
    /// <see cref="IHierarchal{T}"/> types.
    /// </summary>
    /// <typeparam name="T">The <see cref="IHierarchal{T}"/> reference type that
    /// makes up the types contained in the hierarchy.</typeparam>
    public class HierarchalChildren<T> : Children<T, T> where T : class, IHierarchal<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="HierarchalChildren{T}"/> class.
        /// </summary>
        /// <param name="parent">The instance whose children is being held by
        /// <c>this</c>.</param>
        public HierarchalChildren(T parent)
            : base(parent, child => child.Parent)
        {}
    }
}