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

namespace Chernobyl.Collections.Generic
{
    /// <summary>
    /// An <see cref="IEnumerator{T}"/> that continuously loops through an <see cref="IEnumerable{T}"/>.
    /// </summary>
    public class LoopingEnumerator<T> : IEnumerator<T>
    {
        /// <param name="enumerable">The values to infinitely loop.</param>
        /// <param name="reverseWhenFinished">True if this instance should start at the end when it is finished
        /// with one full iteration. False if it should start at the beginning.</param>
        public LoopingEnumerator(IEnumerable<T> enumerable, bool reverseWhenFinished = false)
        {
            _enumerable = enumerable;
            _reverseWhenFinished = reverseWhenFinished;

            _forward = _enumerable.GetEnumerator();
            _backward = _enumerable.Reverse().GetEnumerator();
            _enumerator = _forward;
        }

        /// <inheritdoc />
        public T Current
        {
            get
            {
                if (_currentAvailable == null)
                    throw new InvalidOperationException("Enumeration has not started. Call MoveNext.");

                var current = default(T);
                if (_currentAvailable == true) current = _enumerator.Current;
                return current;
            }
        }

        /// <inheritdoc />
        object IEnumerator.Current => Current;

        /// <inheritdoc />
        public bool MoveNext()
        {
            bool result = _enumerator.MoveNext();
            _currentAvailable = result;

            if (result == false)
            {
                if(_reverseWhenFinished)
                {
                    if (_enumerator == _forward)
                    {
                        _enumerator.Reset();
                        _enumerator = _backward;
                    }
                    else
                    {
                        // Reverse enumerators don't support Reset so we have to grab a fresh
                        // reverse enumerator.
                        _enumerator = _forward;
                        _backward.Dispose();
                        _backward = _enumerable.Reverse().GetEnumerator();
                    }
                }
                else _enumerator.Reset();

                _currentAvailable = result = _enumerator.MoveNext();
            }
            return result;
        }

        /// <inheritdoc />
        public void Reset()
        {
            _enumerator.Reset();
            _enumerator = _forward;
        }

        /// <inheritdoc />
        public void Dispose()
        {
            _backward.Dispose();
            _forward.Dispose();
        }

        readonly IEnumerable<T> _enumerable;
        readonly bool _reverseWhenFinished;
        readonly IEnumerator<T> _forward;
        IEnumerator<T> _backward;
        IEnumerator<T> _enumerator;

        // Set to the last return value of MoveNext or null if MoveNext has not been called.
        bool? _currentAvailable;
    }

    /// <summary>
    /// Utility and extension methods for <see cref="LoopingEnumerator{T}"/>.
    /// </summary>
    public static class LoopingEnumerator
    {
        /// <summary>
        /// Turns an <see cref="IEnumerable{T}"/> into an infinitely looping <see cref="IEnumerable{T}"/>.
        /// </summary>
        /// <param name="enumerable">The values to infinitely loop.</param>
        /// <param name="reverseWhenFinished">True if this instance should start at the end when it
        /// is finished with one full iteration. False if it should start at the beginning.</param>
        public static IEnumerable<T> AsLooping<T>(this IEnumerable<T> enumerable, bool reverseWhenFinished = false) =>
            new EnumeratorEnumerable<T>(() => new LoopingEnumerator<T>(enumerable, reverseWhenFinished));
    }
}