//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//----------------------------------------------------------------

namespace System.ServiceModel.Activities
{
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Runtime;
    using System.ServiceModel;
    using System.ServiceModel.Channels;
    using System.Threading;
    using System.Transactions;
    using SR2 = System.ServiceModel.Activities.SR;

    public class WorkflowControlClient : ClientBase<IWorkflowInstanceManagement>
    {
        BeginOperationDelegate onBeginAbandonDelegate;
        EndOperationDelegate onEndAbandonDelegate;
        SendOrPostCallback onAbandonCompleteDelegate;

        BeginOperationDelegate onBeginCancelDelegate;
        EndOperationDelegate onEndCancelDelegate;
        SendOrPostCallback onCancelCompleteDelegate;

        BeginOperationDelegate onBeginRunDelegate;
        EndOperationDelegate onEndRunDelegate;
        SendOrPostCallback onRunCompleteDelegate;

        BeginOperationDelegate onBeginSuspendDelegate;
        EndOperationDelegate onEndSuspendDelegate;
        SendOrPostCallback onSuspendCompleteDelegate;

        BeginOperationDelegate onBeginUnsuspendDelegate;
        EndOperationDelegate onEndUnsuspendDelegate;
        SendOrPostCallback onUnsuspendCompleteDelegate;

        BeginOperationDelegate onBeginTerminateDelegate;
        EndOperationDelegate onEndTerminateDelegate;
        SendOrPostCallback onTerminateCompleteDelegate;

        bool checkedBinding;
        bool supportsTransactedInvoke;

        public WorkflowControlClient()
            : base()
        {

        }

        public WorkflowControlClient(string endpointConfigurationName)
            : base(endpointConfigurationName)
        {

        }

        public WorkflowControlClient(string endpointConfigurationName, EndpointAddress remoteAddress)
            : base(endpointConfigurationName, remoteAddress)
        {

        }

        public WorkflowControlClient(string endpointConfigurationName, string remoteAddress)
            : base(endpointConfigurationName, remoteAddress)
        {

        }

        public WorkflowControlClient(Binding binding, EndpointAddress remoteAddress)
            : base(binding, remoteAddress)
        {

        }

        public WorkflowControlClient(WorkflowControlEndpoint workflowEndpoint)
            : base(workflowEndpoint.Binding, workflowEndpoint.Address)
        {

        }

        public event EventHandler<AsyncCompletedEventArgs> AbandonCompleted;
        public event EventHandler<AsyncCompletedEventArgs> CancelCompleted;
        public event EventHandler<AsyncCompletedEventArgs> RunCompleted;
        public event EventHandler<AsyncCompletedEventArgs> SuspendCompleted;
        public event EventHandler<AsyncCompletedEventArgs> UnsuspendCompleted;
        public event EventHandler<AsyncCompletedEventArgs> TerminateCompleted;

        bool SupportsTransactedInvoke
        {
            get
            {
                if (!this.checkedBinding)
                {
                    foreach (BindingElement bindingElement in base.Endpoint.Binding.CreateBindingElements())
                    {
                        TransactionFlowBindingElement transactionFlowElement = bindingElement as TransactionFlowBindingElement;

                        if (transactionFlowElement != null)
                        {
                            this.supportsTransactedInvoke = true;
                            break;
                        }
                    }
                    this.checkedBinding = true;
                }
                return this.supportsTransactedInvoke;
            }
        }

        bool IsTransactedInvoke
        {
            get
            {
                return this.SupportsTransactedInvoke && Transaction.Current != null;
            }
        }

