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

namespace Chernobyl.Collections.Generic.Event
{
    /// <summary>
    /// An <see cref="IEventEnumerable{T}"/> that never changes. This type
    /// converts an <see cref="IEnumerable{T}"/> to an 
    /// <see cref="IEventEnumerable{T}"/>.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class StaticEventEnumerable<T> : IEventEnumerable<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="StaticEventEnumerable{T}"/> class.
        /// </summary>
        /// <param name="enumerable">The instance represented by this 
        /// <see cref="IEventEnumerable{T}"/>.</param>
        public StaticEventEnumerable(params T[] enumerable)
            : this((IEnumerable<T>)enumerable)
        {}

        /// <summary>
        /// Initializes a new instance of the <see cref="StaticEventEnumerable{T}"/> class.
        /// </summary>
        /// <param name="enumerable">The instance represented by this 
        /// <see cref="IEventEnumerable{T}"/>.</param>
        public StaticEventEnumerable(IEnumerable<T> enumerable)
        {
            _enumerable = enumerable;
        }

        /// <summary>
        /// An event that is raised right after items are added to this list.
        /// </summary>
        public event EventHandler<ItemsEventArgs<T>> ItemsAdded
        {
            add { /* event handler not needed. */ }
            remove { /* event handler not needed. */ }
        }

        /// <summary>
        /// An event that is raised right after items are removed from this list.
        /// </summary>
        public event EventHandler<ItemsEventArgs<T>> ItemsRemoved
        {
            add { /* event handler not needed. */ }
            remove { /* event handler not needed. */ }
        }

        /// <summary>
        /// Returns an enumerator that iterates through the collection.
        /// </summary>
        /// <returns>
        /// A <see cref="IEnumerator{T}" /> that can be used to iterate through 
        /// the collection.
        /// </returns>
        public IEnumerator<T> GetEnumerator()
        {
            return _enumerable.GetEnumerator();
        }

        /// <summary>
        /// Returns an enumerator that iterates through a collection.
        /// </summary>
        /// <returns>
        /// An <see cref="IEnumerator" /> object that can be used to iterate 
        /// through the collection.
        /// </returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        /// <summary>
        /// An event that is raised right after items are added to this list.
        /// </summary>
        event EventHandler<ItemsEventArgs> IEventEnumerable.ItemsAdded
        {
            add { /* event handler not needed. */ }
            remove { /* event handler not needed. */ }
        }

        /// <summary>
        /// An event that is raised right after items are removed from this list.
        /// </summary>
        event EventHandler<ItemsEventArgs> IEventEnumerable.ItemsRemoved
        {
            add { /* event handler not needed. */ }
            remove { /* event handler not needed. */ }
        }

        /// <summary>
        /// The instance represented by this <see cref="IEventEnumerable{T}"/>.
        /// </summary>
        readonly IEnumerable<T> _enumerable;
    }

    /// <summary>
    /// Extensions and utilities for <see cref="StaticEventEnumerable{T}"/> and 
    /// related types.
    /// </summary>
    public static class StaticEventEnumerableExtensions
    {
        /// <summary>
        /// Creates an <see cref="IEventEnumerable{T}"/> from an 
        /// <see cref="IEnumerable{T}"/>.
        /// </summary>
        /// <typeparam name="T">The type of the elements of source.</typeparam>
        /// <param name="source">The <see cref="IEnumerable{T}"/> to create a 
        /// <see cref="IEventEnumerable{T}"/> from.</param>
        /// <returns>A <see cref="IEventEnumerable{T}"/> that contains elements 
        /// from the input sequence.</returns>
        /// <exception cref="ArgumentNullException">Thrown if 
        /// <paramref name="source"/> is null.</exception>
        public static IEventEnumerable<T> ToEventEnumerable<T>(this IEnumerable<T> source)
        {
            return new StaticEventEnumerable<T>(source);
        }
    }
}