//******************************************************************************************************
//  ThreadPoolTrace.cs - Gbtc
//
//  Copyright © 2016, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://www.opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  11/19/2016 - Steven E. Chisholm
//       Generated original version of source code.
//
//******************************************************************************************************

using System;
using System.Collections;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Timers;
using GSF.Reflection;

namespace GSF.Diagnostics
{
    /// <summary>
    /// Executes a trace on the <see cref="ThreadPool"/> for all callbacks currently queued.
    /// This will not include work items that have a time delayed callback.
    /// </summary>
    /// <remarks>
    /// This class heavily relies on reflection to get the ThreadPool queue.
    /// Therefore it is very unlikely to work in MONO and can break 
    /// if Microsoft changes any of the member names or how the ThreadPool 
    /// works.
    /// 
    /// In this case <see cref="WorksInThisRuntime"/> will be set to false
    /// and <see cref="GetTrace"/> will return "Not Supported"
    /// 
    /// </remarks>
    public static class ThreadPoolTrace
    {
        private static LogPublisher Log = Logger.CreatePublisher(typeof(ThreadPoolTrace), MessageClass.Component);
        /// <summary>
        /// Indicates that this trace works in the runtime version of .NET.
        /// </summary>
        public static bool WorksInThisRuntime { get; private set; }

        private static Type s_threadPoolType;
        private static MethodInfo s_threadPoolGetQueuedWorkItemsMethod;

        private static Type s_queueWorkerCallbackType;
        private static FieldInfo s_callbackField;
        private static FieldInfo s_stateField;

        private static Type s_timerQueueTimerType;
        private static FieldInfo s_timerQueueTimerTimerCallbackField;

        private static Type s_timerQueueType;
        private static MethodInfo s_timerQueueFireQueuedTimerCompletionMethod;

        private static Type s_timerType;
        private static FieldInfo s_timerOnIntervalElapsedField;

        static ThreadPoolTrace()
        {
            WorksInThisRuntime = false;

            try
            {
                s_threadPoolType = typeof(ThreadPool);
                s_threadPoolGetQueuedWorkItemsMethod = s_threadPoolType.GetMethod("GetQueuedWorkItems", BindingFlags.Static | BindingFlags.NonPublic);

                s_queueWorkerCallbackType = Type.GetType("System.Threading.QueueUserWorkItemCallback");
                s_callbackField = s_queueWorkerCallbackType?.GetField("callback", BindingFlags.NonPublic | BindingFlags.Instance);
                s_stateField = s_queueWorkerCallbackType?.GetField("state", BindingFlags.NonPublic | BindingFlags.Instance);
                s_timerQueueTimerType = Type.GetType("System.Threading.TimerQueueTimer");
                s_timerQueueTimerTimerCallbackField = s_timerQueueTimerType?.GetField("m_timerCallback", BindingFlags.NonPublic | BindingFlags.Instance);
                s_timerQueueType = Type.GetType("System.Threading.TimerQueue");
                s_timerQueueFireQueuedTimerCompletionMethod = s_timerQueueType?.GetMethod("FireQueuedTimerCompletion", BindingFlags.NonPublic | BindingFlags.Static);
                s_timerType = typeof(System.Timers.Timer);
                s_timerOnIntervalElapsedField = s_timerType?.GetField("onIntervalElapsed", BindingFlags.NonPublic | BindingFlags.Instance);
                WorksInThisRuntime = true;
            }
            catch (Exception ex)
            {
                Log.Publish(MessageLevel.Error, MessageFlags.BugReport, "Error in constructor", null, null, ex);
            }

        }

        /// <summary>
        /// Traces all queued items on the ThreadPool.
        /// </summary>
        /// <param name="sb"></param>
        public static void GetTrace(StringBuilder sb)
        {
            if (!WorksInThisRuntime)
            {
                sb.AppendLine("Not Supported");
                return;
            }

            try
            {
                foreach (var iThreadPoolWorkItem in (IEnumerable)s_threadPoolGetQueuedWorkItemsMethod.Invoke(null, null))
                {
                    ProcessIThreadPoolWorkItem(sb, iThreadPoolWorkItem);
                }

            }
            catch (Exception ex)
            {
                Log.Publish(MessageLevel.Error, MessageFlags.BugReport, "Error in GetTrace", null, null, ex);

                WorksInThisRuntime = false;
            }

        }

        private static void ProcessIThreadPoolWorkItem(StringBuilder sb, object item)
        {
            if (item != null && item.GetType() == s_queueWorkerCallbackType)
            {
                WaitCallback callback = (WaitCallback)s_callbackField.GetValue(item);
                object state = (object)s_stateField.GetValue(item);

                if (TryProcessThreadingTimerCallback(sb, callback, state))
                {

                }
                else
                {
                    sb.AppendLine(callback.Method.GetFriendlyMethodNameWithClass());
                }
            }
            else if (item != null)
            {
                sb.AppendLine(item.GetType().ToString());
            }
        }

        private static bool TryProcessThreadingTimerCallback(StringBuilder sb, WaitCallback callback, object state)
        {
            if (callback.Target == null && callback.Method == s_timerQueueFireQueuedTimerCompletionMethod && state != null && state.GetType() == s_timerQueueTimerType)
            {
                TimerCallback timerCallback = (TimerCallback)s_timerQueueTimerTimerCallbackField.GetValue(state);

                if (TryProcessTimersTimerCallback(sb, timerCallback))
                {
                }
                else
                {
                    sb.AppendLine(timerCallback.Method.GetFriendlyMethodNameWithClass());
                }
                return true;
            }
            return false;
        }

        private static bool TryProcessTimersTimerCallback(StringBuilder sb, TimerCallback timerCallback)
        {
            if (timerCallback.Target != null && timerCallback.Target.GetType() == s_timerType)
            {
                System.Timers.Timer t = timerCallback.Target as System.Timers.Timer;
                ElapsedEventHandler onIntervalElapsed = (ElapsedEventHandler)s_timerOnIntervalElapsedField.GetValue(t);
                sb.AppendLine(onIntervalElapsed.Method.GetFriendlyMethodNameWithClass());
                return true;
            }
            return false;
        }
    }
}