using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Chernobyl.Attribution;
using Chernobyl.Collections.Generic;
using Chernobyl.Reflection;

namespace Chernobyl.Extensions
{
    /// <summary>
    /// Extensions and utility methods for <see cref="IKeyAttribute"/> and
    /// related types.
    /// </summary>
    public static class KeyAttribute
    {
        /// <summary>
        /// Retrieves the values of the parameter using the find method provided.
        /// </summary>
        /// <param name="parameter">The parameter to locate values for.</param>
        /// <param name="find">The method used to locate the parameters.</param>
        /// <param name="callback">The method to invoke when the parameters have
        /// been found.</param>
        public static void GetValues(this ParameterInfo parameter,
                                    Find<Object, Object> find,
                                    Callback<IEnumerable<Object>> callback)
        {
            find.FindMany(parameter.GetKeys(), callback);
        }

        /// <summary>
        /// Retrieves the value of the parameter using the find method provided.
        /// </summary>
        /// <param name="parameter">The parameter to locate value for.</param>
        /// <param name="find">The method used to locate the parameter.</param>
        /// <param name="callback">The method to invoke when the parameters have
        /// been found.</param>
        public static void GetValue(this ParameterInfo parameter,
                                    Find<Object, Object> find,
                                    Callback<Object> callback)
        {
            parameter.GetValues(find, values =>
            {
                values.Duplicated()
                      .DefaultIfEmpty(values.First)
                      .To(callback.AsAction());
            });
        }

        /// <summary>
        /// Retrieves the values of the parameters using the find method provided.
        /// </summary>
        /// <param name="parameters">The parameters to locate values for.</param>
        /// <param name="find">The method used to locate the parameters.</param>
        /// <param name="callback">The method to invoke when the parameters have
        /// been found.</param>
        public static void GetValues(this IEnumerable<ParameterInfo> parameters,
                                     Find<ParameterInfo, Object> find,
                                     Callback<IEnumerable<Object>> callback)
        {
            find.FindMany(parameters, callback);
        }

        /// <summary>
        /// Returns the static, void return methods that are attributed with a
        /// <see cref="IKeyAttribute"/>.
        /// </summary>
        /// <param name="type">The type to look in for the methods.</param>
        /// <returns>The static, void return methods mapped to their keys.</returns>
        public static IEnumerable<KeyValuePair<Object, Action>> GetActions(this Type type)
        {
            Func<MethodInfo, IEnumerable<KeyValuePair<Object, Action>>> selector =
                method => method.GetCustomAttributes(typeof(IKeyAttribute), true)
                                .Cast<IKeyAttribute>()
                                .Select(attr => new KeyValuePair<Object, Action>(
                                                attr.Key, () => method.Invoke(null, Array<Object>.Empty)));

            // Grab static methods that have no parameters.
            return type.GetMethods()
                       .Where(method => method.IsStatic &&
                              method.GetParameters().IsEmpty() &&
                              method.ReturnType == typeof(void))
                       .SelectMany(selector);
        }

        /// <summary>
        /// Returns the static, void return methods that are attributed with a
        /// <see cref="IKeyAttribute"/>.
        /// </summary>
        /// <param name="assembly">The <see cref="Assembly"/> to look in for the
        /// methods.</param>
        /// <returns>The static, void return methods mapped to their keys.</returns>
        public static IEnumerable<KeyValuePair<Object, Action>> GetActions(this Assembly assembly)
        {
            return assembly.GetTypes().SelectMany(type => type.GetActions());
        }

