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

namespace Chernobyl.Collections.Generic.Hierarchy
{
    /// <summary>
    /// An NUnit helper test fixture that is made to help with the creation of 
    /// test fixtures which test <see cref="ITreeEnumerable{T}"/> and related 
    /// tree <see cref="IEnumerator{T}"/> types.
    /// </summary>
    public abstract class TreeEnumeratorTests : EnumerationTests<TreeEnumeratorTests.Foobar>
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="TreeEnumeratorTests"/> class.
        /// </summary>
        protected TreeEnumeratorTests()
            : base(true)
        { }

        /// <summary>
        /// A helper class that implements <see cref="ITreeEnumerable{T}"/>. 
        /// This class gives base classes a common <see cref="ITreeEnumerable{T}"/> 
        /// to test with.
        /// </summary>
        public class Foobar : ITreeEnumerable<Foobar>
        {
            public Foobar(int index)
            {
                Children = new List<Foobar>();
                Index = index;
            }

            public int Index;

            public List<Foobar> Children { get; private set; }

            public IEnumerable<Foobar> DepthFirst
            {
                get
                {
                    return
                        new EnumeratorFactory<Foobar>(
                            () => new DepthFirstEnumerator<Foobar>(this, foobar => foobar.Children.GetEnumerator()));
                }
            }

            public IEnumerable<Foobar> BreadthFirst
            {
                get
                {
                    return
                        new EnumeratorFactory<Foobar>(
                            () => new BreadthFirstEnumerator<Foobar>(this, foobar => foobar.Children.GetEnumerator()));
                }
            }

            public IEnumerator<Foobar> GetEnumerator()
            {
                return DepthFirst.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }

        /// <summary>
        /// This method should return a new <see cref="IEnumerable{T}"/> that can
        /// be iterated over exactly once. This method should create a new
        /// <see cref="IEnumerable{T}"/> every time it is invoked and not reuse
        /// instances.
        /// </summary>
        protected override IEnumerable<Foobar> CreateSingleItemEnumerable()
        {
            return new Foobar(0);
        }

        protected override IEnumerable<Foobar> OrderedItems
        {
            get { return OrderedItemsValue; }
        }

        /// <summary>
        /// The backing property to <see cref="OrderedItems"/>.
        /// </summary>
        protected IEnumerable<Foobar> OrderedItemsValue { get; set; }
    }
}