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

namespace Chernobyl.Collections.Generic
{
    /// <summary>
    /// An <see cref="IEventEnumerable{T}"/> that contains a set of random items
    /// from another <see cref="IEventEnumerable{T}"/>.
    /// </summary>
    /// <typeparam name="T">The type that is to be contained within this
    /// <see cref="IEventEnumerable{T}"/>.</typeparam>
    public class Randoms<T> : DecoratingEventEnumerable<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Randoms{T}"/> class
        /// that allows duplicate values.
        /// </summary>
        /// <param name="enumerable">The instance to choose the random items from.</param>
        /// <param name="count">The number of random items to hold in this 
        /// instance. This number must be above zero and will be clamped to the 
        /// number of items in <paramref name="enumerable"/>.</param>
        public Randoms(IEventEnumerable<T> enumerable, uint count)
            : this(enumerable, count, true, new Random(), new List<T>())
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="Randoms{T}"/> class.
        /// </summary>
        /// <param name="enumerable">The instance to choose the random items from.</param>
        /// <param name="count">The number of random items to hold in this 
        /// instance. If <paramref name="allowDuplicates"/> is true then this 
        /// number will be clamped to the number of items in 
        /// <paramref name="enumerable"/>. This number must be above 0.</param>
        /// <param name="allowDuplicates">True if duplicate random items can be
        /// contained in this instance, false if otherwise.</param>
        public Randoms(IEventEnumerable<T> enumerable, uint count, bool allowDuplicates)
            : this(enumerable, count, allowDuplicates, new Random(), new List<T>())
        {}

        /// <summary>
        /// Initializes a new instance of the <see cref="Randoms{T}" /> class.
        /// </summary>
        /// <param name="enumerable">The instance to choose the random items from.</param>
        /// <param name="count">The number of random items to hold in this 
        /// instance. If <paramref name="allowDuplicates"/> is true then this 
        /// number will be clamped to the number of items in 
        /// <paramref name="enumerable"/>.  This number must be above 0.</param>
        /// <param name="allowDuplicates">True if duplicate random items can be
        /// contained in this instance, false if otherwise.</param>
        /// <param name="random">The <see cref="Random"/> number generator
        /// to use when finding random items.</param>
        /// <param name="collection">The <see cref="IEnumerable{T}" /> being
        /// decorated or extended with event capabilities.</param>
        public Randoms(IEventEnumerable<T> enumerable, uint count, bool allowDuplicates, Random random, ICollection<T> collection)
            : base(collection)
        {
            enumerable.ThrowIfNull("enumerable");
            if(count == 0)
                throw new ArgumentOutOfRangeException("count", count, 
                    "The count must be greater than zero.");
            random.ThrowIfNull("random");
            collection.ThrowIfNull("collection");

            _enumerable = enumerable;
            _items = collection;
            _count = count;
            _allowDuplicates = allowDuplicates;
            _random = random;

            Update();
            _enumerable.ItemsAdded += (sender, e) => Update();
            _enumerable.ItemsRemoved += (sender, e) => Update();
        }

        /// <summary>
        /// Re-randomizes the items in this instance.
        /// </summary>
        void Update()
        {
            // Remove the old items.
            if (_items.Any())
            {
                ItemsEventArgs<T> eventArgs = new ItemsEventArgs<T>(_items.ToList());
                _items.Clear();

                if (ItemsRemovedHandler != null)
                    ItemsRemovedHandler(this, eventArgs);
            }

            // Add the new items.
            if (_enumerable.Any())
            {
                _items.AddRange(_enumerable.Random(_count, _allowDuplicates, _random));

                if (ItemsAddedHandler != null)
                    ItemsAddedHandler(this, new ItemsEventArgs<T>(_items));
            }
        }

        /// <summary>
        /// The instance to choose the random items from.
        /// </summary>
        readonly IEventEnumerable<T> _enumerable;

        /// <summary>
        /// The instance that stores the random items.
        /// </summary>
        readonly ICollection<T> _items;

        /// <summary>
        /// The number of random items to hold in this instance. If 
        /// <see cref="_allowDuplicates"/> is true then this number will be 
        /// clamped to the number of items in <see cref="_enumerable"/>. This 
        /// number must be above 0.
        /// </summary>
        readonly uint _count;

        /// <summary>
        /// True if duplicate random items can be contained in this instance, 
        /// false if otherwise.
        /// </summary>
        readonly bool _allowDuplicates;

        /// <summary>
        /// The <see cref="Random"/> number generator to use when finding random 
        /// items.
        /// </summary>
        readonly Random _random;
    }

    /// <summary>
    /// Utility and extension code for 
    /// <see cref="Chernobyl.Collections.Generic.Randoms{T}"/> and the client
    /// code that uses it.
    /// </summary>
    public static class RandomsExtensions
    {
        /// <summary>
        /// Creates an <see cref="IEventEnumerable{T}" /> that contains a set of,
        /// continuously updated, random items from the 
        /// <see cref="IEventEnumerable{T}" /> specified. This method allows for
        /// duplicate items.
        /// </summary>
        /// <typeparam name="T">The type that is to be contained within this
        /// <see cref="IEventEnumerable{T}"/>.</typeparam>
        /// <param name="enumerable">The instance to choose the random items from.</param>
        /// <param name="count">The number of random items to hold in this 
        /// instance. This number must be greater than 0 and will be clamped to
        /// <paramref name="enumerable"/>.</param>
        /// <returns>The <see cref="IEventEnumerable{T}" /> containing the random 
        /// items.</returns>
        public static IEventEnumerable<T> Randoms<T>(this IEventEnumerable<T> enumerable, uint count)
        {
            return enumerable.Randoms(count, true);
        }

        /// <summary>
        /// Creates an <see cref="IEventEnumerable{T}" /> that contains a set of,
        /// continuously updated, random items from the 
        /// <see cref="IEventEnumerable{T}" /> specified.
        /// </summary>
        /// <typeparam name="T">The type that is to be contained within this
        /// <see cref="IEventEnumerable{T}"/>.</typeparam>
        /// <param name="enumerable">The instance to choose the random items from.</param>
        /// <param name="count">The number of random items to hold in this 
        /// instance. If <paramref name="allowDuplicates"/> is true then this 
        /// number will be clamped to the number of items in 
        /// <paramref name="enumerable"/>. This number must be above 0.</param>
        /// <param name="allowDuplicates">True if duplicate random items can be
        /// contained in this instance, false if otherwise.</param>
        /// <returns>The <see cref="IEventEnumerable{T}" /> containing the random 
        /// items.</returns>
        public static IEventEnumerable<T> Randoms<T>(this IEventEnumerable<T> enumerable, uint count, bool allowDuplicates)
        {
            return new Randoms<T>(enumerable, count, allowDuplicates);
        }
    }
}