using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.Remoting.Messaging;
using Developpez.Dotnet.ComponentModel;

namespace Developpez.Dotnet.Diagnostics
{
    /// <summary>
    /// Permet d'obtenir le nombre d'exécutions et le temps d'exécutions des méthodes
    /// d'un objet
    /// </summary>
    /// <typeparam name="T">Type de l'objet à surveiller</typeparam>
    public class MethodTimeMonitor<T> where T:MarshalByRefObject
    {
        /* Clairement possible d'obtenir des cas asynchrones */

        /// <summary>
        /// Objet de synchronisation
        /// </summary>
        protected object sync = new object();

        /// <summary>
        /// Crée une nouvelle instance du chronomètre d'exécution de méthode
        /// </summary>
        public MethodTimeMonitor()
        {
            Monitored = new Dictionary<T, Dictionary<string, MethodTimeMonitor<T>.TimeMonitorEntry>>();
            RunningMethods = new Dictionary<IMethodCallMessage, ParameterizedGenericPool<Stopwatch>.GenericPoolItem>();
            PerfCounterPool = new GenericPool<Stopwatch>(1, 32); /* pool de 32 objets au maximum, ça devrais suffire */
        }

        #region Not Thread Safe

        /// <summary>
        /// Entrée du rapport d'utilisation d'une méthode
        /// </summary>
        public class TimeMonitorEntry
        {
            /// <summary>
            /// Construit une nouvelle instance d'une entrée du rapport d'appels
            /// </summary>
            public TimeMonitorEntry()
            {
                CallCount = 0;
                TotalTime = TimeSpan.Zero; /* secondes */
            }

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

            /// <summary>
            /// Nombre d'appels effectués à cette méthode
            /// </summary>
            public virtual int CallCount { get; set; }

            /// <summary>
            /// Temps total passé dans cette méthode (incluant également les sous-méthodes appelées)
            /// </summary>
            public virtual TimeSpan TotalTime { get; set; }

            /// <summary>
            /// Crée une copie de l'objet
            /// </summary>
            /// <returns>Copie</returns>
            public virtual TimeMonitorEntry Clone()
            {
                TimeMonitorEntry res = new MethodTimeMonitor<T>.TimeMonitorEntry();
                res.CallCount = CallCount;
                res.TotalTime = TotalTime;
                res.MethodName = MethodName;
                return res;
            }
        }

        /// <summary>
        /// Ensemble des méthodes actuellement surverillées
        /// </summary>
        protected virtual Dictionary<T, Dictionary<string, TimeMonitorEntry>> Monitored { get; private set; }

        #endregion

        #region Thread Safe - Transition Level

        /// <summary>
        /// Pool de chronomètres à utiliser pour l'observation des méthodes
        /// </summary>
        protected virtual GenericPool<Stopwatch> PerfCounterPool { get; private set; }

        /* C'est ici qu'on va pouvoir calculer les temps d'exécution.
         * Pour ne pas bloquer inutilement (probable), un autre sync
         * */

        /// <summary>
        /// Objet de synchronisation pour les transitions entre moniteur (proxy) et code (implémentation)
        /// </summary>
        protected object transition_sync = new object();

        /// <summary>
        /// Méthodes actuellement en cours d'exécution, avec un pool pour le perf counter
        /// afin d'éviter d'en créer un nombre infini
        /// </summary>
        protected virtual Dictionary<IMethodCallMessage, GenericPool<Stopwatch>.GenericPoolItem> RunningMethods { get; private set; }

        #endregion

        #region Thread Safe - Sync Level

        /// <summary>
        /// Début d'appel à une méthode d'un objet
        /// </summary>
        /// <param name="obj">Objet sur lequel la méthode est appelée</param>
        /// <param name="args">Paramètres de l'évènement</param>
        protected virtual void MethodBegin(T obj, BeforeMethodCallEventArgs args)
        {
            lock (transition_sync)
            {
                GenericPool<Stopwatch>.GenericPoolItem item = PerfCounterPool.ObtainItem();
                RunningMethods[args.Msg] = item;
                item.Value.Reset();
                item.Value.Start();
            }
        }

        /// <summary>
        /// Fin d'appel à une méthode d'un objet : cas où une exception est survenue
        /// </summary>
        /// <param name="obj">Objet sur lequel la méthode est appelée</param>
        /// <param name="args">Paramètres de l'évènement</param>
        protected virtual void MethodExceptionEnd(T obj, MethodCallExceptionEventArgs args)
        {
            GenericPool<Stopwatch>.GenericPoolItem item = null;
            try
            {
                lock (transition_sync)
                {
                    /* on ne fait que retirer le message ... une exception ne compte pas comme "temps" */
                    if (!RunningMethods.TryGetValue(args.Msg, out item))
                    {
                        /* oops ? */
                        Debug.Fail(String.Format("L'appel de fin de méthode pour {0} a été appelé, sans qu'il y ait eu de début !",
                            args.MethodName));
                        return;
                    }

                    RunningMethods.Remove(args.Msg);
                }
            }
            finally
            {
                if (item != null)
                    item.Dispose();
            }
        }

