namespace System.Web {
    using System;
    using System.ComponentModel;
    using System.Globalization;
    using System.Runtime.Remoting.Messaging;
    using System.Security.Principal;
    using System.Text;
    using System.Threading;
    using System.Web.Configuration;
    using System.Web.UI;
    using System.Web.Util;

    // Contains information about any modifications ASP.NET has made to the current
    // thread and how to undo them. See also the comments on
    // HttpApplication.OnThreadEnterPrivate.

    internal sealed class ThreadContext : ISyncContextLock {

        // This is a marker holding the current ThreadContext for the current
        // thread. Uses TLS so that it's not wiped away by ExecutionContext.Run.
        [ThreadStatic]
        private static ThreadContext _currentThreadContext;

        private ImpersonationContext _newImpersonationContext;
        private HttpContext _originalHttpContext;
        private SynchronizationContext _originalSynchronizationContext;
        private ThreadContext _originalThreadContextCurrent;
        private CultureInfo _originalThreadCurrentCulture;
        private CultureInfo _originalThreadCurrentUICulture;
        private IPrincipal _originalThreadPrincipal;
        private bool _setCurrentThreadOnHttpContext;

        internal ThreadContext(HttpContext httpContext) {
            HttpContext = httpContext;
        }

        internal static ThreadContext Current {
            get { return _currentThreadContext; }
            private set { _currentThreadContext = value; }
        }

        internal bool HasBeenDisassociatedFromThread {
            get;
            private set;
        }

        internal HttpContext HttpContext {
            get;
            private set;
        }

        // Associates this ThreadContext with the current thread. This restores certain
        // ambient values associated with the current HttpContext, such as the current
        // user and cultures. It also sets HttpContext.Current.
        internal void AssociateWithCurrentThread(bool setImpersonationContext) {
            Debug.Assert(HttpContext != null); // only to be used when context is available
            Debug.Assert(Current != this, "This ThreadContext is already associated with this thread.");
            Debug.Assert(!HasBeenDisassociatedFromThread, "This ThreadContext has already been disassociated from a thread.");

            Debug.Trace("OnThread", GetTraceMessage("Enter1"));

            /*
             * !! IMPORTANT !!
             * Keep this logic in sync with DisassociateFromCurrentThread and EnterExecutionContext.
             */

            // attach http context to the call context
            _originalHttpContext = DisposableHttpContextWrapper.SwitchContext(HttpContext);

            // set impersonation on the current thread
            if (setImpersonationContext) {
                SetImpersonationContext();
            }

            // set synchronization context for the current thread to support the async pattern
            _originalSynchronizationContext = AsyncOperationManager.SynchronizationContext;
            AspNetSynchronizationContextBase aspNetSynchronizationContext = HttpContext.SyncContext;
            AsyncOperationManager.SynchronizationContext = aspNetSynchronizationContext;

            // set ETW trace ID
            Guid g = HttpContext.WorkerRequest.RequestTraceIdentifier;
            if (g != Guid.Empty) {
                CallContext.LogicalSetData("E2ETrace.ActivityID", g);
            }

            // set SqlDependecyCookie
            HttpContext.ResetSqlDependencyCookie();

            // set principal on the current thread
            _originalThreadPrincipal = Thread.CurrentPrincipal;
            HttpApplication.SetCurrentPrincipalWithAssert(HttpContext.User);

            // only set culture on the current thread if it is not initialized
            SetRequestLevelCulture();

            // DevDivBugs 75042
            // set current thread in context if there is not there
            // the timeout manager  uses this to abort the correct thread
            if (HttpContext.CurrentThread == null) {
                _setCurrentThreadOnHttpContext = true;
                HttpContext.CurrentThread = Thread.CurrentThread;
            }

            // Store a reference to the original ThreadContext.Current. It is possible that a parent
            // ThreadContext might already be associated with the current thread, e.g. if the current
            // stack contains a call to MgdIndicateCompletion (via
            // PipelineRuntime.ProcessRequestNotificationHelper). If this is the case, the child
            // ThreadContext will temporarily take over.
            _originalThreadContextCurrent = Current;
            Current = this;

            Debug.Trace("OnThread", GetTraceMessage("Enter2"));
        }

        private ClientImpersonationContext CreateNewClientImpersonationContext() {
            // impersonation is set in the ClientImpersonationContext ctor
            return new ClientImpersonationContext(HttpContext);
        }

