#region Using directives

using System;
using System.Threading;
using System.Reflection;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Globalization;
using Microsoft.Win32;
#endregion

namespace System.Workflow.Runtime.DebugEngine
{
    internal sealed class DebugControllerThread
    {
        #region Data members

        private Thread controllerThread = null;
        private int threadId = 0;
        private ManualResetEvent threadInitializedEvent = null;
        private volatile bool runThread = false;
        private static readonly string ExpressionEvaluationFrameTypeName = "ExpressionEvaluationFrameTypeName";
        #endregion

        #region Methods

        public DebugControllerThread()
        {
            this.threadInitializedEvent = new ManualResetEvent(false);
            this.threadInitializedEvent.Reset();

            this.controllerThread = new Thread(ControllerThreadFunction);
            this.controllerThread.IsBackground = true;
            this.controllerThread.Priority = ThreadPriority.Lowest;
            this.controllerThread.Name = "__dct__";
        }

        public void RunThread(IInstanceTable instanceTable)
        {
            Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "WDE: DebugControllerThread.DebugControllerThread():"));
            if (this.controllerThread == null)
                return;

            this.runThread = true;
            this.controllerThread.Start(instanceTable);
            this.threadInitializedEvent.WaitOne();
        }

        public void StopThread()
        {
            Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "WDE: DebugControllerThread.StopThread():"));

            try
            {
                if (this.controllerThread != null)
                {
                    this.runThread = false;
                    Thread.Sleep(10);

                    // On x64 we put the debug controller thread to Sleep(Timeout.Infinite) in 
                    // ExpressionEvaluationFunction. This thread needs to be started before it
                    // a Join can execute.
                    if (this.controllerThread.IsAlive && IntPtr.Size == 8)
                    {
                        while (this.controllerThread.ThreadState == System.Threading.ThreadState.WaitSleepJoin)
                        {
                            this.controllerThread.Start();
                            this.controllerThread.Join();
                        }
                    }
                    else
                        this.controllerThread.Join();
                }
            }
            catch (ThreadStateException)
            {
                // Ignore the ThreadStateException which will be thrown when StopThread() is called during 
                // AppDomain unload.
            }
            finally
            {
                this.controllerThread = null;
            }

            this.controllerThread = null;
            this.threadId = 0;
            this.threadInitializedEvent = null;
        }

        private void ControllerThreadFunction(object instanceTable)
        {
            try
            {
                Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "WDE: DebugControllerThread.ControllerThreadFunction():"));

                IExpressionEvaluationFrame expressionEvaluationFrame = null;

                try
                {
                    RegistryKey debugEngineSubKey = Registry.LocalMachine.OpenSubKey(RegistryKeys.DebuggerSubKey);
                    if (debugEngineSubKey != null)
                    {
                        string evaluationFrameTypeName = debugEngineSubKey.GetValue(ExpressionEvaluationFrameTypeName, String.Empty) as string;
                        if (!String.IsNullOrEmpty(evaluationFrameTypeName) && Type.GetType(evaluationFrameTypeName) != null)
                            expressionEvaluationFrame = Activator.CreateInstance(Type.GetType(evaluationFrameTypeName)) as IExpressionEvaluationFrame;
                    }
                }
                catch { }

                if (expressionEvaluationFrame == null)
                {
                    Type eeFrameType = null;

                    const string eeFrameTypeNameFormat = "Microsoft.Workflow.DebugEngine.ExpressionEvaluationFrame, Microsoft.Workflow.ExpressionEvaluation, Version={0}.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35";

                    // Try versions 12.0.0.0, 11.0.0.0, 10.0.0.0
                    for (int version = 12; eeFrameType == null && version >= 10; --version)
                    {
                        try
                        {
                            eeFrameType = Type.GetType(string.Format(CultureInfo.InvariantCulture, eeFrameTypeNameFormat, version));
                        }
                        catch (TypeLoadException)
                        {
                            // Fall back to next-lower version
                        }
                    }

                    if (eeFrameType != null)
                    {
                        expressionEvaluationFrame = Activator.CreateInstance(eeFrameType) as IExpressionEvaluationFrame;
                    }
                }

                Debug.Assert(expressionEvaluationFrame != null, "Failed to create Expression Evaluation Frame.");

                if (expressionEvaluationFrame != null)
                    expressionEvaluationFrame.CreateEvaluationFrame((IInstanceTable)instanceTable, (DebugEngineCallback)Delegate.CreateDelegate(typeof(DebugEngineCallback), this, "ExpressionEvaluationFunction"));
            }
            catch
            {
                // Don't throw exceptions to the Runtime, it would terminate the debugee.
            }
        }

        // This thread spins forever. It is used by the Debug Engine to perform expression evaluation as a "carrier
        // wave". It is created only when the debugger is attached and terminates itself when the debugger isn't
        // attached anymore.
        public void ExpressionEvaluationFunction()
        {
            this.threadId = NativeMethods.GetCurrentThreadId();
            this.threadInitializedEvent.Set();


            using (new DebuggerThreadMarker())
            {
                // If an exception occurs somehow, continue to spin.
                while (this.runThread)
                {
                    try
                    {
                        // Expression eval on x64 does not work (bug 18143) so 
                        // don't let the thread spin.
                        if (IntPtr.Size == 8)
                        {
                            Thread.Sleep(Timeout.Infinite);
                        }
                        else
                            // Spin within the try catch.
                            while (this.runThread);
                    }
                    catch (ThreadAbortException)
                    {
                        Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "WDE: DebugControllerThread.ExpressionEvaluationFunction(): ThreadAbortException"));

                        // Explicitly do not call ResetAbort().
                        throw;
                    }
                    catch
                    {
                        Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "WDE: DebugControllerThread.ExpressionEvaluationFunction(): other exception"));
                    }
                }
            }
        }

        #endregion

        #region Properties

        public int ThreadId
        {
            get
            {
                return this.threadId;
            }
        }

        public int ManagedThreadId
        {
            get
            {
                return this.controllerThread.ManagedThreadId;
            }
        }

        #endregion
    }
}