        /// <summary>
        /// Fin d'appel à une méthode d'un objet : cas normal
        /// </summary>
        /// <param name="obj">Objet sur lequel la méthode est appelée</param>
        /// <param name="args">Paramètres de l'évènement</param>
        protected virtual void MethodEnd(T obj, AfterMethodCallEventArgs args)
        {
            GenericPool<Stopwatch>.GenericPoolItem item = null;
            lock (transition_sync)
            {
                if (!RunningMethods.TryGetValue(args.Msg, out item))
                {
                    /* oops ? */
                    Debug.Fail(String.Format("L'appel de fin de méthode pour {0} a été appelé, sans qu'il y ait eu de début !",
                        args.MethodName));
                    return;
                }
                else
                    item.Value.Stop();
            }

            try
            {
                lock (sync)
                {
                    /* rajout du résultat */
                    Dictionary<string, TimeMonitorEntry> target_dictionary;
                    if (!Monitored.TryGetValue(obj, out target_dictionary))
                        Monitored[obj] = target_dictionary = new Dictionary<string, MethodTimeMonitor<T>.TimeMonitorEntry>();

                    TimeMonitorEntry entry = null;
                    if (!target_dictionary.TryGetValue(args.MethodName, out entry))
                    {
                        target_dictionary[args.MethodName] = entry = new MethodTimeMonitor<T>.TimeMonitorEntry();
                        entry.MethodName = args.MethodName;
                    }

                    entry.CallCount++;
                    entry.TotalTime += item.Value.Elapsed;
                }
            }
            finally
            {
                item.Dispose();
            }
        }
        
        /// <summary>
        /// Retourne un objet équivalent à obj, mais dont les appels
        /// de méthodes seront surveillés
        /// </summary>
        /// <param name="obj">objet à surveiller</param>
        /// <returns>Un proxy vers obj pour lequel les appels de méthodes sont surveillés</returns>
        public virtual T GetAsMonitored(T obj)
        {
            return GetAsMonitored(obj, null);
        }

        /// <summary>
        /// Retourne un objet équivalent à obj, mais dont les appels
        /// de méthodes seront surveillés
        /// </summary>
        /// <param name="obj">objet à surveiller</param>
        /// <param name="methodsToMonitor">Noms des méthodes à surveiller, ou null pour tout surveiller</param>
        /// <returns>Un proxy vers obj pour lequel les appels de méthodes sont surveillés</returns>
        private T GetAsMonitored(T obj, string[] methodsToMonitor)
        {
            MethodCallMonitor<T> m;

            T result = MethodCallMonitor<T>.Create(obj, out m);

            m.MonitoredMethods = methodsToMonitor;

            m.BeforeMethodCall += delegate(object sender, BeforeMethodCallEventArgs e)
            {
                MethodBegin(obj, e);
            };
            m.AfterMethodCall += delegate(object sender, AfterMethodCallEventArgs e)
            {
                MethodEnd(obj, e);
            };
            m.MethodCallException += delegate(object sender, MethodCallExceptionEventArgs e)
            {
                MethodExceptionEnd(obj, e);
            };

            return result;
        }

        /// <summary>
        /// Annule toute surveillance de l'objet obj
        /// </summary>
        /// <param name="obj">L'objet pour lequel annuler la surveillance</param>
        public virtual void DiscardMonitoring(T obj)
        {
            lock (sync)
            {
                Monitored.Remove(obj);
            }
        }

        /// <summary>
        /// Genère un rapport contenant pour chaque objet monitoré, l'ensemble des informations
        /// d'appel et d'exécution des méthode surveillées
        /// </summary>
        /// <returns>Rapport</returns>
        public virtual KeyValuePair<T,TimeMonitorEntry[]>[] Report()
        {
            List<KeyValuePair<T, TimeMonitorEntry[]>> result = new List<KeyValuePair<T, MethodTimeMonitor<T>.TimeMonitorEntry[]>>();
            lock (sync)
            {
                foreach (var section in Monitored)
                {
                    List<TimeMonitorEntry> sub = new List<MethodTimeMonitor<T>.TimeMonitorEntry>();
                    foreach (var item in section.Value)
                    {
                        sub.Add(item.Value.Clone());
                    }
                    result.Add(new KeyValuePair<T, TimeMonitorEntry[]>(section.Key, sub.ToArray()));
                }
            }
            return result.ToArray();
        }

        #endregion
    }
}