using System;
using System.Collections.Generic;
using Chernobyl.Update;

namespace Chernobyl.Input.Controls
{
    /// <summary>
    /// A helper class that implements a default control and makes creating
    /// IControls easier. This class also defines some static helper methods
    /// for working with <see cref="IControl"/>s.
    /// </summary>
    public abstract class Control : Updateable, IControl
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        protected Control() : this(new List<IControl>())
        { }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="controlChildrenList">The list to use as a child control list.</param>
        protected Control(ICollection<IControl> controlChildrenList)
        {
            ControlChildren = controlChildrenList;
        }

        /// <summary>
        /// The name of this control.
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// A helper method that takes one <see cref="IControl"/> and makes it 
        /// the parent of another. If a previous parent is attached to child,
        /// that parent will first be separated from the child passed in. This 
        /// method also makes the parent and child into <see cref="IUpdateable"/> 
        /// parent and child; i.e. it is the same as calling:
        /// <code>
        /// Control.MakeParentChild(parent, child, true);
        /// </code>
        /// </summary>
        /// <param name="parent">The <see cref="IControl"/> that is to become the 
        /// parent of the <paramref name="child"/>.</param>
        /// <param name="child">The <see cref="IControl"/> that is to become the 
        /// child of the <paramref name="parent"/>.</param>
        public static void MakeParentChild(IControl parent, IControl child)
        {
            MakeParentChild(parent, child, true);
        }

        /// <summary>
        /// A helper method that takes one <see cref="IControl"/> and makes it 
        /// the parent of another. If a previous parent is attached to child,
        /// that parent will first be separated from the child passed in.
        /// </summary>
        /// <param name="parent">The <see cref="IControl"/> that is to become the 
        /// parent of the <paramref name="child"/>.</param>
        /// <param name="child">The <see cref="IControl"/> that is to become the 
        /// child of the <paramref name="parent"/>.</param>
        /// <param name="makeUpdateableParentChild">True if the <see cref="IControl"/> 
        /// <paramref name="parent"/> and <paramref name="child"/> should be made 
        /// into <see cref="IUpdateable"/> parent and child also, false if 
        /// otherwise.</param>
        public static void MakeParentChild(IControl parent, IControl child, bool makeUpdateableParentChild)
        {
            parent.ControlChildren.Add(child);

            // if the child already has a parent, have them separate
            if (child.ControlParent != null)
                child.ControlParent.ControlChildren.Remove(child);

            child.ControlParent = parent;

            if(makeUpdateableParentChild == true)
                Updateable.MakeParentChild(parent, child);
        }

        /// <summary>
        /// A helper method that splits apart a parent/child relationship of two
        /// <see cref="IControl"/>s. 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. If the parent and child are <see cref="IUpdateable"/> 
        /// parent and child as well, then they will be separated. 
        /// </summary>
        /// <param name="parent">The <see cref="IControl"/> parent that is to be 
        /// separated from the <paramref name="child"/>.</param>
        /// <param name="child">The <see cref="IControl"/> child that is to be 
        /// separated from the <paramref name="child"/>.</param>
        public static void SeparateParentChild(IControl parent, IControl child)
        {
            // ensure these two are actually parented before separating them
            if (child.ControlParent == parent)
            {
                parent.ControlChildren.Remove(child);
                child.ControlParent = null;

                Updateable.SeparateParentChild(parent, child);
            }
        }

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

            destination.Name = source.Name;
            destination.ControlParent = source.ControlParent;

            foreach (IControl controlChild in source.ControlChildren)
                MakeParentChild(destination, controlChild);
        }

        /// <summary>
        /// The parent of this control.
        /// </summary>
        public IControl ControlParent { get; set; }

        /// <summary>
        /// The children of this control
        /// </summary>
        public ICollection<IControl> ControlChildren { get; protected set; }

        /// <summary>
        /// An event that is raised when this <see cref="IControl"/> is
        /// disconnected from the device it was previously connected to and is
        /// no longer available for use. Actions performed on the 
        /// <see cref="IControl"/> after it has been disconnected may result
        /// is an <see cref="DisconnectedException"/> being thrown.
        /// </summary>
        public virtual event EventHandler Disconnected
        {
            add { DisconnectedMethod += value; }
            remove { DisconnectedMethod -= value; }
        }

        /// <summary>
        /// The method that acts as the backing property to 
        /// <see cref="Disconnected"/>. Use this method if you wish to raise the
        /// <see cref="Disconnected"/> event.
        /// </summary>
        protected EventHandler DisconnectedMethod { get; private set; }
    }
}