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

/*
 * Request timeout manager -- implements the request timeout mechanism
 */
namespace System.Web {
    using System.Threading;
    using System.Collections;
    using System.Web.Util;

    internal class RequestTimeoutManager {
        private int                 _requestCount;
        private DoubleLinkList[]    _lists;           // partitioned to avoid contention
        private int                 _currentList;
        private int                 _inProgressLock;  // only 1 thread can be cancelling
        private readonly TimeSpan   _timerPeriod = new TimeSpan(0, 0, 15); // 15 second init precision
        private Timer               _timer;

        internal RequestTimeoutManager() {
            // initialize request lists

            _requestCount = 0;

            _lists = new DoubleLinkList[13];
            for (int i = 0; i < _lists.Length; i++)
                _lists[i] = new DoubleLinkList();
            _currentList = 0;

            // init lock

            _inProgressLock = 0;

            // create the timer

#if DBG
            if (!Debug.IsTagPresent("Timer") || Debug.IsTagEnabled("Timer"))
#endif
            {
                _timer = new Timer(new TimerCallback(this.TimerCompletionCallback), null, _timerPeriod, _timerPeriod);
            }

        }

        internal void Stop() {
            // stop the timer

            if (_timer != null) {
                ((IDisposable)_timer).Dispose();
                _timer = null;
            }

            while (_inProgressLock != 0)
                Thread.Sleep(100);

            // cancel all cancelable requests

            if (_requestCount > 0)
                CancelTimedOutRequests(DateTime.UtcNow.AddYears(1)); // future date
        }

        private void TimerCompletionCallback(Object state) {
            if (_requestCount > 0)
                CancelTimedOutRequests(DateTime.UtcNow);
        }

        private void CancelTimedOutRequests(DateTime now) {

            // only one thread can be doing it

            if (Interlocked.CompareExchange(ref _inProgressLock, 1, 0) != 0)
                return;

            // collect them all into a separate list with minimal locking

            ArrayList entries = new ArrayList(_requestCount); // size can change
            DoubleLinkListEnumerator en;

            for (int i = 0; i < _lists.Length; i++) {
                lock (_lists[i]) {
                    en = _lists[i].GetEnumerator();

                    while (en.MoveNext())
                        entries.Add(en.GetDoubleLink());

                    en = null;
                }
            }

            // walk through the collected list to timeout what's needed

            int n = entries.Count;

            for (int i = 0; i < n; i++)
                ((RequestTimeoutEntry)entries[i]).TimeoutIfNeeded(now);

            // this thread is done -- unlock

            Interlocked.Exchange(ref _inProgressLock, 0);
        }

        internal void Add(HttpContext context) {
            if (context.TimeoutLink != null) {
                ((RequestTimeoutEntry)context.TimeoutLink).IncrementCount();
                return;
            }
           
            // create new entry

            RequestTimeoutEntry entry = new RequestTimeoutEntry(context);

            // add it to the list

            int i = _currentList++;
            if (i >= _lists.Length) {
                i = 0;
                _currentList = 0;
            }

            entry.AddToList(_lists[i]);
            Interlocked.Increment(ref _requestCount);

            // update HttpContext
            context.TimeoutLink = entry;
        }

        internal void Remove(HttpContext context) {
            RequestTimeoutEntry entry = (RequestTimeoutEntry)context.TimeoutLink;

            // remove from the list
            if (entry != null) {
                if( entry.DecrementCount() == 0 ) {
                    entry.RemoveFromList();
                    Interlocked.Decrement(ref _requestCount);
                } else {
                    return;
                }
            }

            // update HttpContext
            context.TimeoutLink = null;
        }

        private class RequestTimeoutEntry : DoubleLink {
            private  HttpContext    _context;   // the request
            private  DoubleLinkList _list;
            private int _count;

            internal RequestTimeoutEntry(HttpContext context) {
                _context = context;
                _count = 1;
            }

            internal void AddToList(DoubleLinkList list) {
                lock(list) {
                    list.InsertTail(this);
                    _list = list;
                }
            }

            internal void RemoveFromList() {
                if (_list != null) {
                    lock(_list) {
                        Remove();
                        _list = null;
                    }
                }
            }

            internal void TimeoutIfNeeded(DateTime now) {
                Thread thread = _context.MustTimeout(now);
                if (thread != null) {
                    RemoveFromList();
                    thread.Abort(new HttpApplication.CancelModuleException(true));
                }
            }

            internal void IncrementCount() {
                Interlocked.Increment( ref _count );
            }

            internal int DecrementCount() {
                return Interlocked.Decrement( ref _count );
            }
        }
    }

}