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

namespace Chernobyl.Reflection.Template
{
    /// <summary>
    /// An <see cref="IComponent"/> that allows for at runtime switching of
    /// it's implementation and makes creating new <see cref="IComponent"/>s
    /// easier through the use of other <see cref="IComponent"/> implementations.
    /// This is an implementation of the decorator pattern 
    /// (http://en.wikipedia.org/wiki/Decorator_pattern).
    /// </summary>
    public abstract class ComponentDecorator : IComponent
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ComponentDecorator"/> class.
        /// Note to implementors: this constructor immediately configures the
        /// <see cref="DecoratedComponent"/> using the 
        /// <see cref="ConfigureImplementer()"/> method. This assumes the
        /// <see cref="DecoratedComponent"/> is ready to use.
        /// </summary>
        protected ComponentDecorator() 
            : this(true)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="ComponentDecorator"/> class.
        /// </summary>
        /// <param name="configure">True if this instance should be configured
        /// immediately, false if the <see cref="ConfigureImplementer()"/> method
        /// will be invoked at a later time by the implementing type.</param>
        protected ComponentDecorator(bool configure)
        {
            if (configure == true)
                ConfigureImplementer();
        }

        /// <summary>
        /// The namespace or prefix of this component.
        /// </summary>
        public string Prefix
        {
            get { return DecoratedComponent.Prefix; }
        }

        /// <summary>
        /// The name of this component which can be used to generate code for
        /// this component.
        /// </summary>
        public virtual string CodeName
        {
            get { return DecoratedComponent.CodeName; }
        }

        /// <summary>
        /// The <see cref="IComponent"/> that is the parent to this
        /// <see cref="IComponent"/>. This <see cref="IComponent"/> will be
        /// added to the parent <see cref="IComponent"/>'s
        /// <see cref="ComponentChildren"/> list. If this <see cref="IComponent"/>
        /// is already a child to another <see cref="IComponent"/> then it will
        /// be removed from that <see cref="IComponent"/>'s
        /// <see cref="ComponentChildren"/> list. Setting null on this property
        /// will cause this <see cref="IComponent"/> to be removed from it's
        /// parent, if necessary. Note that the <see cref="ComponentDecorator"/>
        /// does not invoke the <see cref="DecoratedComponent"/>'s
        /// <see cref="Parent"/> property because then the 
        /// <see cref="DecoratedComponent"/> would be added to the 
        /// <see cref="Parent"/>'s <see cref="ComponentChildren"/> list rather
        /// than this instance.
        /// </summary>
        public virtual IComponent Parent
        {
            get { return DecoratedComponent.Parent; }
            set { DecoratedComponent.Parent = value; }
        }

        /// <summary>
        /// Sub-components of this <see cref="IComponent"/>. Note that the 
        /// <see cref="ComponentDecorator"/> does not return the 
        /// <see cref="DecoratedComponent"/>'s <see cref="ComponentChildren"/>
        /// property because then the <see cref="DecoratedComponent"/> would 
        /// be set on the added children's <see cref="Parent"/> property rather
        /// than this instance.
        /// </summary>
        public IEventCollection<IComponent> ComponentChildren
        {
            get { return DecoratedComponent.ComponentChildren; }
        }

        /// <summary>
        /// Gets or sets the name of the instance. This property is made virtual
        /// to allow for a name is separate from the
        /// <see cref="DecoratedComponent"/>.
        /// </summary>
        public string Name
        {
            get { return DecoratedComponent.Name; }
            set { DecoratedComponent.Name = value; }
        }

        /// <summary>
        /// An <see cref="IEnumerable{T}"/> that iterates over an
        /// <see cref="ITreeEnumerable{T}"/> in depth first order (see
        /// http://en.wikipedia.org/wiki/Depth-first_search for more information).
        /// </summary>
        /// <value></value>
        public IEnumerable<IComponent> DepthFirst
        {
            get { return DecoratedComponent.DepthFirst; }
        }

        /// <summary>
        /// An <see cref="IEnumerable{T}"/> that iterates over an
        /// <see cref="ITreeEnumerable{T}"/> in breadth first order (see
        /// http://en.wikipedia.org/wiki/Breadth-first_search for more information).
        /// </summary>
        /// <value></value>
        public IEnumerable<IComponent> BreadthFirst
        {
            get { return DecoratedComponent.BreadthFirst; }
        }

        /// <summary>
        /// Returns an enumerator that iterates through this
        /// <see cref="IComponent"/> and the <see cref="IComponent"/> tree
        /// underneath it.
        /// </summary>
        /// <returns>
        /// A <see cref="IEnumerator{T}"/> that can 
        /// be used to iterate through the <see cref="IComponent"/> tree.
        /// </returns>
        public IEnumerator<IComponent> GetEnumerator()
        {
            return DecoratedComponent.GetEnumerator();
        }

        /// <summary>
        /// Returns an <see cref="IEnumerator"/> that iterates through this
        /// <see cref="IComponent"/> and the <see cref="IComponent"/> tree
        /// underneath it.
        /// </summary>
        /// <returns>
        /// A <see cref="IEnumerator"/> that can 
        /// be used to iterate through the <see cref="IComponent"/> tree.
        /// </returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return DecoratedComponent.GetEnumerator();
        }

        /// <summary>
        /// The <see cref="IComponent"/> that "decorates"
        /// (http://en.wikipedia.org/wiki/Decorator_pattern) this
        /// <see cref="IComponent"/>. The decorator is used when this
        /// <see cref="IComponent"/> needs client code to refer to the
        /// decorator rather than this <see cref="IComponent"/> such as when
        /// parenting children. In the event that a decorator doesn't exist,
        /// this property is set to null.
        /// </summary>
        public IComponent Decorator
        {
            get { return DecoratedComponent.Decorator; }
            set { DecoratedComponent.Decorator = value; }
        }

        /// <summary>
        /// A method that must be invoked by the implementing type so this
        /// instance can be properly setup to work with the 
        /// <see cref="DecoratedComponent"/>.
        /// </summary>
        protected void ConfigureImplementer()
        {
            if (_implementerConfigured == false)
            {
                if (DecoratedComponent == null)
                    throw new Exception("The DecoratedComponent is null and cannot " +
                    "be configured. Please pass false to this class' constructor and " +
                    "invoke ConfigureImplementer() method when the DecoratedComponent " +
                    "is ready.");

                Decorator = this;
                _implementerConfigured = true;
            }   
        }

        /// <summary>
        /// The <see cref="IComponent"/> instance that implements the 
        /// functionality of this class.
        /// </summary>
        protected abstract IComponent DecoratedComponent { get; }

        /// <summary>
        /// True if the <see cref="ConfigureImplementer()"/> method has already
        /// been called, false if otherwise.
        /// </summary>
        bool _implementerConfigured;
    }
}