using System;
using System.Collections.Generic;
using System.Linq;

namespace Chernobyl.Update
{
    /// <summary>
    /// A default implementation of IUpdateable. Can also
    /// be used as a helper class for implementing new 
    /// IUpdateables. Do NOT handle the type Updateable 
    /// because not all updateables derive from Updateable. 
    /// Instead, handle the type IUpdateable.
    /// </summary>
    public class Updateable : IUpdateable
    {
        /// <summary>
        /// Constructor that creates a Updateable and creates a 
        /// <see cref="List{T}"/> to hold the children.
        /// </summary>
        public Updateable()
            : this(new List<IUpdateable>())
        { }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="childCollection">The list that should be used to
        /// hold children, like <see cref="List{IUpdateable}"/>.</param>
        public Updateable(ICollection<IUpdateable> childCollection)
        {
            UpdateableChildren = childCollection;
        }

        /// <summary>
        /// By default, this method just loops through it's children
        /// and calls <see cref="Update"/> on them, passing in
        /// the delta time it receives.
        /// </summary>
        /// <param name="deltaTime">The amount of time that has
        /// passed since this update was last called.</param>
        public virtual void Update(TimeSpan deltaTime)
        {
            // We place the children in an array so that, if new children are
            // added to the UpdateableChildren during this update, we won't get
            // and invalidated enumerator.
            foreach (IUpdateable child in UpdateableChildren.ToArray())
                child.Update(deltaTime);
        }

        /// <summary>
        /// A helper method that makes one IUpdateable the parent of another. 
        /// </summary>
        /// <param name="parent">The IUpdateable to make the parent of the child.</param>
        /// <param name="child">The IUpdateable to make the child of the parent. 
        /// If this child is already parented, the child will be un-parented with
        /// that parent and assigned the new <paramref name="parent"/>.</param>
        public static void MakeParentChild(IUpdateable parent, IUpdateable child)
        {
            // make sure the child isn't already a child of the parent
            if (parent.UpdateableChildren.Contains(child) == false)
            {
                parent.UpdateableChildren.Add(child);

                // if the child already has a parent, remove the child from that parent
                if (child.UpdateableParent != null)
                    child.UpdateableParent.UpdateableChildren.Remove(child);

                child.UpdateableParent = parent;
            }
        }

        /// <summary>
        /// A helper method that splits apart a parent/child relationship of two
        /// IUpdateables. The child's parent is first checked to make sure it is 
        /// the parent passed in. If it is, then the child's parent property is 
        /// set to null. If not, the parent property on the child is left alone.
        /// </summary>
        /// <param name="parent">The parent to separate from the child.</param>
        /// <param name="child">The child to separate from the parent.</param>
        public static void SeparateParentChild(IUpdateable parent, IUpdateable child)
        {
            // ensure these two are actually parented before seperating them
            if (child.UpdateableParent == parent)
            {
                parent.UpdateableChildren.Remove(child);
                child.UpdateableParent = null;
            }
        }

        /// <summary>
        /// Shallow copies the data from the <paramref name="source"/> 
        /// <see cref="IUpdateable"/> to the <paramref name="destination"/>
        /// <see cref="IUpdateable"/>.
        /// </summary>
        /// <param name="destination">The <see cref="IUpdateable"/> to copy the 
        /// data to.</param>
        /// <param name="source">The <see cref="IUpdateable"/> to copy the data
        /// from.</param>
        public static void ShallowCopy(IUpdateable destination, IUpdateable source)
        {
            destination.UpdateableParent = source.UpdateableParent;

            foreach (IUpdateable updateableChild in source.UpdateableChildren)
                MakeParentChild(destination, updateableChild);
        }

        /// <summary>
        /// The parent of this IUpdateable or null if this IUpdateable does not
        /// have a parent.
        /// </summary>
        public IUpdateable UpdateableParent { get; set; }

        /// <summary>
        /// Holds a collection of children that should be updated
        /// when this updateable decides they should be updated.
        /// </summary>
        public ICollection<IUpdateable> UpdateableChildren { get; private set; }
    }
}