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

namespace Chernobyl.Dependency
{
    /// <summary>
    /// An <see cref="Attribute"/> that stores the return value of a static
    /// method. If the return value is attributed with an 
    /// <see cref="IStorageAttribute{TKey, TValue}"/> whose key is an
    /// <see cref="Object"/> and whose value is an <see cref="IValue{T}"/>
    /// holding an object, then that instance will be uesd to store the return
    /// value. Otherwise, the return value will be stored in an 
    /// <see cref="StaticStorageAttribute"/>. If the return value is attributed 
    /// with <see cref="IKeyAttribute"/> instances then the 
    /// <see cref="IKeyAttribute.Key"/> of each <see cref="IKeyAttribute"/> is 
    /// used as the key to store and retrieve the value (the return value is 
    /// stored once per key). Note that the static method is not invoked immediately 
    /// to extract the return value; it is invoked when the value is requested.
    /// </summary>
    [AttributeUsage(AttributeTargets.ReturnValue)]
    public class SetAttribute : Attribute, IProcessAttribute<ParameterInfo>
    {
        /// <summary>
        /// Performs the task requested on the <see cref="ICustomAttributeProvider"/> 
        /// passed in.
        /// </summary>
        /// <param name="returnParameter">The <see cref="ICustomAttributeProvider"/>  
        /// this <see cref="Attribute"/> was applied to and that is to be
        /// processed.</param>
        public void Process(ParameterInfo returnParameter)
        {
            IValue<object> value = returnParameter.ToReturnValue();

            // Grab the key to store the items.
            var keyAttributes = returnParameter.GetCustomAttributes(typeof(IKeyAttribute), true)
                                               .Cast<IKeyAttribute>();
            if (keyAttributes.Any())
            {
                // Grab the storage containers to store the instance in.
                var storages = returnParameter
                    .GetCustomAttributes(typeof(IStorageAttribute<Object, IValue<Object>>), true)
                    .Cast<IStorageAttribute<Object, IValue<Object>>>()
                    .DefaultIfEmpty(StaticStorageAttribute.Default);

                // Store the value in the storages using the key.
                foreach (IKeyAttribute keyAttribute in keyAttributes)
                    foreach (var storage in storages)
                        storage.Container.Add(keyAttribute.Key, value);
            }
            else
                throw new MethodException(
                    String.Format("Unable to store the result of the return " +
                                  "parameter '{0}' on the member '{1}' as the " +
                                  "return parameter is not attributed with a " +
                                  "'{2}'. ", returnParameter, returnParameter.Member,
                                  typeof(IKeyAttribute)),
                                  ((MethodBase)returnParameter.Member).ToEnumerable());
        }
    }
}