//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
 
namespace System.ServiceModel.Security
{
    using System.Globalization;
    using System.IdentityModel.Selectors;
    using System.Runtime;
    using System.Runtime.CompilerServices;
    using System.ServiceModel;
    using System.ServiceModel.Activation;
    using System.Web.Security;
 
    public sealed class UserNamePasswordServiceCredential
    {
        internal const UserNamePasswordValidationMode DefaultUserNamePasswordValidationMode = UserNamePasswordValidationMode.Windows;
        internal const bool DefaultCacheLogonTokens = false;
        internal const int DefaultMaxCachedLogonTokens = 128;
        internal const string DefaultCachedLogonTokenLifetimeString = "00:15:00";
        internal static readonly TimeSpan DefaultCachedLogonTokenLifetime = TimeSpan.Parse(DefaultCachedLogonTokenLifetimeString, CultureInfo.InvariantCulture);
 
        UserNamePasswordValidationMode validationMode = DefaultUserNamePasswordValidationMode;
        UserNamePasswordValidator validator;
        object membershipProvider;
        bool includeWindowsGroups = SspiSecurityTokenProvider.DefaultExtractWindowsGroupClaims;
        bool cacheLogonTokens = DefaultCacheLogonTokens;
        int maxCachedLogonTokens = DefaultMaxCachedLogonTokens;
        TimeSpan cachedLogonTokenLifetime = DefaultCachedLogonTokenLifetime;
        bool isReadOnly;
 
        internal UserNamePasswordServiceCredential()
        {
            // empty
        }
 
        internal UserNamePasswordServiceCredential(UserNamePasswordServiceCredential other)
        {
            this.includeWindowsGroups = other.includeWindowsGroups;
            this.membershipProvider = other.membershipProvider;
            this.validationMode = other.validationMode;
            this.validator = other.validator;
            this.cacheLogonTokens = other.cacheLogonTokens;
            this.maxCachedLogonTokens = other.maxCachedLogonTokens;
            this.cachedLogonTokenLifetime = other.cachedLogonTokenLifetime;
            this.isReadOnly = other.isReadOnly;
        }
 
        public UserNamePasswordValidationMode UserNamePasswordValidationMode 
        { 
            get 
            {
                return this.validationMode;
            } 
            set 
            {
                UserNamePasswordValidationModeHelper.Validate(value);
                ThrowIfImmutable();
                this.validationMode = value;
            } 
        }
 
        public UserNamePasswordValidator CustomUserNamePasswordValidator 
        { 
            get 
            {
                return this.validator; 
            } 
            set 
            {
                ThrowIfImmutable();
                this.validator = value;
            } 
        }
 
        public MembershipProvider MembershipProvider
        {
            get
            {
                return (MembershipProvider)this.membershipProvider;
            }
            set
            {
                ThrowIfImmutable();
                this.membershipProvider = value;
            }
        }
 
        public bool IncludeWindowsGroups
        {
            get
            {
                return this.includeWindowsGroups;
            }
            set
            {
                ThrowIfImmutable();
                this.includeWindowsGroups = value;
            }
        }
 
        public bool CacheLogonTokens
        {
            get
            {
                return this.cacheLogonTokens;
            }
            set
            {
                ThrowIfImmutable();
                this.cacheLogonTokens = value;
            }
        }
 
        public int MaxCachedLogonTokens
        {
            get
            {
                return this.maxCachedLogonTokens;
            }
            set
            {
                if (value <= 0)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", SR.GetString(SR.ValueMustBeGreaterThanZero)));
                }
                ThrowIfImmutable();
                this.maxCachedLogonTokens = value;
            }
        }
 
        public TimeSpan CachedLogonTokenLifetime
        {
            get
            {
                return this.cachedLogonTokenLifetime;
            }
            set
            {
                if (value <= TimeSpan.Zero)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", SR.GetString(SR.TimeSpanMustbeGreaterThanTimeSpanZero)));
                }
 
                if (TimeoutHelper.IsTooLarge(value))
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
                        SR.GetString(SR.SFxTimeoutOutOfRangeTooBig)));
                }
                ThrowIfImmutable();
                this.cachedLogonTokenLifetime = value;
            }
        }
 
        internal UserNamePasswordValidator GetUserNamePasswordValidator()
        {
            if (this.validationMode == UserNamePasswordValidationMode.MembershipProvider)
            {
                return this.GetMembershipProviderValidator();
            }
            else if (this.validationMode == UserNamePasswordValidationMode.Custom)
            {
                if (this.validator == null)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MissingCustomUserNamePasswordValidator)));
                }
                return this.validator;
            }
 
            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
        }
 
        [MethodImpl(MethodImplOptions.NoInlining)]
        UserNamePasswordValidator GetMembershipProviderValidator()
        {
            MembershipProvider provider;
 
            if (this.membershipProvider != null)
            {
                provider = (MembershipProvider)this.membershipProvider;
            }
            else
            {
                provider = SystemWebHelper.GetMembershipProvider();
            }
 
            if (provider == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MissingMembershipProvider)));
            }
            return UserNamePasswordValidator.CreateMembershipProviderValidator(provider);
        }
 
        internal void MakeReadOnly()
        {
            this.isReadOnly = true;
        }
 
        void ThrowIfImmutable()
        {
            if (this.isReadOnly)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
            }
        }
    }
}