        [Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Abandon")]
        public void Abandon(Guid instanceId)
        {
            Abandon(instanceId, null);
        }

        [Fx.Tag.InheritThrows(From = "Abandon")]
        public void Abandon(Guid instanceId, string reason)
        {
            base.Channel.Abandon(instanceId, reason);
        }

        [Fx.Tag.InheritThrows(From = "Abandon")]
        public void AbandonAsync(Guid instanceId)
        {
            AbandonAsync(instanceId, null, null);
        }

        [Fx.Tag.InheritThrows(From = "Abandon")]
        public void AbandonAsync(Guid instanceId, object userState)
        {
            AbandonAsync(instanceId, null, userState);
        }

        [Fx.Tag.InheritThrows(From = "Abandon")]
        public void AbandonAsync(Guid instanceId, string reason)
        {
            AbandonAsync(instanceId, reason, null);
        }

        [Fx.Tag.InheritThrows(From = "Abandon")]
        public void AbandonAsync(Guid instanceId, string reason, object userState)
        {
            if (this.onBeginAbandonDelegate == null)
            {
                this.onBeginAbandonDelegate = new BeginOperationDelegate(OnBeginAbandon);
                this.onEndAbandonDelegate = new EndOperationDelegate(OnEndAbandon);
                this.onAbandonCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnAbandonCompleted));
            }

            base.InvokeAsync(this.onBeginAbandonDelegate, new object[] { instanceId, reason },
                this.onEndAbandonDelegate, this.onAbandonCompleteDelegate, userState);
        }

        [Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Cancel")]
        public void Cancel(Guid instanceId)
        {
            if (this.IsTransactedInvoke)
            {
                base.Channel.TransactedCancel(instanceId);
            }
            else
            {
                base.Channel.Cancel((instanceId));
            }
        }

        [Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Cancel")]
        public void CancelAsync(Guid instanceId)
        {
            this.CancelAsync(instanceId, null);
        }

        [Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Cancel")]
        public void CancelAsync(Guid instanceId, object userState)
        {
            if (this.onBeginCancelDelegate == null)
            {
                this.onBeginCancelDelegate = new BeginOperationDelegate(OnBeginCancel);
                this.onEndCancelDelegate = new EndOperationDelegate(OnEndCancel);
                this.onCancelCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnCancelCompleted));
            }

            base.InvokeAsync(this.onBeginCancelDelegate, new object[] { instanceId },
                this.onEndCancelDelegate, this.onCancelCompleteDelegate, userState);
        }

        [Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Run")]
        public void Run(Guid instanceId)
        {
            if (this.IsTransactedInvoke)
            {
                base.Channel.TransactedRun((instanceId));
            }
            else
            {
                base.Channel.Run((instanceId));
            }
        }

        [Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Run")]
        public void RunAsync(Guid instanceId)
        {
            this.RunAsync(instanceId, null);
        }
        [Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Run")]
        public void RunAsync(Guid instanceId, object userState)
        {
            if (this.onBeginRunDelegate == null)
            {
                this.onBeginRunDelegate = new BeginOperationDelegate(OnBeginRun);
                this.onEndRunDelegate = new EndOperationDelegate(OnEndRun);
                this.onRunCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnRunCompleted));
            }

            base.InvokeAsync(this.onBeginRunDelegate, new object[] { instanceId },
                this.onEndRunDelegate, this.onRunCompleteDelegate, userState);
        }

        [Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Suspend")]
        public void Suspend(Guid instanceId)
        {
            Suspend(instanceId, SR2.DefaultSuspendReason);
        }
        [Fx.Tag.InheritThrows(From = "Suspend")]
        public void Suspend(Guid instanceId, string reason)
        {
            if (this.IsTransactedInvoke)
            {
                base.Channel.TransactedSuspend(instanceId, reason);
            }
            else
            {
                base.Channel.Suspend(instanceId, reason);
            }
        }
        [Fx.Tag.InheritThrows(From = "Suspend")]
        public void SuspendAsync(Guid instanceId)
        {
            this.SuspendAsync(instanceId, SR2.DefaultSuspendReason);
        }
        [Fx.Tag.InheritThrows(From = "Suspend")]
        public void SuspendAsync(Guid instanceId, string reason)
        {
            this.SuspendAsync(instanceId, reason, null);
        }
        [Fx.Tag.InheritThrows(From = "Suspend")]
        public void SuspendAsync(Guid instanceId, object userState)
        {
            this.SuspendAsync(instanceId, SR2.DefaultSuspendReason, userState);
        }
        [Fx.Tag.InheritThrows(From = "Suspend")]
        public void SuspendAsync(Guid instanceId, string reason, object userState)
        {
            if (this.onBeginSuspendDelegate == null)
            {
                this.onEndSuspendDelegate = new EndOperationDelegate(OnEndSuspend);
                this.onSuspendCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnSuspendCompleted));
                this.onBeginSuspendDelegate = new BeginOperationDelegate(OnBeginSuspend);
            }

            base.InvokeAsync(this.onBeginSuspendDelegate, new object[] { instanceId, reason },
                this.onEndSuspendDelegate, this.onSuspendCompleteDelegate, userState);

        }

        [Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Unsuspend")]
        public void Unsuspend(Guid instanceId)
        {
            if (this.IsTransactedInvoke)
            {
                base.Channel.TransactedUnsuspend(instanceId);
            }
            else
            {
                base.Channel.Unsuspend(instanceId);
            }
        }
        [Fx.Tag.InheritThrows(From = "Unsuspend")]
        public void UnsuspendAsync(Guid instanceId)
        {
            this.UnsuspendAsync(instanceId, null);
        }
        [Fx.Tag.InheritThrows(From = "Unsuspend")]
        public void UnsuspendAsync(Guid instanceId, object userState)
        {
            if (this.onBeginUnsuspendDelegate == null)
            {
                this.onBeginUnsuspendDelegate = new BeginOperationDelegate(OnBeginUnsuspend);
                this.onEndUnsuspendDelegate = new EndOperationDelegate(OnEndUnsuspend);
                this.onUnsuspendCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnUnsuspendCompleted));
            }

            base.InvokeAsync(this.onBeginUnsuspendDelegate, new object[] { instanceId },
                this.onEndUnsuspendDelegate, this.onUnsuspendCompleteDelegate, userState);

        }

