//******************************************************************************************************
//  TimerTrace.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.Reflection;
using System.Text;
using System.Threading;
using System.Timers;
using GSF.Reflection;

namespace GSF.Diagnostics
{
    /// <summary>
    /// Executes a trace on the <see cref="System.Threading.Timer"/> for all queued timers.
    /// </summary>
    /// <remarks>
    /// This class heavily relies on reflection to get the Timer queue.
    /// Therefore it is very unlikely to work in MONO and can break 
    /// if Microsoft changes any of the member names or how the Timer 
    /// works.
    /// 
    /// In this case <see cref="WorksInThisRuntime"/> will be set to false
    /// and <see cref="GetTrace"/> will return "Not Supported"
    /// 
    /// </remarks>
    public static class TimerTrace
    {
        private static LogPublisher Log = Logger.CreatePublisher(typeof(TimerTrace), 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_timerQueueType;
        private static MethodInfo s_timerQueueInstanceMethod;
        private static FieldInfo s_timerQueueTimersField;

        private static Type s_timerQueueTimerType;
        private static FieldInfo s_timerQueueTimerTimerCallbackField;
        private static FieldInfo s_timerQueueTimerNextField;

        private static Type s_timerType;
        private static FieldInfo s_timerOnIntervalElapsedField;

        static TimerTrace()
        {
            WorksInThisRuntime = false;

            try
            {
                s_timerQueueType = Type.GetType("System.Threading.TimerQueue");
                s_timerQueueInstanceMethod = s_timerQueueType?.GetProperty("Instance", BindingFlags.Public | BindingFlags.Static)?.GetMethod;
                s_timerQueueTimersField = s_timerQueueType?.GetField("m_timers", BindingFlags.NonPublic | BindingFlags.Instance);

                s_timerQueueTimerType = Type.GetType("System.Threading.TimerQueueTimer");
                s_timerQueueTimerTimerCallbackField = s_timerQueueTimerType?.GetField("m_timerCallback", BindingFlags.NonPublic | BindingFlags.Instance);
                s_timerQueueTimerNextField = s_timerQueueTimerType?.GetField("m_next", BindingFlags.NonPublic | BindingFlags.Instance);

                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>
        /// Gets all of the callbacks for all timers.
        /// </summary>
        /// <param name="sb"></param>
        public static void GetTrace(StringBuilder sb)
        {
            if (!WorksInThisRuntime)
            {
                sb.AppendLine("Not Supported");
                return;
            }

            try
            {

                object timerQueue = s_timerQueueInstanceMethod.Invoke(null, null);
                lock (timerQueue)
                {
                    object timerQueueTimer = s_timerQueueTimersField.GetValue(timerQueue);

                    while (timerQueueTimer != null)
                    {
                        ProcessTimerQueueTimer(sb, timerQueueTimer);
                        timerQueueTimer = s_timerQueueTimerNextField.GetValue(timerQueueTimer);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Publish(MessageLevel.Error, MessageFlags.BugReport, "Error in GetTrace", null, null, ex);

                WorksInThisRuntime = false;
            }
        }


        private static void ProcessTimerQueueTimer(StringBuilder sb, object state)
        {
            TimerCallback timerCallback = (TimerCallback)s_timerQueueTimerTimerCallbackField.GetValue(state);

            if (TryProcessTimersTimerCallback(sb, timerCallback))
            {

            }
            else
            {
                sb.AppendLine(timerCallback.Method.GetFriendlyMethodNameWithClass());
            }
            return;
        }

        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;
        }
    }
}