using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Event;
using Chernobyl.Utility;
using Chernobyl.Values;

namespace Chernobyl.Reflection
{
    /// <summary>
    /// Represents the value of a return parameter on a method or constructor.
    /// </summary>
    /// <typeparam name="T">The return type of the method to be called.</typeparam>
    public class ReturnValue<T> : HeldValue<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ReturnValue{T}"/> class
        /// whose <paramref name="method"/> is static and takes no parameters.
        /// </summary>
        /// <param name="method">The method or constructor to invoke to 
        /// retrieve the return value.</param>
        public ReturnValue(MethodBase method)
            : this(method, DecoratingEventEnumerable<IValue<Object>>.Empty)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="ReturnValue{T}"/> class
        /// whose <paramref name="method"/> is static.
        /// </summary>
        /// <param name="method">The method or constructor to invoke to 
        /// retrieve the return value.</param>
        /// <param name="parameters">An argument list for the invoked method or 
        /// constructor. This is an sequence of objects with the same number, 
        /// order, and type as the parameters of the method or constructor to be 
        /// invoked. If there are no parameters, this should be null. If the 
        /// method or constructor represented by this instance takes a ByRef 
        /// parameter, there is no special attribute required for that parameter 
        /// in order to invoke the method or constructor using this function. 
        /// Any object in this array that is not explicitly initialized with a 
        /// value will contain the default value for that object type. For 
        /// reference-type elements, this value is null. For value-type elements, 
        /// this value is 0, 0.0, or false, depending on the specific element type.</param>
        public ReturnValue(MethodBase method,
                           IEventEnumerable<IValue<Object>> parameters)
            : this(Values.Value.Null<Object>(), method, parameters)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="ReturnValue{T}"/> class.
        /// </summary>
        /// <param name="instance">The <see cref="IValue{T}"/> containing the 
        /// object on which to invoke the method or constructor. If a method is 
        /// static, this argument is ignored. If a constructor is static, the
        /// instance contained within the <see cref="IValue{T}"/> must be null 
        /// or an instance of the class that defines the constructor.</param>
        /// <param name="method">The method or constructor to invoke to 
        /// retrieve the return value.</param>
        /// <param name="parameters">An argument list for the invoked method or 
        /// constructor. This is an sequence of objects with the same number, 
        /// order, and type as the parameters of the method or constructor to be 
        /// invoked. If there are no parameters, this should be null. If the 
        /// method or constructor represented by this instance takes a ByRef 
        /// parameter, there is no special attribute required for that parameter 
        /// in order to invoke the method or constructor using this function. 
        /// Any object in this array that is not explicitly initialized with a 
        /// value will contain the default value for that object type. For 
        /// reference-type elements, this value is null. For value-type elements, 
        /// this value is 0, 0.0, or false, depending on the specific element type.</param>
        public ReturnValue(IValue<Object> instance,
                           MethodBase method,
                           IEventEnumerable<IValue<Object>> parameters)
            : this(instance, method, BindingFlags.Default, null, 
                   parameters, null)
        {}

        /// <summary>
        /// Initializes a new instance of the <see cref="ReturnValue{T}"/> class.
        /// </summary>
        /// <param name="instance">The <see cref="IValue{T}"/> containing the 
        /// object on which to invoke the method or constructor. If a method is 
        /// static, this argument is ignored. If a constructor is static, the
        /// instance contained within the <see cref="IValue{T}"/> must be null 
        /// or an instance of the class that defines the constructor.</param>
        /// <param name="method">The method or constructor to invoke to retrieve 
        /// the return value.</param>
        /// <param name="invokeAttributes">A bitmask that is a combination of 0 
        /// or more bit flags from <see cref="BindingFlags"/>. If binder is 
        /// null, this parameter is assigned the value 
        /// <see cref="BindingFlags.Default"/>; thus, whatever you pass in is 
        /// ignored.</param>
        /// <param name="binder">An object that enables the binding, coercion of 
        /// argument types, invocation of members, and retrieval of 
        /// <see cref="MemberInfo"/> objects via reflection. If binder is null, 
        /// the default binder is used.</param>
        /// <param name="parameters">An argument list for the invoked method or 
        /// constructor. This is an sequence of objects with the same number, 
        /// order, and type as the parameters of the method or constructor to be 
        /// invoked. If there are no parameters, this should be null. If the 
        /// method or constructor represented by this instance takes a ByRef 
        /// parameter, there is no special attribute required for that parameter 
        /// in order to invoke the method or constructor using this function. 
        /// Any object in this array that is not explicitly initialized with a 
        /// value will contain the default value for that object type. For 
        /// reference-type elements, this value is null. For value-type elements, 
        /// this value is 0, 0.0, or false, depending on the specific element type.</param>
        /// <param name="culture">An instance of <see cref="CultureInfo"/> used 
        /// to govern the coercion of types. If this is null, the CultureInfo 
        /// for the current thread is used. (This is necessary to convert a 
        /// <see cref="String"/> that represents 1000 to a Double value, for 
        /// example, since 1000 is represented differently by different cultures.)</param>
        public ReturnValue(IValue<Object> instance, 
                           MethodBase method, 
                           BindingFlags invokeAttributes,
                           Binder binder,
                           IEventEnumerable<IValue<Object>> parameters,
                           CultureInfo culture)
        {
            instance.ThrowIfNull("instance");
            method.ThrowIfNull("method");
            parameters.ThrowIfNull("parameters");

            _instance = instance;
            _method = method;
            _invokeAttributes = invokeAttributes;
            _binder = binder;
            _parameters = parameters;
            _culture = culture;

            // Create a Composite<T> which consists of the instance to invoke
            // the method on as the first value and the parameters making up the
            // rest of the collection. This Composite<T> will make accessing the
            // values easier.
            var instanceList = new DecoratingEventList<IValue<Object>>(new[] {_instance});
            _instanceAndParameters = instanceList.Concat(_parameters).AsValues();
        }

