using System;
using System.Reflection;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Activation;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Proxies;
using Developpez.Dotnet.Reflection;

namespace Developpez.Dotnet.Diagnostics
{
    /// <summary>
    /// Moniteur d'appels à des méthodes d'un objet
    /// </summary>
    /// <typeparam name="T">Type de l'objet à surveiller</typeparam>
    public class MethodCallMonitor<T> : RealProxy where T : MarshalByRefObject
    {
        /// <summary>
        /// Uri de l'objet
        /// </summary>
        protected virtual string ObjUri { get; set; }

        /// <summary>
        /// Liste des méthodes surveillées. null ou un tableau vide
        /// signifie de surveiller toutes les méthodes sans exception
        /// </summary>
        public virtual string[] MonitoredMethods { get; set; }

        MethodCallMonitor(MarshalByRefObject target)
            : base(typeof(T))
        {
            if (target == null)
                throw new ArgumentNullException("target");

            MonitoredMethods = null;

            ObjUri = RemotingServices.Marshal(target).URI;
        }

        /// <summary>
        /// Transmet l'appel d'une méthode au proxy sous-jacent
        /// </summary>
        /// <param name="invokeMessage">Le message contenant les informations d'appel de méthode</param>
        /// <returns>Le message renvoyé par la méthode appelée, contenant la valeur de retour et les paramètres ref ou out</returns>
        public override IMessage Invoke(IMessage invokeMessage)
        {
            if (invokeMessage is IConstructionCallMessage)
            {
                IConstructionReturnMessage myIConstructionReturnMessage =
                   this.InitializeServerObject((IConstructionCallMessage)invokeMessage);
                ConstructionResponse constructionResponse = new
                   ConstructionResponse(null, (IMethodCallMessage)invokeMessage);
                return constructionResponse;
            }
            else
            {
                IMethodCallMessage methodCall_base = invokeMessage as IMethodCallMessage;
                if (methodCall_base != null)
                {
                    MethodCallMessageWrapper methodCall =
                        new MethodCallMessageWrapper(methodCall_base);

                    methodCall.Properties["__Uri"] = ObjUri;

                    bool ignoreMonitoring = false;

                    /* on regarde s'il faut surveiller cette méthode */
                    if (MonitoredMethods != null && MonitoredMethods.Length > 0)
                    {
                        ignoreMonitoring = !methodCall.MethodName.In(MonitoredMethods);
                    }

                    if (!ignoreMonitoring)
                    {
                        // Build default return message
                        object retVal = ((MethodInfo)methodCall.MethodBase).ReturnType.GetDefaultValue();
                        var outArgs = methodCall.Args;
                        var retMsg = new ReturnMessage(retVal, outArgs, outArgs.Length, methodCall.LogicalCallContext, methodCall);

                        BeforeMethodCallEventArgs arg = new BeforeMethodCallEventArgs(methodCall) { Cancel = false, ReturnMessage = retMsg };
                        OnBeforeMethodCall(arg);
                        if (arg.Cancel)
                        {
                            AfterMethodCallEventArgs r_arg = new AfterMethodCallEventArgs(methodCall, true) { ReturnMessage = arg.ReturnMessage };
                            OnAfterMethodCall(r_arg);
                            return r_arg.ReturnMessage;
                        }
                    }

                    IMessage returnMessage = null;

                    try
                    {
                        returnMessage = ChannelServices.SyncDispatchMessage(methodCall);
                        IMethodReturnMessage methodReturnMessage = (IMethodReturnMessage)returnMessage;

                        if (!ignoreMonitoring)
                        {
                            AfterMethodCallEventArgs r_arg = new AfterMethodCallEventArgs(methodCall, true) { ReturnMessage = returnMessage };
                            OnAfterMethodCall(r_arg);
                            returnMessage = r_arg.ReturnMessage;
                        }

                        return returnMessage;
                    }
                    catch (Exception ex)
                    {
                        returnMessage = null;
                        if (!ignoreMonitoring)
                        {
                            MethodCallExceptionEventArgs ex_args = new MethodCallExceptionEventArgs(methodCall, ex) { Rethrow = true };

                            OnMethodCallException(ex_args);

                            if (ex_args.Rethrow)
                            {
                                throw new TargetInvocationException(ex_args.Exception);
                            }
                            else
                                return ex_args.ReturnMessage;
                        }
                        else
                        {
                            /* en l'absence de monitor on génère une exception */
                            throw new TargetInvocationException(ex);
                        }
                    }
                }
            }
            return ChannelServices.SyncDispatchMessage(invokeMessage);
        }

