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

namespace Chernobyl.Extensions
{
    /// <summary>
    /// Extension methods for <see cref="Action{T}"/> and related types.
    /// </summary>
    public static class ActionExtensions
    {
        /// <summary>
        /// Returns a method that invokes <paramref name="method"/> with the
        /// argument specified by <paramref name="arg1"/>.
        /// </summary>
        /// <typeparam name="T1">The type of the argument expected by 
        /// <paramref name="method"/>.</typeparam>
        /// <param name="method">The method to invoke on invocation of the returned
        /// method.</param>
        /// <param name="arg1">The argument to pass to <paramref name="method"/>
        /// on invocation of the returned method.</param>
        /// <returns>The method whose invocation invokes <paramref name="method"/>
        /// with <paramref name="arg1"/> as its parameter.</returns>
        public static Action Bind<T1>(this Action<T1> method, T1 arg1)
        {
            return () => method(arg1);
        }

        /// <summary>
        /// Returns a sequence of methods whose argument is bound to the values
        /// in <paramref name="arguments"/>.
        /// </summary>
        /// <typeparam name="T1">The argument type expected by <paramref name="method"/>.</typeparam>
        /// <param name="method">The method to be invoked on invocation of the
        /// returned methods.</param>
        /// <param name="arguments">The instances to be provided to 
        /// <paramref name="method"/>.</param>
        /// <returns>The methods whose invocation will invoke <paramref name="method"/>
        /// with the <paramref name="arguments"/> as its parameters.</returns>
        public static IEnumerable<Action> Bind<T1>(this Action<T1> method, IEnumerable<T1> arguments)
        {
            return arguments.Select<T1, Action>(method.Bind);
        }

        /// <summary>
        /// Returns a method that invokes <paramref name="method" /> with the
        /// argument specified by <paramref name="arg1" />.
        /// </summary>
        /// <typeparam name="T1">The type of the first argument expected by
        /// <paramref name="method" />.</typeparam>
        /// <typeparam name="T2">The type of the second argument expected by
        /// <paramref name="method" />.</typeparam>
        /// <param name="method">The method to invoke on invocation of the returned
        /// method.</param>
        /// <param name="arg1">The argument to pass to <paramref name="method" />
        /// on invocation of the returned method.</param>
        /// <returns>
        /// The method whose invocation invokes <paramref name="method" />
        /// with <paramref name="arg1" /> as its parameter.
        /// </returns>
        public static Action<T2> Bind<T1, T2>(this Action<T1, T2> method, T1 arg1)
        {
            return arg2 => method(arg1, arg2);
        }

        /// <summary>
        /// Returns a sequence of methods whose first argument is bound to the 
        /// values in <paramref name="firstArguments"/>.
        /// </summary>
        /// <typeparam name="T1">The first argument type expected by <paramref name="method" />.</typeparam>
        /// <typeparam name="T2">The second argument type expected by <paramref name="method" />.</typeparam>
        /// <param name="method">The method to be invoked on invocation of the
        /// returned methods.</param>
        /// <param name="firstArguments">The instances to be provided to
        /// <paramref name="method" />.</param>
        /// <returns>
        /// The methods whose invocation will invoke <paramref name="method" />
        /// with the <paramref name="firstArguments" /> as its parameters.
        /// </returns>
        public static IEnumerable<Action<T2>> Bind<T1, T2>(this Action<T1, T2> method, IEnumerable<T1> firstArguments)
        {
            return firstArguments.Select<T1, Action<T2>>(method.Bind);
        }

        /// <summary>
        /// Returns a method that invokes <paramref name="method" /> with the
        /// argument specified by <paramref name="arg1" />.
        /// </summary>
        /// <typeparam name="T1">The type of the first argument expected by
        /// <paramref name="method" />.</typeparam>
        /// <typeparam name="T2">The type of the second argument expected by
        /// <paramref name="method" />.</typeparam>
        /// <typeparam name="T3">The type of the third argument expected by
        /// <paramref name="method" />.</typeparam>
        /// <param name="method">The method to invoke on invocation of the returned
        /// method.</param>
        /// <param name="arg1">The argument to pass to <paramref name="method" />
        /// on invocation of the returned method.</param>
        /// <returns>
        /// The method whose invocation invokes <paramref name="method" />
        /// with <paramref name="arg1" /> as its parameter.
        /// </returns>
        public static Action<T2, T3> Bind<T1, T2, T3>(this Action<T1, T2, T3> method, T1 arg1)
        {
            return (arg2, arg3) => method(arg1, arg2, arg3);
        }

