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

namespace Chernobyl.Collections.Generic.Hierarchy
{
    /// <summary>
    /// A helper class for implementing <see cref="IEnumerator{T}"/>s that 
    /// iterate over trees.
    /// </summary>
    /// <typeparam name="T">The type that contains a list of instances of it's 
    /// own type (a class that acts as a node in a tree).</typeparam>
    public abstract class TreeEnumerator<T> : IEnumerator<T>
    {
        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="DepthFirstEnumerator{T}"/> class.
        /// </summary>
        /// <param name="startingNode">The inclusive node to start from (it will
        /// become the first value of <see cref="IEnumerator{T}.Current"/>.</param>
        /// <param name="getChildEnumerator">The method that retrieves the 
        /// <see cref="IEnumerator{T}"/> from an instance of type 
        /// <typeparamref name="T"/>. Typically, it will look something like 
        /// this (using a lambda expression):
        /// <code>
        /// foobar => foobar.Children.GetEnumerator();
        /// </code>
        /// </param>
        protected TreeEnumerator(T startingNode, Func<T, IEnumerator<T>> getChildEnumerator)
        {
            EnumeratorLevels = new LinkedList<IEnumerator<T>>();
            Start = startingNode;
            GetChildEnumerator = getChildEnumerator;
            ResetInternal();
        }

        /// <summary>
        /// Gets the element in the collection at the current position of the 
        /// enumerator.
        /// </summary>
        /// <returns>The element in the collection at the current position of 
        /// the enumerator.</returns>
        /// <exception cref="InvalidOperationException">The enumerator is 
        /// positioned before the first element of the collection or after the 
        /// last element or the collection was modified after the enumerator 
        /// was created.</exception>
        public virtual T Current 
        { 
            get 
            {
                if (Started == false)
                    throw new InvalidOperationException("The enumerator is positioned " + 
                    "before the first element of the collection or after the last. Please " + 
                    "call the MoveNext() method on the enumerator before calling the Current property.");

                return _current; 
            }
            set { _current = value; }
        }

        /// <summary>
        /// Performs application-defined tasks associated with freeing, 
        /// releasing, or resetting unmanaged resources.
        /// </summary>
        public virtual void Dispose() { }

        /// <summary>
        /// Gets the element in the collection at the current position of the 
        /// enumerator.
        /// </summary>
        /// <returns>The element in the collection at the current position of 
        /// the enumerator.</returns>
        /// <exception cref="InvalidOperationException">The enumerator is 
        /// positioned before the first element of the collection or after the 
        /// last element or the collection was modified after the enumerator 
        /// was created.</exception>
        object IEnumerator.Current { get { return Current; } }

        /// <summary>
        /// Advances the enumerator to the next element of the collection.
        /// </summary>
        /// <returns>
        /// true if the enumerator was successfully advanced to the next element; 
        /// false if the enumerator has passed the end of the collection.
        /// </returns>
        /// <exception cref="InvalidOperationException">The collection was 
        /// modified after the enumerator was created. </exception>
        public abstract bool MoveNext();

        /// <summary>
        /// Sets the enumerator to its initial position, which is before the 
        /// first element in the collection.
        /// </summary>
        /// <exception cref="InvalidOperationException">The collection was 
        /// modified after the enumerator was created. </exception>
        public virtual void Reset()
        {
            ResetInternal();
        }

        /// <summary>
        /// The inclusive node to start from (it will become the first value of 
        /// <see cref="IEnumerator{T}.Current"/>. 
        /// </summary>
        protected T Start { get; set; }

        /// <summary>
        /// True if this <see cref="IEnumerator{T}"/> has started iterating 
        /// (<see cref="MoveNext()"/> has been called).
        /// </summary>
        protected bool Started { get; set; }

        /// <summary>
        /// The method that retrieves the <see cref="IEnumerator{T}"/> from an 
        /// instance of type <typeparamref name="T"/>. Typically, it will look 
        /// something like this (using a lambda expression):
        /// <code>
        /// foobar => foobar.Children.GetEnumerator();
        /// </code>
        /// </summary>
        protected Func<T, IEnumerator<T>> GetChildEnumerator;

        /// <summary>
        /// Represents the various levels of a tree (imagine the tree as a pyramid 
        /// with the one node at the top and child nodes at each story in the 
        /// pyramid). This list holds the enumerators we are currently enumerating 
        /// through.
        /// </summary>
        protected LinkedList<IEnumerator<T>> EnumeratorLevels { get; set; }

        /// <summary>
        /// This member is called in both the constructor and the 
        /// <see cref="Reset()"/> method. It was created to prevent a virtual 
        /// method call being made in the constructor.
        /// </summary>
        void ResetInternal()
        {
            EnumeratorLevels.Clear();
            Started = false;
        }

        /// <summary>
        /// The backing field to <see cref="Current"/>.
        /// </summary>
        T _current;
    }
}