using System;
using System.Collections.Generic;
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
    /// types.
    /// </summary>
    /// <typeparam name="TParent">The type that is the value held by this 
    /// <see cref="IValue{T}"/>.</typeparam>
    /// <typeparam name="TChild">The type whose parent is held by this 
    /// <see cref="IValue{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 child from <see cref="Parent{TParent, TChild}"/>).</typeparam>
    public class Parent<TParent, TChild> : DynamicContainer<TParent>
        where TChild : class
        where TParent : class
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="DynamicContainer{T}"/> class.
        /// </summary>
        /// <param name="child">The instance whose parent is being held by 
        /// <c>this</c>.</param>
        /// <param name="getChildren">The method used to get the child 
        /// <see cref="ICollection{T}"/> from a <typeparamref name="TParent"/> 
        /// type. This method will be used to add/remove the <paramref name="child"/>
        /// to/from the parent children <see cref="ICollection{T}"/>.</param>
        /// <exception cref="ArgumentNullException">Thrown if 
        /// <paramref name="child"/> or <paramref name="getChildren"/> is null.</exception>
        public Parent(TChild child, Func<TParent, ICollection<TChild>> getChildren)
        {
            // Note: the value of this IValue<T> is not provided in the constructor.
            // This is because getChildren could return a "Children" type. The
            // "Children" type will its own "getParent" method. If that method
            // was invoked during the constructor of this object a crash would
            // result because "getParent" would return null (since this parent
            // hasn't been constructed).

            child.ThrowIfNull("child");
            getChildren.ThrowIfNull("getChildren");

            _child = child;
            _getChildren = getChildren;

            Provide += OnProvide;
        }

        /// <summary>
        /// An event handler that is invoked when the parent has been changed.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The event arguments containg the old and new parent.</param>
        void OnProvide(object sender, ValueChangedEventArgs<TParent> e)
        {
            if (e.OldValue != null)
                _getChildren(e.OldValue).Remove(_child);

            if (e.NewValue != null)
            {
                ICollection<TChild> children = _getChildren(e.NewValue);
                if(children.Contains(_child) == false)
                    children.Add(_child);
            }
        }

        /// <summary>
        /// The instance whose parent is being held by <c>this</c>.
        /// </summary>
        readonly TChild _child;

        /// <summary>
        /// The method used to get the child <see cref="ICollection{T}"/> from
        /// a <typeparamref name="TParent"/> type.
        /// </summary>
        readonly Func<TParent, ICollection<TChild>> _getChildren;
    }

    /// <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="Parent{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 HierarchalParent<T>
        : Parent<T, T> where T : class, IHierarchal<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="HierarchalParent{T}"/> 
        /// class.
        /// </summary>
        /// <param name="child">The instance whose parent is being held by 
        /// <c>this</c>.</param>
        public HierarchalParent(T child)
            : base(child, parent => parent.Children)
        {}
    }
}