        /// <summary>
        /// Returns a method that, when invoked, will invoked the provided
        /// <paramref name="method" /> once for each of the <paramref name="firstArguments" />
        /// provided. The <paramref name="firstArguments" /> will form the first
        /// parameter of the <paramref name="method" />.
        /// </summary>
        /// <typeparam name="T1">The first argument type expected by <paramref name="method" />.</typeparam>
        /// <typeparam name="T2">The second argument type expected by <paramref name="method" />.</typeparam>
        /// <typeparam name="T3">The third argument type expected by <paramref name="method" />.</typeparam>
        /// <param name="method">The method to be invoked on invocation of the
        /// returned method.</param>
        /// <param name="firstArguments">The instances to be provided to
        /// <paramref name="method" />.</param>
        /// <returns>
        /// The method whose invocation will invoke <paramref name="method" />
        /// with the <paramref name="firstArguments" /> as its parameters.
        /// </returns>
        public static IEnumerable<Action<T2, T3>> Bind<T1, T2, T3>(this Action<T1, T2, T3> method, IEnumerable<T1> firstArguments)
        {
            return firstArguments.Select<T1, Action<T2, T3>>(method.Bind);
        }

        /// <summary>
        /// Creates a composite method that, when invoked, invokes other methods.
        /// </summary>
        /// <param name="actions">The methods to combine into a single composite
        /// method.</param>
        /// <returns>The composite method.</returns>
        public static Action Combine(this IEnumerable<Action> actions)
        {
            return () => actions.For(action => action());
        }

        /// <summary>
        /// Converts a single method taking many arguments to many methods each
        /// taking one argument, such that, when the returned method are all
        /// invoked, <paramref name="callback"/> will be invoked with all of the
        /// items passed to the returned methods.
        /// </summary>
        /// <typeparam name="T">The type taken by the methods.</typeparam>
        /// <param name="callback">The callback to be invoked once all of the 
        ///     return methods have been invoked..</param>
        /// <param name="count">The number of items to collect before 
        ///     <paramref name="callback"/> is invoked.</param>
        /// <returns>The methods to invoke to invoke <paramref name="callback"/>.</returns>
        public static IEnumerable<Action<T>> AsMany<T>(this Action<IEnumerable<T>> callback, int count)
        {
            var values = new T[count];
            var valuesResolved = 0;

            return values.Select<T, Action<T>>((o, index) => value =>
            {
                values[index] = value;

                // Invoke the callback once all values have been resolved.
                if (Interlocked.Increment(ref valuesResolved) == count)
                {
                    callback(values);
                    valuesResolved = 0;
                }
            });
        }

        /// <summary>
        /// Converts many methods taking a single argument to one method taking
        /// many arguments, such that, when the returned method is invoked, all
        /// of the provided <paramref name="methods"/> are invoked.
        /// </summary>
        /// <typeparam name="T">The type taken by the methods.</typeparam>
        /// <param name="methods">The methods to invoke when the returned method
        /// is invoked.</param>
        /// <returns>The method to invoke when invoking <paramref name="methods"/>.</returns>
        public static Action<IEnumerable<T>> AsOne<T>(this IEnumerable<Action<T>> methods)
        {
            return items => methods.Zip(items).For(pair => pair.First(pair.Second));
        }

        /// <summary>
        /// Converts a method taking one argument into a method that can take 
        /// many of the same argument type.
        /// </summary>
        /// <typeparam name="T">The type taken by the <paramref name="method"/>.</typeparam>
        /// <param name="method">The method to convert.</param>
        /// <returns>The method to whose invocation invokes <paramref name="method"/>
        /// once for each item.</returns>
        public static Action<IEnumerable<T>> AsManyArgumented<T>(this Action<T> method)
        {
            return items => items.For(method);
        }

        /// <summary>
        /// Invokes the specified methods, passing in the provided method.
        /// </summary>
        public static void Invoke(this IEnumerable<Action> actions)
        {
            actions.For(action => action());
        }

        /// <summary>
        /// Invokes the specified methods, passing in the provided method.
        /// </summary>
        /// <typeparam name="T">The type expected by the method.</typeparam>
        /// <param name="actions">The methods to invoke.</param>
        /// <param name="param1">The parameter to pass to the methods.</param>
        public static void Invoke<T>(this IEnumerable<Action<T>> actions, T param1)
        {
            actions.For(action => action(param1));
        }

        /// <summary>
        /// Returns a method that casts the parameter before passing it to the
        /// method provided.
        /// </summary>
        /// <typeparam name="TTo">The type to cast the parameter to and pass to
        /// the method provided.</typeparam>
        /// <param name="action">The method to invoke after the cast.</param>
        /// <returns>The method that, when invoked, invokes <paramref name="action"/>
        /// with its parameter casted.</returns>
        public static Action<object> Cast<TTo>(this Action<TTo> action)
        {
            return instance => action((TTo)instance);
        }
    }
}