/*

   * Licensed to the Apache Software Foundation (ASF) under one or more

   * contributor license agreements.  See the NOTICE file distributed with

   * this work for additional information regarding copyright ownership.

   * The ASF licenses this file to You under the Apache License, Version 2.0

   * (the "License"); you may not use this file except in compliance with

   * the License.  You may obtain a copy of the License at

   *

   *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.wicket.markup.parser;

 import java.util.Iterator;

 import java.util.Map;

 import org.apache.wicket.markup.MarkupElement;

 import org.apache.wicket.util.lang.EnumeratedType;

 import org.apache.wicket.util.lang.Objects;

 import org.apache.wicket.util.string.AppendingStringBuffer;

 import org.apache.wicket.util.string.StringValue;

 import org.apache.wicket.util.string.Strings;

 import org.apache.wicket.util.value.IValueMap;

 import org.apache.wicket.util.value.ValueMap;

 public class XmlTag extends MarkupElement

 {
	

 	public static final Type CLOSE = new Type("CLOSE");

	

 	public static final Type OPEN = new Type("OPEN");

	

 	public static final Type OPEN_CLOSE = new Type("OPEN_CLOSE");

	

 	private IValueMap attributes;

	

 	int columnNumber;

	

 	int length;

	

 	int lineNumber;

	

 	String name;

	

 	String namespace;

	

 	int pos;

	

 	CharSequence text;

	

 	Type type;

	

 	private XmlTag closes;

	

 	private XmlTag copyOf = this;

	

 	private boolean isMutable = true;

	

 	private boolean nameChanged = false;

	

 	public static final class Type extends EnumeratedType

 	{

 		private static final long serialVersionUID = 1L;

		

		Type(final String name)

		{

			super(name);

		}

	}

	

	public XmlTag()

	{

		super();

	}

	

	public final boolean closes(final XmlTag open)

	{

		return (closes == open) || (closes == open.copyOf);

	}

	

	public final boolean equalTo(final MarkupElement element)

	{

		if (element instanceof XmlTag)

		{

			final XmlTag that = (XmlTag)element;

			if (!Objects.equal(getNamespace(), that.getNamespace()))

			{

				return false;

			}

			if (!getName().equals(that.getName()))

			{

				return false;

			}

			if (!getAttributes().equals(that.getAttributes()))

			{

				return false;

			}

			return true;

		}

		return false;

	}

	

	public IValueMap getAttributes()

	{

		if (attributes == null)

		{

			if ((copyOf == this) || (copyOf == null) || (copyOf.attributes == null))

			{

				attributes = new ValueMap();

			}

			else

			{

				attributes = new ValueMap(copyOf.attributes);

			}

		}

		return attributes;

	}

	

	public boolean hasAttributes()

	{

		return attributes != null && attributes.size() > 0;

	}

	

	public int getColumnNumber()

	{

		return columnNumber;

	}

	

	public int getLength()

	{

		return length;

	}

	

	public int getLineNumber()

	{

		return lineNumber;

	}

	

	public String getName()

	{

		return name;

	}

	

	public boolean getNameChanged()

	{

		return nameChanged;

	}

	

	public String getNamespace()

	{

		return namespace;

	}

	

	public final XmlTag getOpenTag()

	{

		return closes;

	}

	

	public int getPos()

	{

		return pos;

	}

	

	public CharSequence getString(final String key)

	{

		return getAttributes().getCharSequence(key);

	}

	

	public Type getType()

	{

		return type;

	}

	

	public boolean isClose()

	{

		return type == CLOSE;

	}

	

	public final boolean isMutable()

	{

		return isMutable;

	}

	

	public boolean isOpen()

	{

		return type == OPEN;

	}

	

	public boolean isOpenClose()

	{

		return type == OPEN_CLOSE;

	}

	

	public boolean hasEqualTagName(final XmlTag tag)

	{

		if (!getName().equalsIgnoreCase(tag.getName()))

		{

			return false;

		}

		if ((getNamespace() == null) && (tag.getNamespace() == null))

		{

			return true;

		}

		if ((getNamespace() != null) && (tag.getNamespace() != null))

		{

			return getNamespace().equalsIgnoreCase(tag.getNamespace());

		}

		return false;

	}

	

	public void makeImmutable()

	{

		if (isMutable)

		{

			isMutable = false;

			if (attributes != null)

			{

				attributes.makeImmutable();

				text = null;

			}

		}

	}

	

	public XmlTag mutable()

	{

		if (isMutable)

		{

			return this;

		}

		else

		{

			final XmlTag tag = new XmlTag();

			copyPropertiesTo(tag);

			return tag;

		}

	}

	

	void copyPropertiesTo(XmlTag dest)

	{

		dest.namespace = namespace;

		dest.name = name;

		dest.pos = pos;

		dest.length = length;

		dest.text = text;

		dest.type = type;

		dest.isMutable = true;

		dest.closes = closes;

		dest.copyOf = copyOf;

		if (attributes != null)

		{

			dest.attributes = new ValueMap(attributes);

		}

	}

	

	public Object put(final String key, final boolean value)

	{

		return put(key, Boolean.toString(value));

	}

	

	public Object put(final String key, final int value)

	{

		return put(key, Integer.toString(value));

	}

	

	public Object put(final String key, final CharSequence value)

	{

		return getAttributes().put(key, value);

	}

	

	public Object put(final String key, final StringValue value)

	{

		return getAttributes().put(key, (value != null) ? value.toString() : null);

	}

	

	public void putAll(final Map map)

	{

		for (final Iterator iterator = map.entrySet().iterator(); iterator.hasNext();)

		{

			final Map.Entry entry = (Map.Entry) iterator.next();

			Object value = entry.getValue();

			put((String) entry.getKey(), (value != null) ? value.toString() : null);

		}

	}

	

	public void remove(final String key)

	{

		getAttributes().remove(key);

	}

	

	public void setName(final String name)

	{

		if (isMutable)

		{

			this.name = name;

			this.nameChanged = true;

		}

		else

		{

			throw new UnsupportedOperationException("Attempt to set name of immutable tag");

		}

	}

	

	public void setNamespace(final String namespace)

	{

		if (isMutable)

		{

			this.namespace = namespace;

			this.nameChanged = true;

		}

		else

		{

			throw new UnsupportedOperationException("Attempt to set namespace of immutable tag");

		}

	}

	

	public void setOpenTag(final XmlTag tag)

	{

		this.closes = tag;

	}

	

	public void setType(final Type type)

	{

		if (isMutable)

		{

			this.type = type;

		}

		else

		{

			throw new UnsupportedOperationException("Attempt to set type of immutable tag");

		}

	}

	

	public String toDebugString()

	{

		return "[Tag name = " + name + ", pos = " + pos + ", line = " + lineNumber + ", length = " +

				length + ", attributes = [" + getAttributes() + "], type = " + type + "]";

	}

	

	public String toString()

	{

		return toCharSequence().toString();

	}

	

	public CharSequence toCharSequence()

	{

		if (!isMutable && (text != null))

		{

			return text;

		}

		return toXmlString(null);

	}

	

	public String toUserDebugString()

	{

		return "'" + toString() + "' (line " + lineNumber + ", column " + columnNumber + ")";

	}

	

	public CharSequence toXmlString(final String attributeToBeIgnored)

	{

		final AppendingStringBuffer buffer = new AppendingStringBuffer();

		buffer.append('<');

		if (type == CLOSE)

		{

			buffer.append('/');

		}

		if (namespace != null)

		{

			buffer.append(namespace);

			buffer.append(':');

		}

		buffer.append(name);

		final IValueMap attributes = getAttributes();

		if (attributes.size() > 0)

		{

			final Iterator iterator = attributes.keySet().iterator();

			for (; iterator.hasNext();)

			{

				final String key = (String)iterator.next();

				if ((key != null) &&

						((attributeToBeIgnored == null) || !key

								.equalsIgnoreCase(attributeToBeIgnored)))

				{

					buffer.append(" ");

					buffer.append(key);

					CharSequence value = getString(key);

					// Attributes without values are possible, e.g. 'disabled'

					if (value != null)

					{

						buffer.append("=\"");

						value = Strings.replaceAll(value, "\"", "\\\"");

						buffer.append(value);

						buffer.append("\"");

					}

				}

			}

		}

		if (type == OPEN_CLOSE)

		{

			buffer.append('/');

		}

		buffer.append('>');

		return buffer;

	}

}