using System;
using System.Reflection;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Event;
using Chernobyl.Utility;

namespace Chernobyl.Dependency
{
    /// <summary>
    /// Used to mark an instance that needs to be retrieved from an 
    /// <see cref="IEventEnumerable"/> instance. When this <see cref="InjectAttribute"/> 
    /// instance has it's 
    /// <see cref="InjectAttribute.Resolve(IEventCollection{object}, object, ICustomAttributeProvider)"/>
    /// method invoked, it will take the instance from  the <see cref="IEventEnumerable"/> 
    /// provided but only if that instance exists. Otherwise the property will 
    /// set the instance when it receives that instance.
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
    public class InjectAttribute : ServiceAttribute
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ServiceAttribute"/> 
        /// class.
        /// </summary>
        public InjectAttribute()
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="ServiceAttribute"/> 
        /// class.
        /// </summary>
        /// <param name="location">The location of the service within the
        /// <see cref="IEventEnumerable"/> hierarchy or an empty array if the service 
        /// is at the root of the hierarchy. This <see cref="Type"/> array 
        /// represents the  "path" that must be taken through the hierarchy of 
        /// <see cref="IEventEnumerable"/> to get to the location where the service 
        /// specified by <see cref="Type"/> resides. Each 
        /// <see cref="Type"/> must implement the <see cref="IEventEnumerable"/> 
        /// interface. An example of what the service path might look like 
        /// (using '/' as separators):
        /// <example>/IEventEnumerable/IGraphicsServices/ITextureServices</example>
        /// In this example, the service represented by <see cref="Type"/>
        /// is located in the <see cref="IEventEnumerable"/> ITextureServices. That 
        /// <see cref="IEventEnumerable"/> is located within IGraphicsServices which 
        /// is located at the root <see cref="IEventEnumerable"/>.</param>
        public InjectAttribute(params Type[] location)
            : base(location)
        { }

        /// <summary>
        /// Retrieves the service from the <paramref name="services"/> instance
        /// and passes it to the <paramref name="attributeProvider"/> provided.
        /// </summary>
        /// <param name="services">The instance that allows access to the other 
        /// services and provides adding or removing of specific services.</param>
        /// <param name="instance">The instance that contained a code element that
        /// was attributed with a <see cref="InjectAttribute"/> instance.</param>
        /// <param name="attributeProvider">The code element that was attributed
        /// with a <see cref="InjectAttribute"/> and whose service needs to be
        /// added into the .</param>
        public override void Resolve(IEventCollection<Object> services, object instance, ICustomAttributeProvider attributeProvider)
        {
            services.ThrowIfNull("services");

            if (attributeProvider != null)
            {
                _property = (PropertyInfo)attributeProvider;
                SetValue = SetValue ?? _property.SetValue;
                Type = Type ?? _property.PropertyType;
            }

            if (SetValue == null)
                throw new Exception("A method to set the code element was not " +
                "found. You must either provide a non-null " +
                typeof(ICustomAttributeProvider).Name + " value to the " +
                "Resolve(" + typeof(IEventEnumerable).Name + ", object, " +
                typeof(ICustomAttributeProvider).Name + ") method or you must " +
                "set the InjectAttribute.SetValue property explicitly.");

            if (Type == null)
                throw new Exception("The type to inject was not found. found. " +
                "You must either provide a non-null " +
                typeof(ICustomAttributeProvider).Name + " value to the " +
                "Resolve(" + typeof(IEventEnumerable).Name + ", object, " +
                typeof(ICustomAttributeProvider).Name + ") method or you must " +
                "set the InjectAttribute.Type property explicitly.");

            _instance = instance;

            // We need to move 
            Type nextServiceType = Type;
            if (Location.Length != 0)
                nextServiceType = Location[0];

            services.OfType(nextServiceType, ServiceRetriever);
        }

        /// <summary>
        /// The method that sets the value on the property. By default, this is
        /// set to the <see cref="PropertyInfo.SetValue(object, object, object[])"/>
        /// method of the <see cref="PropertyInfo"/> passed into 
        /// <see cref="Resolve(IEventCollection{Object}, object, ICustomAttributeProvider)"/>
        /// as the <see cref="ICustomAttributeProvider"/>. The first parameter 
        /// is the instance on which the <see cref="ICustomAttributeProvider"/>
        /// belongs. The second parameter is the service being set. The third 
        /// parameter is the index values for index properties.
        /// </summary>
        public Action<object, object, object[]> SetValue { get; set; }

        /// <summary>
        /// The method that is invoked when the service of the type specified by
        /// <see cref="Type" /> is resolved and can be used.
        /// </summary>
        /// <param name="service">The service that was requested.</param>
        void ServiceRetriever(object service)
        {
            if (_currentLocationIndex == Location.Length)
                SetValue(_instance, service, null);
            else
            {
                IEventEnumerable services = (IEventEnumerable)service;

                // If we we've reached the last Type in the location path
                // then we are at the IEventEnumerable that contains the type that we
                // need. In that case, we'll just request the Type rather than 
                // the next IEventEnumerable instance in the location path.
                ++_currentLocationIndex;
                Type nextServiceType = Type;
                if(_currentLocationIndex < Location.Length)
                    nextServiceType = Location[_currentLocationIndex];

                services.OfType(nextServiceType).First(ServiceRetriever);
            }
        }

        /// <summary>
        /// The index into the <see cref="ServiceAttribute.Location"/> array
        /// that points to the <see cref="Type"/> we are currently processing
        /// in <see cref="ServiceRetriever(object)"/>.
        /// </summary>
        int _currentLocationIndex;

        /// <summary>
        /// The property that was attributed with this attribute.
        /// </summary>
        PropertyInfo _property;

        /// <summary>
        /// The instance that whose type was attributed with this attribute.
        /// </summary>
        object _instance;
    }
}