using System;
using System.Collections.Generic;
using Chernobyl.ComponentModel;

namespace Chernobyl.Creation
{
    /// <summary>
    /// An <see cref="IFactory{TResult, T1}"/> that holds a list of
    /// <see cref="IFactory{TResult, T1}"/> instances. When a creation is
    /// requested, this type will go down the list attempt to build the item
    /// using each <see cref="IFactory{TResult, T1}"/>. This type will return
    /// the first item successfully created from one of the
    /// <see cref="IFactory{TResult, T1}"/>.
    /// </summary>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <typeparam name="T1">The type of the 1.</typeparam>
    public class FirstSuccessFactory<TResult, T1>
        : Builder<TResult>, IFactory<TResult, T1>
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="FirstSuccessFactory{TResult,T1}"/> class.
        /// </summary>
        /// <param name="selectors">The <see cref="IFactory{TResult, T1}"/>
        /// that are to be attempted in building of items.</param>
        public FirstSuccessFactory(IEnumerable<IFactory<TResult, T1>> selectors)
        {
            _selectors = selectors;
        }

        /// <summary>
        /// Constructs and/or configures an instance of type
        /// <typeparamref name="TResult"/>. When this method is invoked,
        /// <see cref="IBuilder{TResult}.Created"/> will be raised before
        /// <paramref name="callback"/> is invoked.
        /// </summary>
        /// <param name="callback">The method that should be invoked when the
        /// instance has been created, when its creation was canceled, or when
        /// an error occurred during its creation. Note that this callback may
        /// be invoked on another thread.</param>
        /// <param name="arg1">The first argument.</param>
        /// <returns>
        /// The <see cref="ITask"/> that can be used to control and
        /// track the creation/configuration of the instance.
        /// </returns>
        public ITask Create(CreationCompletedEventHandler<TResult> callback, T1 arg1)
        {
            return new Task(this, _selectors.GetEnumerator(), callback, arg1);
        }

        /// <summary>
        /// Represents a creation task; handle the actual construction.
        /// </summary>
        class Task : ComponentModel.Task
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="Task"/> class.
            /// </summary>
            /// <param name="factory">The instance that spawned this 
            /// <see cref="ITask"/>.</param>
            /// <param name="selector">The instance that denotes the order in 
            /// which the <see cref="IFactory{TResult, T1}"/> instances are to 
            /// be tried.</param>
            /// <param name="callback">The method that should be invoked when 
            /// the instance has been created, when its creation was canceled, 
            /// or when an error occurred during its creation. Note that this 
            /// callback may be invoked on another thread.</param>
            /// <param name="arg1">The first argument provided to the 
            /// <see cref="IFactory{TResult, T1}"/> instances at creation.</param>
            public Task(FirstSuccessFactory<TResult, T1> factory,
                        IEnumerator<IFactory<TResult, T1>> selector,
                        CreationCompletedEventHandler<TResult> callback,
                        T1 arg1)
            {
                _factory = factory;
                _selector = selector;
                _callback = callback;
                _arg1 = arg1;

                TryNextFactory();
            }

            /// <summary>
            /// An event handler that is invoked when an
            /// <see cref="IFactory{TResult, T1}"/> finishes construction.
            /// </summary>
            /// <param name="sender">The sender of the event.</param>
            /// <param name="e">The <see cref="CreationEventArgs{TResult}"/> 
            /// instance containing the event data.</param>
            void OnCreation(object sender, CreationEventArgs<TResult> e)
            {
                if (e.IsGood())
                    _factory.ReportCreation(_callback, e);
                else
                    TryNextFactory();
            }

            /// <summary>
            /// Moves to the next <see cref="IFactory{TResult, T1}"/> and
            /// invokes the creation method on it. If no 
            /// <see cref="IFactory{TResult, T1}"/> instances are left to try
            /// an error is reported.
            /// </summary>
            void TryNextFactory()
            {
                if (_selector.MoveNext())
                    _selector.Current.Create(OnCreation, _arg1);
                else
                {
                    _factory.ReportCreation(_callback,
                        new CreationEventArgs<TResult>(
                            new Exception("Unable to create the requested " +
                                          "item. No factories are available " +
                                          "which can produce the item.")));
                }
            }

            /// <summary>
            /// The instance that spawned this <see cref="ITask"/>.
            /// </summary>
            readonly FirstSuccessFactory<TResult, T1> _factory;

            /// <summary>
            /// The instance that denotes the order in which the
            /// <see cref="IFactory{TResult, T1}"/> instances are to be tried.
            /// </summary>
            readonly IEnumerator<IFactory<TResult, T1>> _selector;

            /// <summary>
            /// The method that should be invoked when the instance has been 
            /// created, when its creation was canceled, or when an error 
            /// occurred during its creation. Note that this callback may be 
            /// invoked on another thread.
            /// </summary>
            readonly CreationCompletedEventHandler<TResult> _callback;

            /// <summary>
            /// The first argument provided to the <see cref="IFactory{TResult, T1}"/>
            /// instances at creation.
            /// </summary>
            readonly T1 _arg1;
        }

        /// <summary>
        /// The <see cref="IFactory{TResult, T1}"/> that are to be attempted in 
        /// building of items.
        /// </summary>
        readonly IEnumerable<IFactory<TResult, T1>> _selectors;
    }
}