        /// <summary>
        /// Crée un nouveau proxy dynamique crée à partir de l'objet target passé en paramètre
        /// </summary>
        /// <param name="target">Objet pour lequel créer un proxy</param>
        /// <param name="proxy">Paramètre de sortie qui reçoit le MethodCallMonitor créé</param>
        /// <returns>Le proxy dynamique créé</returns>
        public static T Create(T target, out MethodCallMonitor<T> proxy)
        {
            proxy = new MethodCallMonitor<T>(target);
            return (T)proxy.GetTransparentProxy();
        }

        #region Events

        /// <summary>
        /// Appelé avant l'exécution d'une méthode au sein d'un objet surveillé
        /// </summary>
        public event BeforeMethodCallEventHandler BeforeMethodCall;

        /// <summary>
        /// Appelé après l'exécution d'une méthode au sein d'un objet surveillé, si l'exécution n'entraine pas d'exception
        /// </summary>
        public event AfterMethodCallEventHandler AfterMethodCall;

        /// <summary>
        /// Appelé si une exception survient dans une des méthodes surveillées
        /// </summary>
        public event MethodCallExceptionEventHandler MethodCallException;

        
        /// <summary>
        /// Déclanche l'évènement <see cref="BeforeMethodCall"/>
        /// </summary>
        /// <param name="e">Paramètre de l'évènement</param>
        protected virtual void OnBeforeMethodCall(BeforeMethodCallEventArgs e)
        {
            BeforeMethodCallEventHandler evt = BeforeMethodCall;
            if (evt != null)
                evt(this, e);
        }

        /// <summary>
        /// Déclanche l'évènement <see cref="AfterMethodCall"/>
        /// </summary>
        /// <param name="e">Paramètre de l'évènement</param>
        protected virtual void OnAfterMethodCall(AfterMethodCallEventArgs e)
        {
            AfterMethodCallEventHandler evt = AfterMethodCall;
            if (evt != null)
                evt(this, e);
        }

        /// <summary>
        /// Déclanche l'évènement <see cref="MethodCallException"/>
        /// </summary>
        /// <param name="e">Paramètre de l'évènement</param>
        protected virtual void OnMethodCallException(MethodCallExceptionEventArgs e)
        {
            MethodCallExceptionEventHandler evt = MethodCallException;
            if (evt != null)
                evt(this, e);
        }

        #endregion
    }

    #region Events Objects

    /// <summary>
    /// Représente le délégué utilisé pour un évènement précédent l'appel d'une méthode au sein d'un objet surveillé
    /// </summary>
    /// <param name="sender">La source de l'évènement</param>
    /// <param name="e">Un <see cref="BeforeMethodCallEventArgs"/> qui contient les arguments de l'évènement</param>
    public delegate void BeforeMethodCallEventHandler(object sender, BeforeMethodCallEventArgs e);

    /// <summary>
    /// Représente le délégué utilisé pour un évènement suivant l'appel d'une méthode au sein d'un objet surveillé
    /// </summary>
    /// <param name="sender">La source de l'évènement</param>
    /// <param name="e">Un <see cref="BeforeMethodCallEventArgs"/> qui contient les arguments de l'évènement</param>
    public delegate void AfterMethodCallEventHandler(object sender, AfterMethodCallEventArgs e);

    /// <summary>
    /// Représente le délégué utilisé pour un évènement résultant d'une exception dans une des méthodes surveillées
    /// </summary>
    /// <param name="sender">La source de l'évènement</param>
    /// <param name="e">Un <see cref="BeforeMethodCallEventArgs"/> qui contient les arguments de l'évènement</param>
    public delegate void MethodCallExceptionEventHandler(object sender, MethodCallExceptionEventArgs e);