        // Disassociates this ThreadContext from the current thread. Any ambient values (e.g., culture)
        // associated with the current request are stored in the HttpContext object so that they
        // can be restored the next time a ThreadContext associated with this HttpContext is active.
        // Impersonation and other similar modifications to the current thread are undone.
        internal void DisassociateFromCurrentThread() {
            Debug.Trace("OnThread", GetTraceMessage("Leave1"));
            Debug.Assert(Current == this, "This ThreadContext isn't associated with current thread.");
            Debug.Assert(!HasBeenDisassociatedFromThread, "This ThreadContext has already been disassociated from a thread.");

            /*
             * !! IMPORTANT !!
             * Keep this logic in sync with AssociateWithCurrentThread and EnterExecutionContext.
             */

            Current = _originalThreadContextCurrent;
            HasBeenDisassociatedFromThread = true;

            // remove thread if set
            if (_setCurrentThreadOnHttpContext) {
                HttpContext.CurrentThread = null;
            }

            // this thread should not be locking app state
            HttpApplicationFactory.ApplicationState.EnsureUnLock();

            // stop impersonation
            UndoImpersonationContext();

            // restore culture
            RestoreRequestLevelCulture();

            // restrore synchronization context
            AsyncOperationManager.SynchronizationContext = _originalSynchronizationContext;

            // restore thread principal
            HttpApplication.SetCurrentPrincipalWithAssert(_originalThreadPrincipal);

            // Remove SqlCacheDependency cookie from call context if necessary
            HttpContext.RemoveSqlDependencyCookie();

            // remove http context from the call context
            DisposableHttpContextWrapper.SwitchContext(_originalHttpContext);
            _originalHttpContext = null;

            Debug.Trace("OnThread", GetTraceMessage("Leave2"));
        }

        // Called by AspNetHostExecutionContextManager to signal that ExecutionContext.Run
        // is being called on a thread currently associated with our ThreadContext. Since
        // ExecutionContext.Run destroys some of our ambient state (HttpContext.Current, etc.),
        // we need to restore it. This method returns an Action which should be called when
        // the call to ExecutionContext.Run is concluding.
        internal Action EnterExecutionContext() {
            Debug.Trace("OnThread", GetTraceMessage("EnterExecutionContext1"));
            Debug.Assert(Current == this, "This ThreadContext isn't associated with current thread.");
            Debug.Assert(!HasBeenDisassociatedFromThread, "This ThreadContext has already been disassociated from a thread.");

            /*
             * !! IMPORTANT !!
             * Keep this logic in sync with AssociateWithCurrentThread and DisassociateFromCurrentThread.
             */

            // ExecutionContext.Run replaces the current impersonation token, so we need to impersonate
            // if AssociateWithCurrentThread also did so.

            ClientImpersonationContext executionContextClientImpersonationContext = null;
            if (_newImpersonationContext != null) {
                executionContextClientImpersonationContext = CreateNewClientImpersonationContext();
            }

            // ExecutionContext.Run resets the LogicalCallContext / IllogicalCallContext (which contains HttpContext.Current),
            // so we need to restore both of them.

            DisposableHttpContextWrapper.SwitchContext(HttpContext);

            Guid g = HttpContext.WorkerRequest.RequestTraceIdentifier;
            if (g != Guid.Empty) {
                CallContext.LogicalSetData("E2ETrace.ActivityID", g);
            }

            HttpContext.ResetSqlDependencyCookie();

            // ExecutionContext.Run resets the thread's CurrentPrincipal, so we need to restore it.

            HttpApplication.SetCurrentPrincipalWithAssert(HttpContext.User);

            // Other items like [ThreadStatic] fields, culture, etc. are untouched by ExecutionContext.Run,
            // so we don't need to worry about them.

            Debug.Trace("OnThread", GetTraceMessage("EnterExecutionContext2"));

            // This delegate is the cleanup routine.
            return () => {
                Debug.Trace("OnThread", GetTraceMessage("LeaveExecutionContext1"));

                // Undo any impersonation that we performed.
                if (executionContextClientImpersonationContext != null) {
                    executionContextClientImpersonationContext.Undo();
                }

                // Other things, e.g. changes to the logical/illogical call contexts, changes
                // to CurrentPrincipal, etc., will automatically be reverted anyway when
                // the call to ExecutionContext.Run concludes, so we don't need to clean up
                // here.

                Debug.Trace("OnThread", GetTraceMessage("LeaveExecutionContext2"));
            };
        }

        private static string GetTraceMessage(string tag) {
#if DBG
            StringBuilder sb = new StringBuilder(256);
            sb.Append(tag);
            sb.AppendFormat(" Thread={0}", SafeNativeMethods.GetCurrentThreadId().ToString(CultureInfo.InvariantCulture));
            sb.AppendFormat(" Context={0}", (HttpContext.Current != null) ? HttpContext.Current.GetHashCode().ToString(CultureInfo.InvariantCulture) : "NULL_CTX");
            sb.AppendFormat(" Principal={0}", (Thread.CurrentPrincipal != null) ? Thread.CurrentPrincipal.GetHashCode().ToString(CultureInfo.InvariantCulture) : "NULL_PRIN");
            sb.AppendFormat(" Culture={0}", Thread.CurrentThread.CurrentCulture.LCID.ToString(CultureInfo.InvariantCulture));
            sb.AppendFormat(" UICulture={0}", Thread.CurrentThread.CurrentUICulture.LCID.ToString(CultureInfo.InvariantCulture));
            sb.AppendFormat(" ActivityID={0}", CallContext.LogicalGetData("E2ETrace.ActivityID"));
            return sb.ToString();
#else
            // This method should never be called in release mode.
            throw new NotImplementedException();
#endif
        }


