//------------------------------------------------------------------------------
// <copyright file="SessionState.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
//------------------------------------------------------------------------------
 
/*
 * HttpSessionState
 * 
 * Copyright (c) 1998-1999, Microsoft Corporation
 * 
 */
 
namespace System.Web.SessionState {
 
    using System.Threading;
    using System.Runtime.InteropServices;
    using System.Web;
    using System.Web.Util;
    using System.Collections;
    using System.Collections.Specialized;
    using System.Text;
    using System.Globalization;
    using System.Security.Permissions;
 
    public class HttpSessionStateContainer : IHttpSessionState {
        String                      _id;
        ISessionStateItemCollection      _sessionItems;
        HttpStaticObjectsCollection _staticObjects;
        int                         _timeout;
        bool                        _newSession;
        HttpCookieMode              _cookieMode;
        SessionStateMode            _mode;
        bool                        _abandon;
        bool                        _isReadonly;
        SessionStateModule          _stateModule;   // used for optimized InProc session id callback
 
        public HttpSessionStateContainer(
                                 String                      id, 
                                 ISessionStateItemCollection sessionItems,
                                 HttpStaticObjectsCollection staticObjects,
                                 int                         timeout,
                                 bool                        newSession,
                                 HttpCookieMode              cookieMode,
                                 SessionStateMode            mode,
                                 bool                        isReadonly) 
            : this(null, id, sessionItems, staticObjects, timeout, newSession, cookieMode, mode, isReadonly) {
            if (id == null) {
                throw new ArgumentNullException("id");
            }
        }
 
        internal HttpSessionStateContainer(
                                 SessionStateModule          stateModule, 
                                 string                      id,
                                 ISessionStateItemCollection      sessionItems,
                                 HttpStaticObjectsCollection staticObjects,
                                 int                         timeout,
                                 bool                        newSession,
                                 HttpCookieMode              cookieMode,
                                 SessionStateMode            mode,
                                 bool                        isReadonly) {
            _stateModule = stateModule;
            _id = id;   // If null, it means we're delaying session id reading
            _sessionItems = sessionItems;
            _staticObjects = staticObjects;
            _timeout = timeout;    
            _newSession = newSession; 
            _cookieMode = cookieMode;
            _mode = mode;
            _isReadonly = isReadonly;
        }
 
        internal HttpSessionStateContainer() {
        }
 
        /*
         * The Id of the session.
         */
        public String SessionID {
            get {
                if (_id == null) {
                    Debug.Assert(_stateModule != null, "_stateModule != null");
                    _id = _stateModule.DelayedGetSessionId();
                }
                return _id;
            }
        }
 
        /*
         * The length of a session before it times out, in minutes.
         */
        public int Timeout {
            get {return _timeout;}
            set {
                if (value <= 0) {
                    throw new ArgumentException(SR.GetString(SR.Timeout_must_be_positive));
                }
 
                if (value > SessionStateModule.MAX_CACHE_BASED_TIMEOUT_MINUTES &&
                    (Mode == SessionStateMode.InProc ||
                    Mode == SessionStateMode.StateServer)) {
                    throw new ArgumentException(
                        SR.GetString(SR.Invalid_cache_based_session_timeout));
                }
 
                _timeout = value;
            }
        }
 
        /*
         * Is this a new session?
         */
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public bool IsNewSession {
            get {return _newSession;}
        }
 
        /*
         * Is session state in a separate process
         */
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public SessionStateMode Mode {
            get {return _mode;}
        }
 
        /*
         * Is session state cookieless?
         */
        public bool IsCookieless {
            get {
                if (_stateModule != null) {
                    // See VSWhidbey 399907
                    return _stateModule.SessionIDManagerUseCookieless;
                }
                else {
                    // For container created by custom session state module,
                    // sorry, we currently don't have a way to tell and thus we rely blindly
                    // on cookieMode.
                    return CookieMode == HttpCookieMode.UseUri;
                }
            }
        }
 
        public HttpCookieMode CookieMode {
            get {return _cookieMode;}
        }
 
        /*
         * Abandon the session.
         * 
         */
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void Abandon() {
            _abandon = true;
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public int LCID {
            // 
 
 
            get { return Thread.CurrentThread.CurrentCulture.LCID; }
            set { Thread.CurrentThread.CurrentCulture = HttpServerUtility.CreateReadOnlyCultureInfo(value); }
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public int CodePage {
            // 
 
 
            get { 
                if (HttpContext.Current != null)
                    return HttpContext.Current.Response.ContentEncoding.CodePage;
                else
                    return Encoding.Default.CodePage;
            }
            set { 
                if (HttpContext.Current != null)
                    HttpContext.Current.Response.ContentEncoding = Encoding.GetEncoding(value);
            }
        }
 
        public bool IsAbandoned {
            get {return _abandon;}
        }
 
        public HttpStaticObjectsCollection StaticObjects {
            get { return _staticObjects;}
        }
 
        public Object this[String name]
        {
            get {
                return _sessionItems[name];
            }
            set {
                _sessionItems[name] = value;
            }
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public Object this[int index]
        {
            get {return _sessionItems[index];}
            set {_sessionItems[index] = value;}
        }
        
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void Add(String name, Object value) {
            _sessionItems[name] = value;        
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void Remove(String name) {
            _sessionItems.Remove(name);
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void RemoveAt(int index) {
            _sessionItems.RemoveAt(index);
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void Clear() {
            _sessionItems.Clear();
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void RemoveAll() {
            Clear();
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public int Count {
            get {return _sessionItems.Count;}
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public NameObjectCollectionBase.KeysCollection Keys {
            get {return _sessionItems.Keys;}
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public IEnumerator GetEnumerator() {
            return _sessionItems.GetEnumerator();
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void CopyTo(Array array, int index) {
            for (IEnumerator e = this.GetEnumerator(); e.MoveNext();)
                array.SetValue(e.Current, index++);
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public Object SyncRoot {
            get { return this;}
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public bool IsReadOnly {
            get { return _isReadonly;}
        }
 
 
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public bool IsSynchronized {
            get { return false;}
        }
    }
}