        [Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Terminate")]
        public void Terminate(Guid instanceId)
        {
            Terminate(instanceId, SR2.DefaultTerminationReason);
        }
        [Fx.Tag.InheritThrows(From = "Terminate")]
        public void Terminate(Guid instanceId, string reason)
        {
            if (this.IsTransactedInvoke)
            {
                base.Channel.TransactedTerminate(instanceId, reason);
            }
            else
            {
                base.Channel.Terminate(instanceId, reason);
            }
        }
        [Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Terminate")]
        public void TerminateAsync(Guid instanceId)
        {
            this.TerminateAsync(instanceId, SR2.DefaultTerminationReason);
        }
        [Fx.Tag.InheritThrows(From = "Terminate")]
        public void TerminateAsync(Guid instanceId, string reason)
        {
            this.TerminateAsync(instanceId, reason, null);
        }
        [Fx.Tag.InheritThrows(From = "Terminate")]
        public void TerminateAsync(Guid instanceId, object userState)
        {
            this.TerminateAsync(instanceId, SR2.DefaultTerminationReason, userState);
        }
        [Fx.Tag.InheritThrows(From = "Terminate")]
        public void TerminateAsync(Guid instanceId, string reason, object userState)
        {
            if (this.onBeginTerminateDelegate == null)
            {
                this.onEndTerminateDelegate = new EndOperationDelegate(OnEndTerminate);
                this.onTerminateCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnTerminateCompleted));
                this.onBeginTerminateDelegate = new BeginOperationDelegate(OnBeginTerminate);
            }

            base.InvokeAsync(this.onBeginTerminateDelegate, new object[] { instanceId, reason },
                this.onEndTerminateDelegate, this.onTerminateCompleteDelegate, userState);
        }

