using System;
using System.Reflection;
using Developpez.Dotnet.Reflection;

namespace Developpez.Dotnet
{
    /// <summary>
    /// Permet de référencer faiblement un delegate
    /// </summary>
    /// <typeparam name="TDelegate">Type de delegate</typeparam>
    public class WeakDelegate<TDelegate> : IEquatable<TDelegate>
    {
        private readonly WeakReference _targetReference;
        private readonly MethodInfo _method;

        /// <summary>
        /// Initialise une nouvelle instance de <see cref="WeakDelegate{TDelegate}"/> avec le delegate spécifié.
        /// </summary>
        /// <param name="realDelegate">Le delegate pour lequel créer une référence faible</param>
        public WeakDelegate(Delegate realDelegate)
        {
            _targetReference = realDelegate.Target != null
                ? new WeakReference(realDelegate.Target)
                : null;
#if NETFX_CORE
            _method = realDelegate.GetMethodInfo();
#else
            _method = realDelegate.Method;
#endif

        }

        /// <summary>
        /// Obtient le delegate englobé par cette référence faible
        /// </summary>
        /// <returns>Le delegate englobé par cette référence faible</returns>
        public TDelegate GetDelegate()
        {
            return (TDelegate)(object)GetDelegateInternal();
        }

#if NETFX_CORE
        private Delegate GetDelegateInternal()
        {
            if (_targetReference != null)
            {
                object target = _targetReference.Target;
                if (target != null)
                    return _method.CreateDelegate(typeof(TDelegate), target);
                throw new InvalidOperationException("The delegate target has been collected");
            }
            return _method.CreateDelegate(typeof(TDelegate));
        }
#else
        private Delegate GetDelegateInternal()
        {
            if (_targetReference != null)
            {
                object target = _targetReference.Target;
                if (target != null)
                    return Delegate.CreateDelegate(typeof(TDelegate), target, _method);
                throw new InvalidOperationException("The delegate target has been collected");
            }
            return Delegate.CreateDelegate(typeof(TDelegate), _method);
        }

#endif

        /// <summary>
        /// Indique si le delegate est encore actif (true) ou s'il a été collecté (false)
        /// </summary>
        public bool IsAlive
        {
            get { return _targetReference == null || _targetReference.IsAlive; }
        }

        #region IEquatable<TDelegate> Members

        /// <summary>
        /// Indique si cette instance est équivalente au delegate spécifié
        /// </summary>
        /// <param name="other">Le delegate avec lequel comparer cette instance</param>
        /// <returns>true si cette instance est équivalente au delegate spécifié, sinon false</returns>
        public bool Equals(TDelegate other)
        {
            Delegate d = (Delegate)(object)other;
            return d != null
                && d.Target == _targetReference.Target
#if NETFX_CORE
                && d.GetMethodInfo().Equals(_method);
#else
                && d.Method.Equals(_method);
#endif
        }

        #endregion

        /// <summary>
        /// Invoke le delegate avec les arguments spécifiés
        /// </summary>
        /// <param name="args">Arguments à passer au delegate</param>
        /// <returns>La valeur de retour du delegate</returns>
        public object Invoke(params object[] args)
        {
            object target = _targetReference.Target;
            if (target != null)
                return _method.Invoke(_targetReference.Target, args);
            return _method.ReturnType.GetDefaultValue();
        }
    }
}