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

namespace Chernobyl.Collections.Generic
{
    /// <summary>
    /// An <see cref="IEnumerator{T}"/> that iterates through instances of types 
    /// that are structured like a linked list. i.e., the type contains an 
    /// instance to another instance of the same type. For example:
    /// <code>
    /// public class Foobar
    /// {
    ///     public Foobar NextFoo { get; set; }
    /// }
    /// </code>
    /// </summary>
    /// <typeparam name="T">The type that contains an instance of it's 
    /// own type (a class that acts as a node in a linked list).</typeparam>
    public class LinkedEnumerator<T> : IEnumerator<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="LinkedEnumerator{T}"/> 
        /// class.
        /// </summary>
        /// <param name="start">The inclusive node to start from (it will
        /// become the first value of <see cref="IEnumerator{T}.Current"/>.</param>
        /// <param name="getNextItem">A method that returns the next item for the 
        /// current instance. The current instance is passed into the method as 
        /// the first argument and the second argument is for returning the next 
        /// instance. False is to be returned if there is no next item, true if 
        /// the next item set on the second parameter is a valid instance.</param>
        public LinkedEnumerator(T start, NextItem getNextItem)
        {
            Start = start;
            GetNextItem = getNextItem;
            Reset();
        }

        /// <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>
        public T Current
        {
            get
            {
                if (Started == false)
                    throw new InvalidOperationException("The enumerator is " +
                    "positioned before the first element of the collection " +
                    "Make sure the MoveNext() method has been called. ");

                if (Finished == true)
                    throw new InvalidOperationException("The enumerator is " +
                    "positioned after the last element of the collection " +
                    "Make sure to call Reset() to before restarting the iteration. ");

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

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


        /// <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>
        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 bool MoveNext()
        {
            bool result = false;

            if (Started == false)
            {
                result = Started = true;
                Current = Start;
            }
            else
            {
                // GetNextItem will return false if we are finished, true if otherwise
                Finished = !GetNextItem(Current, out _current);
                result = !Finished;
            }

            return result;
        }

        /// <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 void Reset()
        {
            Current = Start;
            Started = false;
            Finished = false;
        }

        /// <summary>
        /// Represents a method that is used to retrieve the next item in a  
        /// linked set of instances.
        /// </summary>
        /// <param name="current">The current item that was enumerated over.</param>
        /// <param name="next">The instance that is to take the result of the  
        /// next item to enumerate through.</param>
        /// <returns>False if there is no next item, true if the next item set 
        /// on <paramref name="next"/> is valid.</returns>
        public delegate bool NextItem(T current, out T next);

        /// <summary>
        /// A method that returns the next item for the current instance. The 
        /// current instance is passed into the method as the first argument and 
        /// the second argument is for returning the next instance. False is to 
        /// be returned if there is no next item, true if the next item set 
        /// on the second parameter is a valid instance.
        /// </summary>
        NextItem GetNextItem { get; set; }

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

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

        /// <summary>
        /// True if the end of the resource processing chain has been reached,
        /// false if otherwise.
        /// </summary>
        bool Finished { get; set; }

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