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

namespace System.IdentityModel.Protocols.WSTrust
{
    /// <summary>
    /// Base class for RST and RSTR.
    /// </summary>
    public abstract class WSTrustMessage : OpenObject
    {
        private bool allowPostdating;
        private EndpointReference appliesTo;
        private string replyTo;
        private string authenticationType;
        private string canonicalizationAlgorithm;
        private string context;
        private string encryptionAlgorithm;
        private Entropy entropy;
        private string issuedTokenEncryptionAlgorithm;
        private string keyWrapAlgorithm;
        private string issuedTokenSignatureAlgorithm;
        private int? keySizeInBits;
        private string keyType;
        private Lifetime lifetime;
        private string requestType;
        private string signatureAlgorithm;
        private string tokenType;
        private UseKey useKey;
        private BinaryExchange binaryExchange;

        /// <summary>
        /// Default constructor for extensibility.
        /// </summary>
        protected WSTrustMessage()
        {
        }

        /// <summary>
        /// Gets or sets a value indicating whether the returned tokens should allow requsts for postdated
        /// tokens.
        /// </summary>
        /// <remarks>
        /// This property is usually used in the token renewal scenario.
        /// </remarks>
        /// <devdocs>
        /// Please refer to section 7 in the WS-Trust spec for more details.
        /// </devdocs>
        public bool AllowPostdating
        {
            get
            {
                return this.allowPostdating;
            }
            
            set
            {
                this.allowPostdating = value;
            }
        }

        /// <summary>
        /// Gets or sets this optional element that specifies the endpoint address for which this security token is desired.
        /// For example, the service to which this token applies.
        /// </summary>
        /// <remarks>
        /// Either TokenType or AppliesTo SHOULD be defined in the token request message. If both 
        /// are specified, the AppliesTo field takes precedence.
        /// </remarks>
        public EndpointReference AppliesTo
        {
            get
            {
                return this.appliesTo;
            }
            
            set
            {
                this.appliesTo = value;
            }
        }

        /// <summary>
        /// Gets or sets the binary data that is exchanged.
        /// </summary>
        public BinaryExchange BinaryExchange
        {
            get
            {
                return this.binaryExchange;
            }
            
            set
            {
                this.binaryExchange = value;
            }
        }

        /// <summary>
        /// Gets or sets the address to be used for replying to the Relying Party.
        /// </summary>
        /// <remarks>
        /// This is a local extension for WS-Fed Passive scenario.
        /// </remarks>
        public string ReplyTo
        {
            get
            {
                return this.replyTo;
            }
           
            set
            {
                this.replyTo = value;
            }
        }

        /// <summary>
        /// Gets or sets the optional element indicates the type of authencation desired,
        /// specified as a URI.
        /// </summary>
        public string AuthenticationType
        {
            get
            {
                return this.authenticationType;
            }
            
            set
            {
                this.authenticationType = value;
            }
        }

        /// <summary>
        /// Gets or sets the CanonicalizationAlgorithm.
        /// </summary>
        public string CanonicalizationAlgorithm
        {
            get
            {
                return this.canonicalizationAlgorithm;
            }
            
            set
            {
                this.canonicalizationAlgorithm = value;
            }
        }

        /// <summary>
        /// Gets or sets the optional context element specifies an identifier/context for this request.
        /// </summary>
        /// <remarks>
        /// All subsequent RSTR elements relating to this request MUST carry this attribute.
        /// </remarks>
        public string Context
        {
            get
            {
                return this.context;
            }
            
            set
            {
                this.context = value;
            }
        }

        /// <summary>
        /// Gets or sets the EncryptionAlgorithm.
        /// </summary>
        public string EncryptionAlgorithm
        {
            get
            {
                return this.encryptionAlgorithm;
            }
            
            set
            {
                this.encryptionAlgorithm = value;
            }
        }

        /// <summary>
        /// Gets or sets this optional element that allows a requestor to specify entropy that is to 
        /// be used in creating the key.
        /// </summary>
        /// <remarks>
        /// This is commonly used in a token issuance request message. The value of this element
        /// SHOULD be either an EncryptedKey or BinarySecret depending on whether or not the key 
        /// is encrypted. 
        /// </remarks>
        /// <devdocs>
        /// It is defined in the section 6.1 in the WS-Trust spec.
        /// </devdocs>
        public Entropy Entropy
        {
            get
            {
                return this.entropy;
            }
            
            set
            {
                this.entropy = value;
            }
        }