        [Fx.Tag.InheritThrows(From = "Abandon")]
        public IAsyncResult BeginAbandon(Guid instanceId, AsyncCallback callback, object state)
        {
            return BeginAbandon(instanceId, null, callback, state);
        }
        [Fx.Tag.InheritThrows(From = "Abandon")]
        public IAsyncResult BeginAbandon(Guid instanceId, string reason, AsyncCallback callback, object state)
        {
            return base.Channel.BeginAbandon(instanceId, reason, callback, state);
        }
        [Fx.Tag.InheritThrows(From = "Abandon")]
        public void EndAbandon(IAsyncResult result)
        {
            base.Channel.EndAbandon(result);
        }

        [Fx.Tag.InheritThrows(From = "Cancel")]
        public IAsyncResult BeginCancel(Guid instanceId, AsyncCallback callback, object state)
        {
            return new CancelAsyncResult(base.Channel, this.IsTransactedInvoke, instanceId, callback, state);
        }

        [Fx.Tag.InheritThrows(From = "Cancel")]
        public void EndCancel(IAsyncResult result)
        {
            CancelAsyncResult.End(result);
        }

        [Fx.Tag.InheritThrows(From = "Run")]
        public IAsyncResult BeginRun(Guid instanceId, AsyncCallback callback, object state)
        {
            return new RunAsyncResult(base.Channel, this.IsTransactedInvoke, instanceId, callback, state);
        }

        [Fx.Tag.InheritThrows(From = "Run")]
        public void EndRun(IAsyncResult result)
        {
            RunAsyncResult.End(result);
        }

        [Fx.Tag.InheritThrows(From = "Suspend")]
        public IAsyncResult BeginSuspend(Guid instanceId, AsyncCallback callback, object state)
        {
            return BeginSuspend(instanceId, SR2.DefaultSuspendReason, callback, state);
        }

        [Fx.Tag.InheritThrows(From = "Suspend")]
        public IAsyncResult BeginSuspend(Guid instanceId, string reason, AsyncCallback callback, object state)
        {
            return new SuspendAsyncResult(base.Channel, this.IsTransactedInvoke, instanceId, reason, callback, state);
        }

        [Fx.Tag.InheritThrows(From = "Suspend")]
        public void EndSuspend(IAsyncResult result)
        {
            SuspendAsyncResult.End(result);
        }

        [Fx.Tag.InheritThrows(From = "Unsuspend")]
        public IAsyncResult BeginUnsuspend(Guid instanceId, AsyncCallback callback, object state)
        {
            return new UnsuspendAsyncResult(base.Channel, this.IsTransactedInvoke, instanceId, callback, state);
        }

        [Fx.Tag.InheritThrows(From = "Unsuspend")]
        public void EndUnsuspend(IAsyncResult result)
        {
            UnsuspendAsyncResult.End(result);
        }

        [Fx.Tag.InheritThrows(From = "Terminate")]
        public IAsyncResult BeginTerminate(Guid instanceId, AsyncCallback callback, object state)
        {
            return BeginTerminate(instanceId, SR2.DefaultTerminationReason, callback, state);
        }

        [Fx.Tag.InheritThrows(From = "Terminate")]
        public IAsyncResult BeginTerminate(Guid instanceId, string reason, AsyncCallback callback, object state)
        {
            return new TerminateAsyncResult(base.Channel, this.IsTransactedInvoke, instanceId, reason, callback, state);
        }

        [Fx.Tag.InheritThrows(From = "Terminate")]
        public void EndTerminate(IAsyncResult result)
        {
            TerminateAsyncResult.End(result);
        }

