using System;
using System.Threading.Tasks;
using System.IO.Pipes;
using System.Threading;
using System.Runtime.ExceptionServices;
using System.Runtime.CompilerServices;

// Copy of external/corefx/src/Common/src/System/Threading/Tasks/TaskToApm.cs
namespace BugReport.System.Threading.Tasks
{
    public static class TaskToApm
    {
        public static IAsyncResult Begin(Task task, AsyncCallback callback, object state)
        {

            // If the task has already completed, then since the Task's CompletedSynchronously==false
            // and we want it to be true, we need to create a new IAsyncResult. (We also need the AsyncState to match.)
            IAsyncResult asyncResult;
            if (task.IsCompleted)
            {
                // Synchronous completion.
                asyncResult = new TaskWrapperAsyncResult(task, state, completedSynchronously: true);
                callback?.Invoke(asyncResult);
            }
            else
            {
                // For asynchronous completion we need to schedule a callback.  Whether we can use the Task as the IAsyncResult
                // depends on whether the Task's AsyncState has reference equality with the requested state.
                asyncResult = task.AsyncState == state ? (IAsyncResult)task : new TaskWrapperAsyncResult(task, state, completedSynchronously: false);
                if (callback != null)
                {
                    InvokeCallbackWhenTaskCompletes(task, callback, asyncResult);
                }
            }
            return asyncResult;
        }

        public static void End(IAsyncResult asyncResult)
        {
            Task task;

            // If the IAsyncResult is our task-wrapping IAsyncResult, extract the Task.
            var twar = asyncResult as TaskWrapperAsyncResult;
            if (twar != null)
            {
                task = twar.Task;
            }
            else
            {
                // Otherwise, the IAsyncResult should be a Task.
                task = asyncResult as Task;
            }

            // Make sure we actually got a task, then complete the operation by waiting on it.
            if (task == null)
            {
                throw new ArgumentNullException();
            }

            task.GetAwaiter().GetResult();
        }

        public static TResult End<TResult>(IAsyncResult asyncResult)
        {
            Task<TResult> task;

            // If the IAsyncResult is our task-wrapping IAsyncResult, extract the Task.
            var twar = asyncResult as TaskWrapperAsyncResult;
            if (twar != null)
            {
                task = twar.Task as Task<TResult>;
            }
            else
            {
                // Otherwise, the IAsyncResult should be a Task<TResult>.
                task = asyncResult as Task<TResult>;
            }

            // Make sure we actually got a task, then complete the operation by waiting on it.
            if (task == null)
            {
                throw new ArgumentNullException();
            }

            return task.GetAwaiter().GetResult();
        }

        private static void InvokeCallbackWhenTaskCompletes(Task antecedent, AsyncCallback callback, IAsyncResult asyncResult)
        {

            // We use OnCompleted rather than ContinueWith in order to avoid running synchronously
            // if the task has already completed by the time we get here.  This is separated out into
            // its own method currently so that we only pay for the closure if necessary.
            antecedent.ConfigureAwait(continueOnCapturedContext: false)
                      .GetAwaiter()
                      .OnCompleted(() => callback(asyncResult));
        }

        private sealed class TaskWrapperAsyncResult : IAsyncResult
        {
            internal readonly Task Task;
            private readonly object _state;
            private readonly bool _completedSynchronously;

            internal TaskWrapperAsyncResult(Task task, object state, bool completedSynchronously)
            {
                this.Task = task;
                _state = state;
                _completedSynchronously = completedSynchronously;
            }

            object IAsyncResult.AsyncState { get { return _state; } }
            bool IAsyncResult.CompletedSynchronously { get { return _completedSynchronously; } }
            bool IAsyncResult.IsCompleted { get { return this.Task.IsCompleted; } }
            WaitHandle IAsyncResult.AsyncWaitHandle { get { return ((IAsyncResult)this.Task).AsyncWaitHandle; } }
        }
    }
}

namespace MainProgram
{
	class Program
	{
		static void Main(string[] args)
		{
			RunServer();
			Thread.Sleep (500);
		}

		static void RunServer ()
		{
			IAsyncResult fooResult = BugReport.System.Threading.Tasks.TaskToApm.Begin (Foo (), TheCallback, "abcd");

			Console.WriteLine ("ran Foo");
			int i = BugReport.System.Threading.Tasks.TaskToApm.End<int> (fooResult);
		}

		static async Task<int> Foo () {
			await Task.Delay (1000);
			return 42;
		}

		[MethodImpl (MethodImplOptions.NoInlining)]
		private static void TheCallback (IAsyncResult res) {
			Console.WriteLine ("abcd = {0}, {1}", res, res.AsyncState);
			throw new ArgumentException ("Lets have an argument");
		}
	}
}