        /// <summary>
        /// Gets or sets this optional URI element that indicates the desired encryption algorithm to be used
        /// with the issued security token.
        /// </summary>
        /// <remarks>
        /// This is an extension to the RequestSecurityToken element. 
        /// </remarks>
        /// <deodocs>
        /// It is defined in the section 11.2 in the WS-Trust spec.
        /// </deodocs>
        /// <exception cref="ArgumentNullException">When the given value is null or an empty string.</exception>
        public string EncryptWith
        {
            get
            {
                return this.issuedTokenEncryptionAlgorithm;
            }
            
            set
            {
                if (string.IsNullOrEmpty(value))
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("IssuedTokenEncryptionAlgorithm");
                }

                this.issuedTokenEncryptionAlgorithm = value;
            }
        }

        /// <summary>
        /// Gets or sets this optional URI element that indicates the desired signature algorithm to be used
        /// with the issued security token.
        /// </summary>
        /// <remarks>
        /// This is an extension to the RequestSecurityToken element. 
        /// </remarks>
        /// <deodocs>
        /// It is defined in the section 11.2 in the WS-Trust spec.
        /// </deodocs>
        /// <exception cref="ArgumentNullException">When the given IssuedTokenSignatureAlgorithm algorithm value is null or string.empty.</exception>
        public string SignWith
        {
            get
            {
                return this.issuedTokenSignatureAlgorithm;
            }
            
            set
            {
                if (string.IsNullOrEmpty(value))
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
                }

                this.issuedTokenSignatureAlgorithm = value;
            }
        }

        /// <summary>
        /// Gets or sets this element that defines the KeySize element inside the RequestSecurityToken message
        /// It is specified in bits.
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">When the given KeySizeInBits value is less than or equal to zero.</exception>
        public int? KeySizeInBits
        {
            get
            {
                return this.keySizeInBits;
            }
            
            set
            {
                if (value.HasValue && value.Value < 0)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
                }

                this.keySizeInBits = value;
            }
        }

        /// <summary>
        /// Gets or sets the KeyTypeOption element inside the RequestSecurityToken message.
        /// </summary>
        /// <remarks>
        /// This optional URI element indicates the type of key desired in the security
        /// token. 
        /// </remarks>
        /// <devdocs>
        /// Please refer to the section 11.2 in the WS-Trust spec for further details.
        /// </devdocs>
        public string KeyType
        {
            get
            {
                return this.keyType;
            }
            
            set
            {
                this.keyType = value;
            }
        }

        /// <summary>
        /// Gets or sets optional URI indicates the desired algorithm to use for key 
        /// wrapping when STS encrypts the issued token for the relying party 
        /// using an asymmetric key. 
        /// </summary>
        public string KeyWrapAlgorithm
        {
            get
            {
                return this.keyWrapAlgorithm;
            }
            
            set
            {
                this.keyWrapAlgorithm = value;
            }
        }

        /// <summary>
        /// Gets or sets the Lifetime element inside the RequestSecurityToken message.
        /// </summary>
        public Lifetime Lifetime
        {
            get
            {
                return this.lifetime;
            }
            
            set
            {
                this.lifetime = value;
            }
        }

        /// <summary>
        /// Gets or sets the required element that indicates the request type.
        /// </summary>
        public string RequestType
        {
            get
            {
                return this.requestType;
            }
            
            set
            {
                this.requestType = value;
            }
        }

        /// <summary>
        /// Gets or sets the SignatureAlgorithm.
        /// </summary>
        public string SignatureAlgorithm
        {
            get
            {
                return this.signatureAlgorithm;
            }
            
            set
            {
                this.signatureAlgorithm = value;
            }
        }

        /// <summary>
        /// Gets or sets the desired token type.
        /// </summary>
        public string TokenType
        {
            get
            {
                return this.tokenType;
            }
           
            set
            {
                this.tokenType = value;
            }
        }

        /// <summary>
        /// Gets or sets the element, which tf the requestor wishes to use an existing key rather than create a new one, 
        /// then this property can be used to reference a security token containing 
        /// the desired key. 
        /// </summary>
        /// <remarks>
        /// This is commonly used in the asymetric key issurance case. On the wire, it will be 
        /// serialized out as a subelement in UseKey element.
        /// </remarks>
        public UseKey UseKey
        {
            get
            {
                return this.useKey;
            }
            
            set
            {
                this.useKey = value;
            }
        }
    }
}