        void OnAbandonCompleted(object state)
        {
            EventHandler<AsyncCompletedEventArgs> abortCompleted = this.AbandonCompleted;

            if (abortCompleted != null)
            {
                InvokeAsyncCompletedEventArgs e = (InvokeAsyncCompletedEventArgs)state;
                abortCompleted(this,
                    new AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
            }
        }

        IAsyncResult OnBeginAbandon(object[] inputs, AsyncCallback callback, object state)
        {
            return this.BeginAbandon((Guid)inputs[0], (string)inputs[1], callback, state);
        }

        object[] OnEndAbandon(IAsyncResult result)
        {
            this.EndAbandon(result);
            return null;
        }

        void OnCancelCompleted(object state)
        {
            EventHandler<AsyncCompletedEventArgs> cancelCompleted = this.CancelCompleted;

            if (cancelCompleted != null)
            {
                InvokeAsyncCompletedEventArgs e = (InvokeAsyncCompletedEventArgs)state;
                cancelCompleted(this,
                    new AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
            }
        }

        IAsyncResult OnBeginCancel(object[] inputs, AsyncCallback callback, object state)
        {
            return this.BeginCancel((Guid)inputs[0], callback, state);
        }

        object[] OnEndCancel(IAsyncResult result)
        {
            this.EndCancel(result);
            return null;
        }

        void OnRunCompleted(object state)
        {
            EventHandler<AsyncCompletedEventArgs> runCompleted = this.RunCompleted;

            if (runCompleted != null)
            {
                InvokeAsyncCompletedEventArgs e = (InvokeAsyncCompletedEventArgs)state;
                runCompleted(this, new AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
            }
        }

        IAsyncResult OnBeginRun(object[] inputs, AsyncCallback callback, object state)
        {
            return this.BeginRun((Guid)inputs[0], callback, state);
        }
        object[] OnEndRun(IAsyncResult result)
        {
            this.EndRun(result);
            return null;
        }

        void OnSuspendCompleted(object state)
        {
            EventHandler<AsyncCompletedEventArgs> suspendCompleted = this.SuspendCompleted;

            if (suspendCompleted != null)
            {
                InvokeAsyncCompletedEventArgs e = (InvokeAsyncCompletedEventArgs)state;
                suspendCompleted(this, new AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
            }
        }
        IAsyncResult OnBeginSuspend(object[] inputs, AsyncCallback callback, object state)
        {
            return this.BeginSuspend((Guid)inputs[0], (string)inputs[1], callback, state);
        }
        object[] OnEndSuspend(IAsyncResult result)
        {
            this.EndSuspend(result);
            return null;
        }

        void OnUnsuspendCompleted(object state)
        {
            EventHandler<AsyncCompletedEventArgs> unsuspendCompleted = this.UnsuspendCompleted;

            if (unsuspendCompleted != null)
            {
                InvokeAsyncCompletedEventArgs e = (InvokeAsyncCompletedEventArgs)state;
                unsuspendCompleted(this, new AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
            }
        }
        IAsyncResult OnBeginUnsuspend(object[] inputs, AsyncCallback callback, object state)
        {
            return this.BeginUnsuspend((Guid)inputs[0], callback, state);
        }
        object[] OnEndUnsuspend(IAsyncResult result)
        {
            this.EndUnsuspend(result);
            return null;
        }

        void OnTerminateCompleted(object state)
        {
            EventHandler<AsyncCompletedEventArgs> terminateCompleted = this.TerminateCompleted;

            if (terminateCompleted != null)
            {
                InvokeAsyncCompletedEventArgs e = (InvokeAsyncCompletedEventArgs)state;
                terminateCompleted(this, new AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
            }
        }

        IAsyncResult OnBeginTerminate(object[] inputs, AsyncCallback callback, object state)
        {
            return this.BeginTerminate((Guid)inputs[0], (string)inputs[1], callback, state);
        }

        object[] OnEndTerminate(IAsyncResult result)
        {
            this.EndTerminate(result);
            return null;
        }

        class CancelAsyncResult : AsyncResult
        {
            static AsyncCompletion handleEndCancel = new AsyncCompletion(HandleEndCancel);
            bool isTransacted;
            IWorkflowInstanceManagement channel;

            public CancelAsyncResult(IWorkflowInstanceManagement channel, bool isTransacted, Guid instanceId,
                AsyncCallback callback, object state)
                : base(callback, state)
            {
                this.isTransacted = isTransacted;
                this.channel = channel;

                if (Cancel(instanceId))
                {
                    this.Complete(true);
                }
            }

            public static void End(IAsyncResult result)
            {
                AsyncResult.End<CancelAsyncResult>(result);
            }

            bool Cancel(Guid instanceId)
            {
                IAsyncResult result;
                AsyncCallback callback = this.PrepareAsyncCompletion(handleEndCancel);

                if (this.isTransacted)
                {
                    result = this.channel.BeginTransactedCancel(instanceId, callback, this);
                }
                else
                {
                    result = this.channel.BeginCancel(instanceId, callback, this);
                }

                if (result.CompletedSynchronously)
                {
                    return HandleEndCancel(result);
                }
                return false;
            }

            static bool HandleEndCancel(IAsyncResult result)
            {
                CancelAsyncResult thisPtr = (CancelAsyncResult)result.AsyncState;

                if (thisPtr.isTransacted)
                {
                    thisPtr.channel.EndTransactedCancel(result);
                }
                else
                {
                    thisPtr.channel.EndCancel(result);
                }
                return true;
            }
        }

        class RunAsyncResult : AsyncResult
        {
            static AsyncCompletion handleEndResume = new AsyncCompletion(HandleEndRun);
            bool isTransacted;
            IWorkflowInstanceManagement channel;

            public RunAsyncResult(IWorkflowInstanceManagement channel, bool isTransacted, Guid instanceId,
                AsyncCallback callback, object state)
                : base(callback, state)
            {
                this.isTransacted = isTransacted;
                this.channel = channel;

                if (Run(instanceId))
                {
                    this.Complete(true);
                }
            }

            public static void End(IAsyncResult result)
            {
                AsyncResult.End<RunAsyncResult>(result);
            }


            bool Run(Guid instanceId)
            {
                IAsyncResult result;
                AsyncCallback callback = this.PrepareAsyncCompletion(handleEndResume);

                if (this.isTransacted)
                {
                    result = this.channel.BeginTransactedRun(instanceId, callback, this);
                }
                else
                {
                    result = this.channel.BeginRun(instanceId, callback, this);
                }

                if (result.CompletedSynchronously)
                {
                    return HandleEndRun(result);
                }
                return false;
            }

            static bool HandleEndRun(IAsyncResult result)
            {
                RunAsyncResult thisPtr = (RunAsyncResult)result.AsyncState;

                if (thisPtr.isTransacted)
                {
                    thisPtr.channel.EndTransactedRun(result);
                }
                else
                {
                    thisPtr.channel.EndRun(result);
                }
                return true;
            }
        }
        class SuspendAsyncResult : AsyncResult
        {
            static AsyncCompletion handleEndSuspend = new AsyncCompletion(HandleEndSuspend);
            bool isTransacted;
            IWorkflowInstanceManagement channel;

            public SuspendAsyncResult(IWorkflowInstanceManagement channel, bool isTransacted,
                Guid instanceId, string reason, AsyncCallback callback, object state)
                : base(callback, state)
            {
                this.isTransacted = isTransacted;
                this.channel = channel;

                if (Suspend(instanceId, reason))
                {
                    this.Complete(true);
                }
            }

            public static void End(IAsyncResult result)
            {
                AsyncResult.End<SuspendAsyncResult>(result);
            }

            bool Suspend(Guid instanceId, string reason)
            {
                IAsyncResult result;
                AsyncCallback callback = this.PrepareAsyncCompletion(handleEndSuspend);

                if (this.isTransacted)
                {
                    result = this.channel.BeginTransactedSuspend(instanceId, reason, callback, this);
                }
                else
                {
                    result = this.channel.BeginSuspend(instanceId, reason, callback, this);
                }

                if (result.CompletedSynchronously)
                {
                    return HandleEndSuspend(result);
                }

                return false;
            }

            static bool HandleEndSuspend(IAsyncResult result)
            {
                SuspendAsyncResult thisPtr = (SuspendAsyncResult)result.AsyncState;

                if (thisPtr.isTransacted)
                {
                    thisPtr.channel.EndTransactedSuspend(result);
                }
                else
                {
                    thisPtr.channel.EndSuspend(result);
                }
                return true;
            }
        }
        class UnsuspendAsyncResult : AsyncResult
        {
            static AsyncCompletion handleEndUnsuspend = new AsyncCompletion(HandleEndUnsuspend);
            bool isTransacted;
            IWorkflowInstanceManagement channel;

            public UnsuspendAsyncResult(IWorkflowInstanceManagement channel, bool isTransacted,
                Guid instanceId, AsyncCallback callback, object state)
                : base(callback, state)
            {
                this.isTransacted = isTransacted;
                this.channel = channel;

                if (Unsuspend(instanceId))
                {
                    this.Complete(true);
                }
            }

            public static void End(IAsyncResult result)
            {
                AsyncResult.End<UnsuspendAsyncResult>(result);
            }

            bool Unsuspend(Guid instanceId)
            {
                IAsyncResult result;
                AsyncCallback callback = this.PrepareAsyncCompletion(handleEndUnsuspend);

                if (this.isTransacted)
                {
                    result = this.channel.BeginTransactedUnsuspend(instanceId, callback, this);
                }
                else
                {
                    result = this.channel.BeginUnsuspend(instanceId, callback, this);
                }

                if (result.CompletedSynchronously)
                {
                    return HandleEndUnsuspend(result);
                }

                return false;
            }

            static bool HandleEndUnsuspend(IAsyncResult result)
            {
                UnsuspendAsyncResult thisPtr = (UnsuspendAsyncResult)result.AsyncState;

                if (thisPtr.isTransacted)
                {
                    thisPtr.channel.EndTransactedUnsuspend(result);
                }
                else
                {
                    thisPtr.channel.EndUnsuspend(result);
                }
                return true;
            }
        }
        class TerminateAsyncResult : AsyncResult
        {
            static AsyncCompletion handleEndTerminate = new AsyncCompletion(HandleEndTerminate);
            bool isTransacted;
            IWorkflowInstanceManagement channel;

            public TerminateAsyncResult(IWorkflowInstanceManagement channel, bool isTransacted, 
                Guid instanceId, string reason, AsyncCallback callback, object state)
                : base(callback, state)
            {
                this.isTransacted = isTransacted;
                this.channel = channel;

                if (Terminate(instanceId, reason))
                {
                    this.Complete(true);
                }
            }

            public static void End(IAsyncResult result)
            {
                AsyncResult.End<TerminateAsyncResult>(result);
            }

            bool Terminate(Guid instanceId, string reason)
            {
                IAsyncResult result;
                AsyncCallback callback = this.PrepareAsyncCompletion(handleEndTerminate);

                if (this.isTransacted)
                {
                    result = this.channel.BeginTransactedTerminate(instanceId, reason, callback, this);
                }
                else
                {
                    result = this.channel.BeginTerminate(instanceId, reason, callback, this);
                }

                if (result.CompletedSynchronously)
                {
                    return HandleEndTerminate(result);
                }
                return false;
            }

            static bool HandleEndTerminate(IAsyncResult result)
            {
                TerminateAsyncResult thisPtr = (TerminateAsyncResult)result.AsyncState;

                if (thisPtr.isTransacted)
                {
                    thisPtr.channel.EndTransactedTerminate(result);
                }
                else
                {
                    thisPtr.channel.EndTerminate(result);
                }
                return true;
            }
        }
    }
}