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

namespace System.ServiceModel.Dispatcher
{
    using System;
    using System.Runtime;
    using System.ServiceModel;
    using System.ServiceModel.Activation;
    using System.Threading;

    class ThreadBehavior
    {
        SendOrPostCallback threadAffinityStartCallback;
        SendOrPostCallback threadAffinityEndCallback;
        static Action<object> cleanThreadCallback;
        readonly SynchronizationContext context;
       
        internal ThreadBehavior(DispatchRuntime dispatch)
        {
            this.context = dispatch.SynchronizationContext;
        }

        SendOrPostCallback ThreadAffinityStartCallbackDelegate
        {
            get
            {
                if (this.threadAffinityStartCallback == null)
                {
                    this.threadAffinityStartCallback = new SendOrPostCallback(this.SynchronizationContextStartCallback);
                }
                return this.threadAffinityStartCallback;
            }
        }
        SendOrPostCallback ThreadAffinityEndCallbackDelegate
        {
            get
            {
                if (this.threadAffinityEndCallback == null)
                {
                    this.threadAffinityEndCallback = new SendOrPostCallback(this.SynchronizationContextEndCallback);
                }
                return this.threadAffinityEndCallback;
            }
        }

        static Action<object> CleanThreadCallbackDelegate
        {
            get
            {
                if (ThreadBehavior.cleanThreadCallback == null)
                {
                    ThreadBehavior.cleanThreadCallback = new Action<object>(ThreadBehavior.CleanThreadCallback);
                }
                return ThreadBehavior.cleanThreadCallback;
            }
        }

        internal void BindThread(ref MessageRpc rpc)
        {
            this.BindCore(ref rpc, true);
        }

        internal void BindEndThread(ref MessageRpc rpc)
        {
            this.BindCore(ref rpc, false);
        }

        void BindCore(ref MessageRpc rpc, bool startOperation)
        {
            SynchronizationContext syncContext = GetSyncContext(rpc.InstanceContext);

            if (syncContext != null)
            {
                IResumeMessageRpc resume = rpc.Pause();
                if (startOperation)
                {
                    syncContext.OperationStarted();
                    syncContext.Post(this.ThreadAffinityStartCallbackDelegate, resume);
                }
                else
                {
                    syncContext.Post(this.ThreadAffinityEndCallbackDelegate, resume);
                }
            }
            else if (rpc.SwitchedThreads)
            {
                IResumeMessageRpc resume = rpc.Pause();
                ActionItem.Schedule(ThreadBehavior.CleanThreadCallbackDelegate, resume);
            }
        }

        SynchronizationContext GetSyncContext(InstanceContext instanceContext)
        {
            Fx.Assert(instanceContext != null, "instanceContext is null !");
            SynchronizationContext syncContext = instanceContext.SynchronizationContext ?? this.context;
            return syncContext;
        }

        void SynchronizationContextStartCallback(object state)
        {
            ResumeProcessing((IResumeMessageRpc)state);
        }
        void SynchronizationContextEndCallback(object state)
        {
            IResumeMessageRpc resume = (IResumeMessageRpc)state;

            ResumeProcessing(resume);

            SynchronizationContext syncContext = GetSyncContext(resume.GetMessageInstanceContext());
            Fx.Assert(syncContext != null, "syncContext is null !?");
            syncContext.OperationCompleted();
        }
        void ResumeProcessing(IResumeMessageRpc resume)
        {
            bool alreadyResumedNoLock;
            resume.Resume(out alreadyResumedNoLock);

            if (alreadyResumedNoLock)
            {
                string text = SR.GetString(SR.SFxMultipleCallbackFromSynchronizationContext, context.GetType().ToString());
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(text));
            }
        }

        static void CleanThreadCallback(object state)
        {
            bool alreadyResumedNoLock;
            ((IResumeMessageRpc)state).Resume(out alreadyResumedNoLock);

            if (alreadyResumedNoLock)
            {
                Fx.Assert("IOThreadScheduler called back twice");
            }
        }

        internal static SynchronizationContext GetCurrentSynchronizationContext()
        {
            if (AspNetEnvironment.IsApplicationDomainHosted())
            {
                return null;
            }
            return SynchronizationContext.Current;
        }
    }
}