//
// System.ServiceModel.EndpointAddress.cs
//
// Author: Duncan Mak (duncan@novell.com)
//	   Atsushi Enomoto (atsushi@ximian.com)
//
// Copyright (C) 2005-2006 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.IO;
using System.Reflection;
using System.Resources;
using System.Runtime.Serialization;
using System.Security.Cryptography.X509Certificates;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;

namespace System.ServiceModel
{
	public class EndpointAddress
	{
		static readonly Uri w3c_anonymous = new Uri (Constants.WsaAnonymousUri);
		static readonly Uri anonymous_role = new Uri ("http://schemas.microsoft.com/2005/12/ServiceModel/Addressing/Anonymous");
		static readonly Uri none_role = new Uri ("http://schemas.microsoft.com/2005/12/ServiceModel/Addressing/None");

		public static Uri AnonymousUri {
			get { return anonymous_role; }
		}

		public static Uri NoneUri {
			get { return none_role; }
		}

		Uri address;
		AddressHeaderCollection headers;
		EndpointIdentity identity;
		XmlDictionaryReader metadata_reader;
		XmlDictionaryReader extension_reader;

		static XmlSchema schema;

		public EndpointAddress (string uri)
			: this (new Uri (uri), new AddressHeader [0])
		{
		}

		public EndpointAddress (Uri uri, params AddressHeader [] headers)
			: this (uri, null, new AddressHeaderCollection (headers), null, null) {}

		public EndpointAddress (Uri uri, EndpointIdentity identity, params AddressHeader [] headers)
			: this (uri, identity, new AddressHeaderCollection (headers), null, null) {}

		public EndpointAddress (Uri uri, EndpointIdentity identity, AddressHeaderCollection headers)
			: this (uri, identity, headers, null, null) {}

		public EndpointAddress (
			Uri uri, EndpointIdentity identity,
			AddressHeaderCollection headers,
			XmlDictionaryReader metadataReader,
			XmlDictionaryReader extensionReader)
		{	
			if (uri == null)
				throw new ArgumentNullException ("uri");
			if (!uri.IsAbsoluteUri)
				throw new ArgumentException ("The argument uri must be absolute");
			this.address = uri;
			this.identity = identity;
			this.headers = headers;
			metadata_reader = metadataReader;
			extension_reader = extensionReader;
		}

		public bool IsAnonymous {
			get { return address.Equals (anonymous_role); }
		}

		public bool IsNone {
			get { return address.Equals (none_role); }
		}

		public AddressHeaderCollection Headers {
			get { return headers; }
		}

		public EndpointIdentity Identity {
			get { return identity; }
		}

		public Uri Uri {
			get { return address; }
		}

#if !NET_2_1
		internal static XmlSchema Schema {
			get {
				if (schema == null) {
					Assembly a = Assembly.GetCallingAssembly ();
					Stream s = a.GetManifestResourceStream ("WS-Addressing.schema");
					schema = XmlSchema.Read (s, null);
				}

				return schema;
			}
		}
#endif

		[MonoTODO]
		public void ApplyTo (Message message)
		{
			throw new NotImplementedException ();
		}

		public override bool Equals (object obj)
		{
			EndpointAddress other = obj as EndpointAddress;
			if (other == null || 
			    other.Uri == null || !other.Uri.Equals (this.Uri) ||
			    other.Headers.Count != this.Headers.Count)
				return false;

			foreach (AddressHeader h in this.Headers) {
				bool match = false;
				foreach (AddressHeader o in other.Headers)
					if (h.Equals (o)) {
						match = true;
						break;
					}
				if (!match)
					return false;
			}

			return true;
		}

		public override int GetHashCode ()
		{
			return address.GetHashCode ();
		}

		public XmlDictionaryReader GetReaderAtExtensions ()
		{
			return extension_reader;
		}

		public XmlDictionaryReader GetReaderAtMetadata ()
		{
			return metadata_reader;
		}

		public static bool operator == (EndpointAddress address1, EndpointAddress address2)
		{
			if ((object) address1 == null)
				return (object) address2 == null;
			if ((object) address2 == null)
				return false;
			return address1.Equals (address2);
		}

		public static bool operator != (EndpointAddress address1, EndpointAddress address2)
		{
			return ! (address1 == address2);
		}

//#if !NET_2_1
		[MonoTODO]
		public static EndpointAddress ReadFrom (
			XmlDictionaryReader reader)
		{
			if (reader == null)
				throw new ArgumentNullException ("reader");

			return ReadFromInternal (null, reader);
		}

		[MonoTODO]
		public static EndpointAddress ReadFrom (
			AddressingVersion addressingVersion,
			XmlDictionaryReader reader)
		{
			return ReadFrom (addressingVersion, (XmlReader) reader);
		}

		[MonoTODO]
		public static EndpointAddress ReadFrom (
			AddressingVersion addressingVersion,
			XmlReader reader)
		{
			if (addressingVersion == null)
				throw new ArgumentNullException ("addressingVersion");
			if (reader == null)
				throw new ArgumentNullException ("reader");

			return ReadFromInternal (addressingVersion, reader);
		}

		[MonoTODO]
		public static EndpointAddress ReadFrom (
			XmlDictionaryReader reader,
			XmlDictionaryString localName,
			XmlDictionaryString ns)
		{
			return ReadFrom (AddressingVersion.WSAddressing10,
					 reader, localName, ns);
		}


