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

namespace Chernobyl.Dependency
{
    /// <summary>
    /// An <see cref="Attribute"/> that retrieves the value of a parameter that 
    /// is attributed with an <see cref="IKeyAttribute"/>. If the parameter 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 used to retrieve the parameter.
    /// Otherwise, the parameter will be taken from an <see cref="StaticStorageAttribute"/>.
    /// </summary>
    [AttributeUsage(AttributeTargets.Parameter)]
    public class GetAttribute : Attribute, IGetAttribute<ParameterInfo>
    {
        /// <summary>
        /// Returns the value of the specified attribute provider. The attribute
        /// provider must be the instance that this
        /// <see cref="IGetAttribute{TCustomAttributeProvider}" /> was attributing.
        /// </summary>
        /// <param name="attributeProvider">The instance this
        /// <see cref="IGetAttribute{TCustomAttributeProvider}" /> was
        /// attributing.</param>
        /// <returns>
        /// The value of the requested item.
        /// </returns>
        public IValue<object> Get(ICustomAttributeProvider attributeProvider)
        {
            var parameterInfo = attributeProvider.Require<ParameterInfo>();

            // Grab the storage containers for this parameter.
            var storages = attributeProvider
                .GetCustomAttributes<IStorageAttribute<Object, IValue<Object>>>(true)
                .DefaultIfEmpty(StaticStorageAttribute.Default).ToArray();

            if (storages.Length > 1)
            {
                Type storageType = typeof (IStorageAttribute<Object, IValue<Object>>);
                throw new ParameterException("The attribute provider \"" + attributeProvider +
                                             "\" is attributed with more than one " +
                                             storageType + " instance. " + typeof(GetAttribute) +
                                             " does not currently support more than " +
                                             "one storage instance. Please ensure that all instances " +
                                             "are attributed with only one " + storageType, 
                                             parameterInfo.ToEnumerable());
            }

            // Grab the key for this parameter.
            var storage = storages.First();
            var keyAttributes = attributeProvider
                .GetCustomAttributes<IKeyAttribute>(true)
                .ToArray();
            if(keyAttributes.Length == 0)
                throw new ParameterException("Unable to retrieve the parameter \"" +
                                             attributeProvider + "\" as it is not " +
                                             "attributed with a \"" + typeof(IKeyAttribute) +
                                             "\".", parameterInfo.ToEnumerable());
            if (keyAttributes.Length > 1)
                throw new ParameterException("Unable to retrieve the parameter \"" +
                                             attributeProvider + "\" as it is attributed " +
                                             "with more than one \"" + typeof(IKeyAttribute) +
                                             "\". GetAttribute cannot choose between the keys.",
                                             parameterInfo.ToEnumerable());
            var keyAttribute = keyAttributes.First();

            // Grab the IValue<T> parameter from the store.
            IValue<Object> parameter;
            if (storage.Container.TryGetValue(keyAttribute.Key, out parameter) == false)
            {
                // The parameter was not in the Store so we'll wait for it
                // to be added.
                var sourceParameter = new SourceValue<object>();

                EventHandler<ItemsEventArgs<KeyValuePair<Object, IValue<Object>>>> itemsAdded = null;
                itemsAdded = (sender, e) =>
                {
                    var keyValues =
                        e.Items.Where(pair => pair.Key.Equals(keyAttribute.Key));
                    if (keyValues.Any())
                    {
                        sourceParameter.Source = keyValues.First().Value;

                        // The item has been added, we no longer need to
                        // listen for addition of items.                            
                        storage.Container.ItemsAdded -= itemsAdded;

                        // We don't worry about the items being remove from
                        // the container for now. In the future we may want
                        // to add functionality to support removal and re-adding.
                    }
                };
                storage.Container.ItemsAdded += itemsAdded;

                parameter = sourceParameter;
            }

            return parameter;
        }

        /// <summary>
        /// Returns the value of the specified attribute provider. The attribute
        /// provider must be the instance that this
        /// <see cref="IGetAttribute{TCustomAttributeProvider}" /> was attributing.
        /// </summary>
        /// <param name="parameterInfo">The instance this
        /// <see cref="IGetAttribute{TCustomAttributeProvider}" /> was
        /// attributing.</param>
        /// <returns>The value of the requested item.</returns>
        public IValue<object> Get(ParameterInfo parameterInfo)
        {
            return Get((ICustomAttributeProvider)parameterInfo);
        }
    }
}