        /// <summary>
        /// Retrieves methods that provide the callback with the return values of
        /// any static, parameterless methods whose return value has been mapped
        /// to keys using <see cref="IKeyAttribute"/> and returns the value.
        /// </summary>
        /// <param name="type">The <see cref="Type"/> to search for keyed values.</param>
        /// <returns>The items held in methods mapped to the keys.</returns>
        public static IEnumerable<KeyValuePair<object, Action<Action<Object>>>> GetLocators(
            this Type type)
        {
            IDictionary<object, Action<Action<Object>>> items =
                new Dictionary<object, Action<Action<Object>>>();

            // Grab static methods that have no parameters.
            var staticMethods = type.GetMethods()
                                    .Where(method => method.IsStatic &&
                                           method.GetParameters().IsEmpty() &&
                                           method.ReturnType != typeof(void));

            // Go through the methods and add them to the dictionary.
            foreach (var method in staticMethods)
            {
                var keyAttribute = (IKeyAttribute)method.ReturnParameter
                                                        .GetCustomAttribute(typeof(IKeyAttribute), true);
                if (keyAttribute != null)
                {
                    var methodInfo = method;
                    items.Add(keyAttribute.Key,
                              callback => callback(methodInfo.Invoke(null, Array<Object>.Empty)));
                }
            }

            return items;
        }

        /// <summary>
        /// Retrieves methods that provide the callback with the return values of
        /// any static, parameterless methods whose return value has been mapped
        /// to keys using <see cref="IKeyAttribute"/> and returns the value.
        /// </summary>
        /// <param name="assembly">The <see cref="Assembly"/> to search for keyed
        /// values.</param>
        /// <returns>The items held in methods mapped to the keys.</returns>
        public static IEnumerable<KeyValuePair<object, Action<Action<Object>>>> GetLocators(
            this Assembly assembly)
        {
            return assembly.GetTypes().SelectMany(type => type.GetLocators());
        }

        /// <summary>
        /// Retrieves methods that, when invoked, invoke any
        /// static, parameterless methods whose return value has been mapped to
        /// keys using <see cref="IKeyAttribute"/> and returns the value.
        /// </summary>
        /// <param name="type">The <see cref="Type"/> to search for keyed values.</param>
        /// <returns>The items held in methods mapped to the keys.</returns>
        public static IEnumerable<KeyValuePair<object, Func<object>>> GetKeyedValues(
            this Type type)
        {
            IDictionary<object, Func<object>> items =
                new Dictionary<object, Func<object>>();

            // Grab static methods that have no parameters.
            var staticMethods = type.GetMethods()
                                    .Where(method => method.IsStatic &&
                                           method.GetParameters().IsEmpty() &&
                                           method.ReturnType != typeof(void));

            // Go through the methods and add them to the dictionary.
            foreach (var method in staticMethods)
            {
                var keyAttribute = (IKeyAttribute)method.ReturnParameter
                                                        .GetCustomAttribute(typeof(IKeyAttribute), true);
                if (keyAttribute != null)
                {
                    var methodInfo = method;
                    items.Add(keyAttribute.Key,
                              () => methodInfo.Invoke(null, Array<Object>.Empty));
                }
            }

            return items;
        }

        /// <summary>
        /// Retrieves methods that, when invoked, invoke any
        /// static, parameterless methods whose return value has been mapped to
        /// keys using <see cref="IKeyAttribute"/> and returns the value.
        /// </summary>
        /// <param name="assembly">The <see cref="Assembly"/> to search for keyed
        /// values.</param>
        /// <returns>The items held in methods mapped to the keys.</returns>
        public static IEnumerable<KeyValuePair<object, Func<object>>> GetKeyedValues(this Assembly assembly)
        {
            return assembly.GetTypes().SelectMany(type => type.GetKeyedValues());
        }

        /// <summary>
        /// Retrives the keys that have been attributed on the
        /// <see cref="ICustomAttributeProvider"/> using the
        /// <see cref="IKeyAttribute"/>.
        /// </summary>
        /// <param name="provider">The instance attributed with
        /// <see cref="IKeyAttribute"/>.</param>
        public static IEnumerable<Object> GetKeys(this ICustomAttributeProvider provider)
        {
            return provider.GetCustomAttributes<IKeyAttribute>(true)
                           .Select(attr => attr.Key);
        }
    }
}