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

namespace Chernobyl.Values
{
    /// <summary>
    /// An <see cref="IValue{T}"/> that represents multiple
    /// <see cref="IValue{T}"/> instances. This type will only raise
    /// <see cref="IValue{T}.Provide"/> if all contained <see cref="IValue{T}"/>
    /// instances have provided values. Additionally, after all
    /// <see cref="IValue{T}"/> instances have provided values, this type will
    /// raise <see cref="IValue{T}.Provide"/> when any of the contained
    /// <see cref="IValue{T}"/> instances raise there <see cref="IValue{T}.Provide"/>.
    /// </summary>
    /// <typeparam name="T">The type that is contained with the
    /// <see cref="IValue{T}"/> this type will be composed of.</typeparam>
    public class Composite<T> : BasicValue<IEnumerable<T>>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Composite{T}"/> class.
        /// </summary>
        /// <param name="values">The instances whose internal value is to be
        /// represented as an <see cref="IEnumerable{T}"/> by this instance.</param>
        public Composite(IEnumerable<IValue<T>> values)
        {
            values.ThrowIfNull("values");

            _values = values.ToArray();
        }

        /// <summary>
        /// The value held by this instance. If the value has not yet been
        /// provided it will be equal to <c>default(T)</c>. Setting this property
        /// will make this instance ready.
        /// </summary>
        protected override IEnumerable<T> BackingValue
        {
            get { return _value; }
            set
            {
                _value.Clear();
                _value.AddRange(value);
            }
        }

        /// <summary>
        /// The previous value of <see cref="BasicValue{T}.Value"/>.
        /// </summary>
        protected override IEnumerable<T> PreviousValue
        {
            get { return _previousValue; }
            set
            {
                _previousValue.Clear();
                _previousValue.AddRange(value);
            }
        }

        /// <summary>
        /// Invoked when <see cref="BasicValue{T}.IsNeeded" /> is changed to true.
        /// Implementations of this method should invoke the base class method.
        /// </summary>
        protected override void Needed()
        {
            // Set the capacity so that we don't have to trim the excess after
            // we've added the defaults values.
            _value.Capacity = _previousValue.Capacity = _valuesProvided.Length =
                _eventHandlers.Capacity = _values.Length;

            // Now ensure that we get the values and their updates.
            if (_values.Length != 0)
            {
                // Add default values so that we can just set the values when they
                // are provided.
                T[] defaults = new T[_values.Length];
                _value.AddRange(defaults);
                _previousValue.AddRange(defaults);
                _eventHandlers.AddRange(new EventHandler<ValueChangedEventArgs<T>>[_values.Length]);

                for (int i = 0; i < _values.Length; i++)
                {
                    int index = i; // Variable to prevent modified closure issue.

                    // Create, store, and assign the event handler.
                    EventHandler<ValueChangedEventArgs<T>> eventHandler =
                        (sender, e) => OnValueProvide(e, index);
                    _eventHandlers[index] = eventHandler;

                    _values[i].Provide += eventHandler;
                }
            }
            else
                IsReady = true;

            base.Needed();
        }

        /// <summary>
        /// Invoked when <see cref="BasicValue{T}.IsNeeded" /> is changed to false.
        /// Implementations of this method should invoke the base class method.
        /// </summary>
        protected override void NotNeeded()
        {
            for (int i = 0; i < _values.Length; i++)
                _values[i].Provide -= _eventHandlers[i];

            _previousValue.Clear();
            _value.Clear();
            _eventHandlers.Clear();

            _valuesProvided.SetAll(false);
            _providedCount = 0;

            IsReady = false;

            base.NotNeeded();
        }

        /// <summary>
        /// Invoked when one of the <see cref="IValue{T}" /> contained by this
        /// instance has it value changed or made ready.
        /// </summary>
        /// <param name="e">The <see cref="ValueChangedEventArgs{T}" />
        /// instance containing the event data.</param>
        /// <param name="index">The index of the item that was changed.</param>
        void OnValueProvide(ValueChangedEventArgs<T> e, int index)
        {
            _previousValue[index] = e.OldValue;
            _value[index] = e.NewValue;

            // Check if this Composite can be made ready. If we are ready then
            // we can notify client code of the change.
            bool raiseProvide = IsReady;
            if (_valuesProvided[index] == false)
            {
                _valuesProvided[index] = true;
                _providedCount++;

                // If all of the values have been provided, then we are ready.
                if (_providedCount == _values.Length)
                {
                    // Don't invoke Provide if we change IsReady to true since
                    // IsReady will invoke Provide for us.
                    if (IsReady == false)
                        IsReady = true;
                    else
                        raiseProvide = true;
                }
            }

            if (raiseProvide && ProvideHandler != null)
                ProvideHandler(this, new ValueChangedEventArgs<IEnumerable<T>>(
                    PreviousValue, Value));
        }

        /// <summary>
        /// The instances whose internal value is to be represented as an
        /// <see cref="IEnumerable{T}"/> by this instance.
        /// </summary>
        readonly IValue<T>[] _values;

        /// <summary>
        /// Specifies which values have been provided where 0 is not ready, 1 is
        /// ready.
        /// </summary>
        readonly BitArray _valuesProvided = new BitArray(0);

        /// <summary>
        /// The number of instances in <see cref="_values"/> that have provided
        /// a first value.
        /// </summary>
        uint _providedCount;

        /// <summary>
        /// The instance that contains the event handlers that react to the
        /// providing of values by the instance contained in <see cref="_values"/>.
        /// </summary>
        readonly List<EventHandler<ValueChangedEventArgs<T>>> _eventHandlers =
            new List<EventHandler<ValueChangedEventArgs<T>>>();

        /// <summary>
        /// The backing field to <see cref="BasicValue{T}.Value"/>.
        /// </summary>
        readonly List<T> _value = new List<T>();

        /// <summary>
        /// The backing field to <see cref="BasicValue{T}.PreviousValue"/>.
        /// </summary>
        readonly List<T> _previousValue = new List<T>();
    }

    /// <summary>
    /// Extension and utility methods for <see cref="Composite{T}"/>.
    /// </summary>
    public static class CompositeExt
    {
        /// <summary>
        /// Returns an <see cref="IValue{T}"/> that represents multiple <see cref="IValue{T}"/>
        /// instances. The instance will only raise <see cref="IValue{T}.Provide"/> if all contained
        /// <see cref="IValue{T}"/> instances have provided values. Additionally, after all
        /// <see cref="IValue{T}"/> instances have provided values, this type will raise
        /// <see cref="IValue{T}.Provide"/> when any of the contained <see cref="IValue{T}"/>
        /// instances raises its <see cref="IValue{T}.Provide"/> event.
        /// </summary>
        public static IValue<IEnumerable<T>> Composite<T>(this IEnumerable<IValue<T>> values) =>
            new Composite<T>(values);
    }
}