//------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//------------------------------------------------------------
 
namespace System.ServiceModel.Security
{
    using System.Diagnostics;
    using System.ServiceModel.Channels;
    using System.ServiceModel;
    using System.Globalization;    
    using System.Xml;
    using System.IO;
 
    using ISecurityElement = System.IdentityModel.ISecurityElement;
 
    sealed class EncryptedHeader : DelegatingHeader
    {
        EncryptedHeaderXml headerXml;
        string name;
        string namespaceUri;
        MessageVersion version;
 
        public EncryptedHeader(MessageHeader plainTextHeader, EncryptedHeaderXml headerXml, string name, string namespaceUri, MessageVersion version)
            : base(plainTextHeader)
        {
            if (!headerXml.HasId || headerXml.Id == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.EncryptedHeaderXmlMustHaveId)));
            }
            this.headerXml = headerXml;
            this.name = name;
            this.namespaceUri = namespaceUri;
            this.version = version;
        }
 
        public string Id
        {
            get { return this.headerXml.Id; }
        }
 
        public override string Name
        {
            get { return this.name; }
        }
 
        public override string Namespace
        {
            get { return this.namespaceUri; }
        }
 
        public override string Actor
        {
            get
            {
                return this.headerXml.Actor;
            }
        }
 
        public override bool MustUnderstand
        {
            get
            {
                return this.headerXml.MustUnderstand;
            }
        }
 
        public override bool Relay
        {
            get
            {
                return this.headerXml.Relay;
            }
        }
 
        internal MessageHeader OriginalHeader
        {
            get { return this.InnerHeader; }
        }
 
        public override bool IsMessageVersionSupported(MessageVersion messageVersion)
        {
            return this.version.Equals( messageVersion );
        }
 
        protected override void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
        {
            if (!IsMessageVersionSupported(messageVersion))
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.MessageHeaderVersionNotSupported, String.Format(CultureInfo.InvariantCulture, "{0}:{1}", this.Namespace, this.Name), version.ToString()), "version"));
            }
 
            this.headerXml.WriteHeaderElement(writer);
            WriteHeaderAttributes(writer, messageVersion);
            this.headerXml.WriteHeaderId(writer);
        }
 
        protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
        {
            this.headerXml.WriteHeaderContents(writer);
        }
    }
}