//------------------------------------------------------------------------------
// <copyright file="LegacyAspNetSynchronizationContext.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

using System;
using System.ComponentModel;
using System.Runtime.ExceptionServices;
using System.Security.Permissions;
using System.Threading;
using System.Web;
using System.Web.Util;

namespace System.Web {

    // Represents a SynchronizationContext that has legacy behavior (<= FX 4.0) when it comes to asynchronous operations.
    // Characterized by locking on the HttpApplication to synchronize work, dispatching Posts as Sends.

    internal sealed class LegacyAspNetSynchronizationContext : AspNetSynchronizationContextBase {
        private HttpApplication _application;
        private Action<bool> _appVerifierCallback;
        private bool _disabled;
        private bool _syncCaller;
        private bool _invalidOperationEncountered;
        private int _pendingCount;
        private ExceptionDispatchInfo _error;
        private WaitCallback _lastCompletionCallback;
        private object _lastCompletionCallbackLock;

        internal LegacyAspNetSynchronizationContext(HttpApplication app) {
            _application = app;
            _appVerifierCallback = AppVerifier.GetSyncContextCheckDelegate(app);
            _lastCompletionCallbackLock = new object();
        }

        private void CheckForRequestStateIfRequired() {
            if (_appVerifierCallback != null) {
                _appVerifierCallback(false);
            }
        }

        private void CallCallback(SendOrPostCallback callback, Object state) {
            CheckForRequestStateIfRequired();

            // don't take app lock for sync caller to avoid deadlocks in case they poll for result
            if (_syncCaller) {
                CallCallbackPossiblyUnderLock(callback, state);
            }
            else {
                lock (_application) {
                    CallCallbackPossiblyUnderLock(callback, state);
                }
            }
        }

        private void CallCallbackPossiblyUnderLock(SendOrPostCallback callback, Object state) {
            ThreadContext threadContext = null;
            try {
                threadContext = _application.OnThreadEnter();
                try {
                    callback(state);
                }
                catch (Exception e) {
                    _error = ExceptionDispatchInfo.Capture(e);
                }
            }
            finally {
                if (threadContext != null) {
                    threadContext.DisassociateFromCurrentThread();
                }
            }
        }

        // this property no-ops using the legacy sync context
        internal override bool AllowAsyncDuringSyncStages {
            get;
            set;
        }

        internal override int PendingOperationsCount {
            get { return _pendingCount; }
        }

        internal override ExceptionDispatchInfo ExceptionDispatchInfo {
            get { return _error; }
        }

        internal override void ClearError() {
            _error = null;
        }

        // Dev11 Bug 70908: Race condition involving SynchronizationContext allows ASP.NET requests to be abandoned in the pipeline
        //  
        // When the last completion occurs, the _pendingCount is decremented and then the _lastCompletionCallbackLock is acquired to get
        // the _lastCompletionCallback.  If the _lastCompletionCallback is non-null, then the last completion will invoke the callback;
        // otherwise, the caller of PendingCompletion will handle the completion.
        internal override bool PendingCompletion(WaitCallback callback) {
            Debug.Assert(_lastCompletionCallback == null); // only one at a time
            bool pending = false;
            if (_pendingCount != 0) {
                lock (_lastCompletionCallbackLock) {
                    if (_pendingCount != 0) {
                        pending = true;
                        _lastCompletionCallback = callback;
                    }
                }
            }
            return pending;            
        }

        public override void Send(SendOrPostCallback callback, Object state) {
#if DBG
            Debug.Trace("Async", "Send");
            Debug.Trace("AsyncStack", "Send from:\r\n" + GetDebugStackTrace());
#endif
            CallCallback(callback, state);
        }

        public override void Post(SendOrPostCallback callback, Object state) {
#if DBG
            Debug.Trace("Async", "Post");
            Debug.Trace("AsyncStack", "Post from:\r\n" + GetDebugStackTrace());
#endif
            CallCallback(callback, state);
        }

#if DBG
        [EnvironmentPermission(SecurityAction.Assert, Unrestricted=true)]
        private void CreateCopyDumpStack() {
            Debug.Trace("Async", "CreateCopy");
            Debug.Trace("AsyncStack", "CreateCopy from:\r\n" + GetDebugStackTrace());
        }
#endif

        public override SynchronizationContext CreateCopy() {
#if DBG
            CreateCopyDumpStack();
#endif
            LegacyAspNetSynchronizationContext context = new LegacyAspNetSynchronizationContext(_application);
            context._disabled = _disabled;
            context._syncCaller = _syncCaller;
            context.AllowAsyncDuringSyncStages = AllowAsyncDuringSyncStages;
            return context;
        }

        public override void OperationStarted() {
            if (_invalidOperationEncountered || (_disabled && _pendingCount == 0)) {
                _invalidOperationEncountered = true;
                throw new InvalidOperationException(SR.GetString(SR.Async_operation_disabled));
            }

            Interlocked.Increment(ref _pendingCount);
#if DBG
            Debug.Trace("Async", "OperationStarted(count=" + _pendingCount + ")");
            Debug.Trace("AsyncStack", "OperationStarted(count=" + _pendingCount + ") from:\r\n" + GetDebugStackTrace());
#endif
        }

        public override void OperationCompleted() {
            if (_invalidOperationEncountered || (_disabled && _pendingCount == 0)) {
                // throw from operation started could cause extra operation completed
                return;
            }

            int pendingCount = Interlocked.Decrement(ref _pendingCount);

#if DBG
            Debug.Trace("Async", "OperationCompleted(pendingCount=" + pendingCount + ")");
            Debug.Trace("AsyncStack", "OperationCompleted(pendingCount=" + pendingCount + ") from:\r\n" + GetDebugStackTrace());
#endif

            // notify (once) about the last completion to resume the async work
            if (pendingCount == 0) {
                WaitCallback callback = null;
                lock (_lastCompletionCallbackLock) {
                    callback = _lastCompletionCallback;
                    _lastCompletionCallback = null;
                }

                if (callback != null) {
                    Debug.Trace("Async", "Queueing LastCompletionWorkItemCallback");
                    ThreadPool.QueueUserWorkItem(callback);
                }
            }
        }

        internal override bool Enabled {
            get { return !_disabled; }
        }

        internal override void Enable() {
            _disabled = false;
        }

        internal override void Disable() {
            _disabled = true;
        }

        internal override void SetSyncCaller() {
            _syncCaller = true;
        }

        internal override void ResetSyncCaller() {
            _syncCaller = false;
        }

        internal override void AssociateWithCurrentThread() {
            Monitor.Enter(_application);
        }

        internal override void DisassociateFromCurrentThread() {
            Monitor.Exit(_application);
        }

#if DBG
        [EnvironmentPermission(SecurityAction.Assert, Unrestricted = true)]
        private static string GetDebugStackTrace() {
            return Environment.StackTrace;
        }
#endif
    }
}