    /// <summary>
    /// Classe de base pour les évènements de <see cref="MethodCallMonitor{T}"/>
    /// </summary>
    public abstract class MethodCallMonitorBaseEventArgs : EventArgs
    {
        /// <summary>
        /// Initialise une nouvelle instance de MethodCallMonitorBaseEventArgs pour le message spécifié
        /// </summary>
        /// <param name="message">Message d'appel de méthode</param>
        protected MethodCallMonitorBaseEventArgs(IMethodCallMessage message)
        {
            this.MethodName = message.MethodName;
            this.Msg = message;
        }

        /// <summary>
        /// Nom de la méthode
        /// </summary>
        public virtual string MethodName { get; private set; }

        /// <summary>
        /// Message (remoting) utilisé par le Framework pour tracer l'appel à la méthode
        /// </summary>
        public virtual IMethodCallMessage Msg { get; private set; }
    }

    /// <summary>
    /// Classe contenant les informations pour l'évènement <see cref="MethodCallExceptionEventHandler"/>
    /// </summary>
    public class MethodCallExceptionEventArgs : MethodCallMonitorBaseEventArgs
    {
        /// <summary>
        /// Initialise une nouvelle instance de MethodCallExceptionEventArgs pour le message et l'exception spécifiés
        /// </summary>
        /// <param name="message">Message d'appel de méthode</param>
        /// <param name="exception">Exception levée pendant l'exécution de la méthode</param>
        public MethodCallExceptionEventArgs(IMethodCallMessage message, Exception exception)
            : base(message)
        {
            this.Exception = exception;
        }

        /// <summary>
        /// Exception détectée au sein de la méthode (résultant d'un "throw")
        /// </summary>
        public Exception Exception { get; private set; }

        /// <summary>
        /// Indique si, une fois cet évènement traité, l'exception doit être à nouveau lancée
        /// pour être interceptée par un niveau supérieur.<br/>
        /// Par défaut, vaut true (dans le cas d'une non gestion de cet évènement, l'exception est remontée)
        /// </summary>
        public bool Rethrow { get; set; }

        /// <summary>
        /// Message de retour à passer à l'appelant, contenant la valeur renvoyée par la méthode
        /// </summary>
        public IMessage ReturnMessage { get; set; }
    }

    /// <summary>
    /// Classe contenant les informations pour l'évènement <see cref="BeforeMethodCallEventHandler"/>
    /// </summary>
    public class BeforeMethodCallEventArgs : MethodCallMonitorBaseEventArgs
    {
        /// <summary>
        /// Initialise une nouvelle instance de BeforeMethodCallEventArgs pour le message spécifié
        /// </summary>
        /// <param name="message">Message d'appel de méthode</param>
        public BeforeMethodCallEventArgs(IMethodCallMessage message)
            : base(message)
        {
        }

        /// <summary>
        /// Indique si l'appel doit être annulé. Dans ce cas, il faut placer un message dans ReturnMessage
        /// pour assurer l'intégrité des appels (ou déclancher une exception).
        /// </summary>
        public bool Cancel { get; set; }

        /// <summary>
        /// Message de retour à passer à l'appelant, contenant la valeur renvoyée par la méthode
        /// </summary>
        public IMessage ReturnMessage { get; set; }
    }

    /// <summary>
    /// Classe contenant les informations pour l'évènement <see cref="AfterMethodCallEventHandler"/>
    /// </summary>
    public class AfterMethodCallEventArgs : MethodCallMonitorBaseEventArgs
    {
        /// <summary>
        /// Initialise une nouvelle instance de AfterMethodCallEventArgs pour le message spécifié
        /// </summary>
        /// <param name="message">Message d'appel de méthode</param>
        /// <param name="cancelled">Indique si l'appel à la méthode a été annulé</param>
        public AfterMethodCallEventArgs(IMethodCallMessage message, bool cancelled)
            : base(message)
        {
            this.Cancelled = cancelled;
        }

        /// <summary>
        /// Indique si l'appel à la méthode a été annulé (résultant de la gestion de l'évènement <see cref="BeforeMethodCallEventHandler"/>)
        /// </summary>
        public bool Cancelled { get; set; }

        /// <summary>
        /// Message de retour à passer à l'appelant, contenant la valeur renvoyée par la méthode
        /// </summary>
        public IMessage ReturnMessage { get; set; }
    }

    #endregion
}