        /// <summary>
        /// Updates the value contained within this <see cref="IValue{T}"/>.
        /// Invokes the method whose return value this instance represents and
        /// stores that return value, invoking <see cref="IValue{T}.Provide"/>
        /// when the value has been set.
        /// </summary>
        public void Update()
        {
            // Make sure we have the instance to invoke on and the parameters.
            if (_instanceAndParameters.Count() == (_parameters.Count() + 1))
            {
                // Grab the instance to invoke the method on and the parameters. The
                // instance will be the first parameter in _instanceAndParametersValues.
                Object instance = _instanceAndParameters.First();
                Object[] parameters = _instanceAndParameters.Skip(1).ToArray();

                Value = (T)_method.Invoke(instance, _invokeAttributes, _binder, 
                                          parameters, _culture);
            }
        }

        /// <summary>
        /// Invoked when <see cref="BasicValue{T}.IsNeeded" /> is changed to true.
        /// Implementations of this method should invoke the base class method.
        /// </summary>
        protected override void Needed()
        {
            Update();

            _instanceAndParameters.ItemsAdded += Update;
            _instanceAndParameters.ItemsRemoved += Update;

            base.Needed();
        }

        /// <summary>
        /// Invoked when <see cref="BasicValue{T}.IsNeeded" /> is changed to false.
        /// Implementations of this method should invoke the base class method.
        /// </summary>
        protected override void NotNeeded()
        {
            _instanceAndParameters.ItemsAdded -= Update;
            _instanceAndParameters.ItemsRemoved -= Update;

            base.NotNeeded();
        }

        /// <summary>
        /// Invoked when items are added to or removed from 
        /// <see cref="_instanceAndParameters"/>. This method just invokes
        /// <see cref="Update()"/>.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="ItemsEventArgs{Object}"/> instance 
        /// containing the event data.</param>
        void Update(object sender, ItemsEventArgs<object> e)
        {
            Update();
        }

        /// <summary>
        /// The <see cref="IValue{T}"/> containing the 
        /// object on which to invoke the method or constructor. If a method is 
        /// static, this argument is ignored. If a constructor is static, the
        /// instance contained within the <see cref="IValue{T}"/> must be null 
        /// or an instance of the class that defines the constructor.
        /// </summary>
        readonly IValue<Object> _instance;

        /// <summary>
        /// The method or constructor to invoke to retrieve the return value.
        /// </summary>
        readonly MethodBase _method;

        /// <summary>
        /// A bitmask that is a combination of 0 
        /// or more bit flags from <see cref="BindingFlags"/>. If binder is 
        /// null, this parameter is assigned the value 
        /// <see cref="BindingFlags.Default"/>; thus, whatever you pass in is 
        /// ignored.
        /// </summary>
        readonly BindingFlags _invokeAttributes;

        /// <summary>
        /// An object that enables the binding, coercion of 
        /// argument types, invocation of members, and retrieval of 
        /// <see cref="MemberInfo"/> objects via reflection. If binder is null, 
        /// the default binder is used.
        /// </summary>
        readonly Binder _binder;

        /// <summary>
        /// An argument list for the invoked method or 
        /// constructor. This is an sequence of objects with the same number, 
        /// order, and type as the parameters of the method or constructor to be 
        /// invoked. If there are no parameters, this should be null. If the 
        /// method or constructor represented by this instance takes a ByRef 
        /// parameter, there is no special attribute required for that parameter 
        /// in order to invoke the method or constructor using this function. 
        /// Any object in this array that is not explicitly initialized with a 
        /// value will contain the default value for that object type. For 
        /// reference-type elements, this value is null. For value-type elements, 
        /// this value is 0, 0.0, or false, depending on the specific element type.
        /// </summary>
        readonly IEventEnumerable<IValue<Object>> _parameters;

        /// <summary>
        /// An instance of <see cref="CultureInfo"/> used 
        /// to govern the coercion of types. If this is null, the CultureInfo 
        /// for the current thread is used. (This is necessary to convert a 
        /// <see cref="String"/> that represents 1000 to a Double value, for 
        /// example, since 1000 is represented differently by different cultures.)
        /// </summary>
        readonly CultureInfo _culture;

        /// <summary>
        /// A composite of <see cref="_instance"/> as the first instance in the
        /// <see cref="IEventEnumerable{T}"/> (if applicable) and the 
        /// <see cref="_parameters"/> following (if applicable).
        /// </summary>
        readonly IEventEnumerable<Object> _instanceAndParameters;
    }
}