        // Restores the thread's CurrentCulture and CurrentUICulture back to what
        // they were before this ThreadContext was associated with the thread. If
        // any culture has changed from its original value, we squirrel the new
        // culture away in HttpContext so that we can restore it the next time any
        // ThreadContext associated with this HttpContext is active.
        private void RestoreRequestLevelCulture() {
            CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
            CultureInfo currentUICulture = Thread.CurrentThread.CurrentUICulture;

            if (_originalThreadCurrentCulture != null) {
                // Avoid the cost of the Demand when setting the culture by comparing the cultures first
                if (currentCulture != _originalThreadCurrentCulture) {
                    HttpRuntime.SetCurrentThreadCultureWithAssert(_originalThreadCurrentCulture);
                    if (HttpContext != null) {
                        // remember changed culture for the rest of the request
                        HttpContext.DynamicCulture = currentCulture;
                    }
                }

                _originalThreadCurrentCulture = null;
            }

            if (_originalThreadCurrentUICulture != null) {
                // Avoid the cost of the Demand when setting the culture by comparing the cultures first
                if (currentUICulture != _originalThreadCurrentUICulture) {
                    Thread.CurrentThread.CurrentUICulture = _originalThreadCurrentUICulture;
                    if (HttpContext != null) {
                        // remember changed culture for the rest of the request
                        HttpContext.DynamicUICulture = currentUICulture;
                    }
                }

                _originalThreadCurrentUICulture = null;
            }
        }

        // Sets impersonation on the current thread.
        internal void SetImpersonationContext() {
            if (_newImpersonationContext == null) {
                _newImpersonationContext = CreateNewClientImpersonationContext();
            }
        }

        // Sets the thread's CurrentCulture and CurrentUICulture to those associated
        // with the current HttpContext. We do this since the culture of a request can
        // change over its lifetime and isn't necessarily the default for the AppDomain,
        // e.g. if the culture was read from the request headers.
        private void SetRequestLevelCulture() {
            CultureInfo culture = null;
            CultureInfo uiculture = null;

            GlobalizationSection globConfig = RuntimeConfig.GetConfig(HttpContext).Globalization;
            if (!String.IsNullOrEmpty(globConfig.Culture))
                culture = HttpContext.CultureFromConfig(globConfig.Culture, true);

            if (!String.IsNullOrEmpty(globConfig.UICulture))
                uiculture = HttpContext.CultureFromConfig(globConfig.UICulture, false);

            if (HttpContext.DynamicCulture != null)
                culture = HttpContext.DynamicCulture;

            if (HttpContext.DynamicUICulture != null)
                uiculture = HttpContext.DynamicUICulture;

            // Page also could have its own culture settings
            Page page = HttpContext.CurrentHandler as Page;

            if (page != null) {
                if (page.DynamicCulture != null)
                    culture = page.DynamicCulture;

                if (page.DynamicUICulture != null)
                    uiculture = page.DynamicUICulture;
            }

            _originalThreadCurrentCulture = Thread.CurrentThread.CurrentCulture;
            _originalThreadCurrentUICulture = Thread.CurrentThread.CurrentUICulture;

            if (culture != null && culture != Thread.CurrentThread.CurrentCulture) {
                HttpRuntime.SetCurrentThreadCultureWithAssert(culture);
            }

            if (uiculture != null && uiculture != Thread.CurrentThread.CurrentUICulture) {
                Thread.CurrentThread.CurrentUICulture = uiculture;
            }
        }

        // Use of IndicateCompletion requires that we synchronize the cultures
        // with what may have been set by user code during execution of the
        // notification.
        internal void Synchronize() {
            HttpContext.DynamicCulture = Thread.CurrentThread.CurrentCulture;
            HttpContext.DynamicUICulture = Thread.CurrentThread.CurrentUICulture;
        }

        // Undoes any impersonation that we did when associating this ThreadContext
        // with the current thread.
        internal void UndoImpersonationContext() {
            // remove impersonation on the current thread
            if (_newImpersonationContext != null) {
                _newImpersonationContext.Undo();
                _newImpersonationContext = null;
            }
        }

        // Called by AspNetSynchronizationContext to signal that it is finished
        // processing on the current thread.
        void ISyncContextLock.Leave() {
            DisassociateFromCurrentThread();
        }

    }
}