/*++
Copyright (c) Microsoft Corporation
 
Module Name:
 
    RequestCacheManager.cs
 
Abstract:
    The class implements the app domain wide configuration
    for request cache aware clients
 
Author:
 
    Alexei Vopilov    21-Dec-2002
 
Revision History:
 
    Jan 25 2004 - Changed the visibility of the class from public to internal, compressed unused logic.
 
--*/
namespace System.Net.Cache {
using System;
using System.Collections;
using System.Net.Configuration;
using System.Configuration;
 
 
    /// <summary>  Specifies app domain-wide default settings for request caching </summary>
    internal sealed class RequestCacheManager {
        private RequestCacheManager() {}
 
        private static volatile RequestCachingSectionInternal s_CacheConfigSettings;
 
        private static readonly RequestCacheBinding s_BypassCacheBinding = new RequestCacheBinding (null, null, new RequestCachePolicy(RequestCacheLevel.BypassCache));
 
        private static volatile RequestCacheBinding s_DefaultGlobalBinding;
        private static volatile RequestCacheBinding s_DefaultHttpBinding;
        private static volatile RequestCacheBinding s_DefaultFtpBinding;
 
        //
        // ATN: the caller MUST use uri.Scheme as a parameter, otheriwse cannot do schme ref comparision
        //
        internal static RequestCacheBinding GetBinding(string internedScheme)
        {
            if (internedScheme == null)
                throw new ArgumentNullException("uriScheme");
 
            if (s_CacheConfigSettings == null)
                LoadConfigSettings();
 
            if(s_CacheConfigSettings.DisableAllCaching)
                return s_BypassCacheBinding;
 
            if (internedScheme.Length == 0)
                return s_DefaultGlobalBinding;
 
            if ((object)internedScheme == (object)Uri.UriSchemeHttp || (object)internedScheme == (object)Uri.UriSchemeHttps)
                return s_DefaultHttpBinding;
 
            if ((object)internedScheme == (object)Uri.UriSchemeFtp)
                return s_DefaultFtpBinding;
 
            return s_BypassCacheBinding;
        }
 
        internal static bool IsCachingEnabled
        {
            get
            {
                if (s_CacheConfigSettings == null)
                    LoadConfigSettings();
 
                return !s_CacheConfigSettings.DisableAllCaching;
            }
        }
 
        //
        internal static void SetBinding(string uriScheme, RequestCacheBinding binding)
        {
            if (uriScheme == null)
                throw new ArgumentNullException("uriScheme");
 
            if (s_CacheConfigSettings == null)
                LoadConfigSettings();
 
            if(s_CacheConfigSettings.DisableAllCaching)
                return;
 
            if (uriScheme.Length == 0)
                s_DefaultGlobalBinding = binding;
            else if (uriScheme == Uri.UriSchemeHttp || uriScheme == Uri.UriSchemeHttps)
                s_DefaultHttpBinding = binding;
            else if (uriScheme == Uri.UriSchemeFtp)
                s_DefaultFtpBinding = binding;
        }
        //
        private static void LoadConfigSettings()
        {
            // Any concurent access shall go here and block until we've grabbed the config settings
            lock (s_BypassCacheBinding)
            {
                if (s_CacheConfigSettings == null)
                {
                    RequestCachingSectionInternal settings = RequestCachingSectionInternal.GetSection();
 
                    s_DefaultGlobalBinding = new RequestCacheBinding (settings.DefaultCache, settings.DefaultHttpValidator, settings.DefaultCachePolicy);
                    s_DefaultHttpBinding = new RequestCacheBinding (settings.DefaultCache, settings.DefaultHttpValidator, settings.DefaultHttpCachePolicy);
                    s_DefaultFtpBinding = new RequestCacheBinding (settings.DefaultCache, settings.DefaultFtpValidator, settings.DefaultFtpCachePolicy);
 
                    s_CacheConfigSettings = settings;
                }
            }
        }
    }
 
    //
    //
    internal class RequestCacheBinding  {
        private RequestCache          m_RequestCache;
        private RequestCacheValidator m_CacheValidator;
        private RequestCachePolicy    m_Policy;
 
 
        internal RequestCacheBinding (RequestCache requestCache, RequestCacheValidator cacheValidator, RequestCachePolicy  policy) {
            m_RequestCache = requestCache;
            m_CacheValidator = cacheValidator;
            m_Policy = policy;
        }
 
        internal RequestCache Cache {
            get {return m_RequestCache;}
        }
 
        internal RequestCacheValidator Validator {
            get {return m_CacheValidator;}
        }
 
        internal RequestCachePolicy Policy {
            get {return m_Policy;}
        }
 
    }
}