		[MonoTODO]
		public static EndpointAddress ReadFrom (
			AddressingVersion addressingVersion,
			XmlDictionaryReader reader,
			XmlDictionaryString localName,
			XmlDictionaryString ns)
		{
			throw new NotImplementedException ();
		}

		[MonoTODO]
		public static EndpointAddress ReadFrom (
			AddressingVersion addressingVersion,
			XmlReader reader, string localname, string ns)
		{
			throw new NotImplementedException ();
		}

		private static EndpointAddress ReadFromInternal (
			AddressingVersion addressingVersion,
			XmlReader reader)
		{
			reader.MoveToContent ();
			if (reader.NodeType != XmlNodeType.Element ||
			    reader.IsEmptyElement)
				throw new ArgumentException ("Cannot detect appropriate WS-Addressing Address element.");

			reader.Read ();
			reader.MoveToContent ();

			if (addressingVersion == null) {
				if (reader.NamespaceURI == AddressingVersion.WSAddressing10.Namespace)
					addressingVersion = AddressingVersion.WSAddressing10;
				else
				if (reader.NamespaceURI == AddressingVersion.WSAddressingAugust2004.Namespace)
					addressingVersion = AddressingVersion.WSAddressingAugust2004;
				else
					throw new ArgumentException ("Cannot detect appropriate WS-Addressing version.");
			}

			EndpointAddress ea = ReadContents (addressingVersion, reader);

			reader.MoveToContent ();
			reader.ReadEndElement ();
			return ea;
		}
		
		private static EndpointAddress ReadContents (
			AddressingVersion addressingVersion, XmlReader reader)
		{
			Uri uri = null;
			EndpointIdentity identity = null;
			reader.MoveToContent ();
			if (reader.LocalName == "Address" && 
			    reader.NamespaceURI == addressingVersion.Namespace &&
			    reader.NodeType == XmlNodeType.Element &&
			    !reader.IsEmptyElement)
				uri = new Uri (reader.ReadElementContentAsString ());
			else
				throw new XmlException (String.Format (
					"Expecting 'Address' from namespace '{0}', but found '{1}' from namespace '{2}'",
					addressingVersion.Namespace, reader.LocalName, reader.NamespaceURI));

			reader.MoveToContent ();
#if !NET_2_1
			MetadataSet metadata = null;
			if (reader.LocalName == "Metadata" &&
			    reader.NamespaceURI == addressingVersion.Namespace &&
			    !reader.IsEmptyElement) {
				reader.Read ();
				metadata = (MetadataSet) new XmlSerializer (typeof (MetadataSet)).Deserialize (reader);
				reader.MoveToContent ();
				reader.ReadEndElement ();
			}
			reader.MoveToContent ();
			if (reader.LocalName == "Identity" &&
			    reader.NamespaceURI == Constants.WsaIdentityUri) {
				// FIXME: implement
				reader.Skip ();
			}
#endif

			if (addressingVersion == AddressingVersion.WSAddressing10 && uri == w3c_anonymous)
				uri = anonymous_role;

#if NET_2_1
			return new EndpointAddress (uri, identity);
#else
			if (metadata == null)
				return new EndpointAddress (uri, identity);
			return new EndpointAddress (uri, identity,
				AddressHeader.CreateAddressHeader (metadata));
#endif
		}

		public override string ToString ()
		{
			return address.ToString (); 
		}

		[MonoTODO]
		public void WriteContentsTo (
			AddressingVersion addressingVersion,
			XmlDictionaryWriter writer)
		{
#if NET_2_1
			writer.WriteString (Uri.AbsoluteUri);
#else
			if (addressingVersion == AddressingVersion.WSAddressing10) {
				((IXmlSerializable) EndpointAddress10.FromEndpointAddress (this)).WriteXml (writer);
			} else {
				writer.WriteString (Uri.AbsoluteUri);
			}
#endif
		}

		public void WriteContentsTo (
			AddressingVersion addressingVersion,
			XmlWriter writer)
		{
			WriteContentsTo (addressingVersion,
				XmlDictionaryWriter.CreateDictionaryWriter (writer));
		}

		public void WriteTo (
			AddressingVersion addressingVersion,
			XmlDictionaryWriter writer)
		{
			WriteTo (addressingVersion, writer, "EndpointReference", addressingVersion.Namespace);
		}

		public void WriteTo (
			AddressingVersion addressingVersion, XmlWriter writer)
		{
			WriteTo (addressingVersion,
				XmlDictionaryWriter.CreateDictionaryWriter (writer));
		}

		public void WriteTo (
			AddressingVersion addressingVersion,
			XmlDictionaryWriter writer,
			XmlDictionaryString localname,
			XmlDictionaryString ns)
		{
			writer.WriteStartElement (localname, ns);
			WriteContentsTo (addressingVersion, writer);
			writer.WriteEndElement ();
		}

		public void WriteTo (
			AddressingVersion addressingVersion,
			XmlWriter writer, string localname, string ns)
		{
			writer.WriteStartElement (localname, ns);
			WriteContentsTo (addressingVersion, writer);
			writer.WriteEndElement ();
		}
	}
}