using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Developpez.Dotnet.Reflection;
#if SILVERLIGHT
using Developpez.Dotnet.Collections;
#endif

namespace Developpez.Dotnet
{
    /// <summary>
    /// Implémente un évènement qui ne garde qu'une référence faible vers ses handlers,
    /// de façon à éviter les fuites mémoire.
    /// </summary>
    /// <typeparam name="TEventHandler">Type du delegate de l'évènement</typeparam>
    public class WeakEvent<TEventHandler>
    {
// ReSharper disable StaticFieldInGenericType
        private static readonly MethodInfo _invokeMethod;
// ReSharper restore StaticFieldInGenericType

        private static readonly Func<WeakEvent<TEventHandler>, TEventHandler> _raiseDelegateGenerator;
        private readonly TEventHandler _raiseDelegate;

        private readonly List<WeakDelegate<TEventHandler>> _handlers;

        static WeakEvent()
        {
            if (!typeof(TEventHandler).Is<MulticastDelegate>())
                throw new ArgumentException("The type parameter must be a delegate type");

#if NETFX_CORE
            _invokeMethod = typeof (TEventHandler).GetTypeInfo().GetDeclaredMethod("Invoke");
#else
            _invokeMethod = typeof(TEventHandler).GetMethod("Invoke");
#endif
            var invokeParameters =
                _invokeMethod.GetParameters()
                .Select(p => Expression.Parameter(p.ParameterType, p.Name))
                .ToArray();
            var raiseParams =
                Expression.NewArrayInit(
                    typeof(object),
                    invokeParameters.AsEnumerable<Expression>());

#if NETFX_CORE
            var raiseMethod = typeof (WeakDelegate<TEventHandler>).GetTypeInfo().GetDeclaredMethod("RaiseInternal");
#else
            var raiseMethod = typeof(WeakEvent<TEventHandler>).GetMethod("RaiseInternal", BindingFlags.NonPublic | BindingFlags.Instance);
#endif

            var tWeakEvent = typeof(WeakEvent<TEventHandler>);
            var weakEventParam = Expression.Parameter(tWeakEvent, "weakEvent");

// ReSharper disable PossiblyMistakenUseOfParamsMethod
            Expression callExpr =
                Expression.Call(
                    weakEventParam,
                    raiseMethod,
                    raiseParams);
// ReSharper restore PossiblyMistakenUseOfParamsMethod

            if (_invokeMethod.ReturnType != typeof(void))
            {
                callExpr = Expression.Convert(callExpr, _invokeMethod.ReturnType);
            }

            var raiseExpr =
                Expression.Lambda<TEventHandler>(
                    callExpr,
                    invokeParameters);

            var generatorExpr =
                Expression.Lambda<Func<WeakEvent<TEventHandler>, TEventHandler>>(
                    raiseExpr,
                    weakEventParam);

            _raiseDelegateGenerator = generatorExpr.Compile();
        }

        /// <summary>
        /// Initialise une nouvelle instance de <see cref="WeakEvent{TEventHandler}" />
        /// </summary>
        public WeakEvent()
        {
            _raiseDelegate = _raiseDelegateGenerator(this);
            _handlers = new List<WeakDelegate<TEventHandler>>();
        }

        /// <summary>
        /// Ajoute un handler à l'évènement
        /// </summary>
        /// <param name="handler">Le handler à ajouter</param>
        public virtual void AddHandler(TEventHandler handler)
        {
            Delegate d = (Delegate)(object)handler;
            _handlers.Add(new WeakDelegate<TEventHandler>(d));
        }

        /// <summary>
        /// Retire un handler de l'évènement
        /// </summary>
        /// <param name="handler">Le handler à retirer</param>
        public virtual void RemoveHandler(TEventHandler handler)
        {
            // also remove "dead" (garbage collected) handlers
            _handlers.RemoveAll(wd => !wd.IsAlive || wd.Equals(handler));
        }

        /// <summary>
        /// Renvoie un delegate qui déclenche l'évènement en appelant tous les handlers encore actifs
        /// </summary>
        public TEventHandler Raise
        {
            get { return _raiseDelegate; }
        }

        internal object RaiseInternal(params object[] args)
        {
            var handlers = _handlers.ToArray();
            object result = _invokeMethod.ReturnType.GetDefaultValue();
            foreach (var weakDelegate in handlers)
            {
                result = weakDelegate.Invoke(args);
                if (!weakDelegate.IsAlive)
                    _handlers.Remove(weakDelegate);
            }
            return result;
        }
    }
}