/*
 * 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;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.wicket.Component;
import org.apache.wicket.MarkupContainer;
import org.apache.wicket.behavior.Behavior;
import org.apache.wicket.markup.parser.XmlTag;
import org.apache.wicket.markup.parser.XmlTag.TagType;
import org.apache.wicket.markup.parser.filter.HtmlHandler;
import org.apache.wicket.request.Response;
import org.apache.wicket.util.lang.Args;
import org.apache.wicket.util.lang.Generics;
import org.apache.wicket.util.string.StringValue;
import org.apache.wicket.util.string.Strings;
import org.apache.wicket.util.value.IValueMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * A subclass of MarkupElement which represents a "significant" markup tag, such as a component open
 * tag. Insignificant markup tags (those which are merely concerned with markup formatting
 * operations and do not denote components or component nesting) are coalesced into instances of
 * RawMarkup (also a subclass of MarkupElement).
 * 
 * @author Jonathan Locke
 */
public class ComponentTag extends MarkupElement
{
        /**
         * Factory that creates component during markup root container's initialization. These
         * components get queued, which allows other components to be dequeued under these auto
         * components.
         * 
         * @author igor
         */
        public interface IAutoComponentFactory
        {
                /**
                 * Creates a new instance of auto component to be queued
                 *
                 * @param container
                 *                The component that will become a parent of the newly created auto component
                 * @param tag
                 *                The markup element for the newly created auto component
                 */
                Component newComponent(MarkupContainer container, ComponentTag tag);
        }


        /** Log. */
        private static final Logger log = LoggerFactory.getLogger(ComponentTag.class);

        /** True if a href attribute is available and autolinking is on */
        private final static int AUTOLINK = 0x0001;

        /** True, if attributes have been modified or added */
        private final static int MODIFIED = 0x0002;

        /** If true, then the MarkupParser will ignore (remove) it. Temporary working variable */
        private final static int IGNORE = 0x0004;

        /** If true, then the tag contain an automatically created wicket id */
        private final static int AUTO_COMPONENT = 0x0008;

        /** Some HTML tags are allow to have no close tag, e.g. 'br' */
        private final static int NO_CLOSE_TAG = 0x0010;

        /** Render the tag as RawMarkup even if no Component can be found */
        public final static int RENDER_RAW = 0x0020;
        
        /** If true, the current tag contains a child or a descendant with the "wicket:id" attribute */
        public final static int CONTAINS_WICKET_ID = 0x0040;

        /** If close tag, than reference to the corresponding open tag */
        private ComponentTag openTag;

        /** The underlying xml tag */
        protected final XmlTag xmlTag;

        /** Boolean flags. See above */
        private int flags = 0;

        /**
         * By default this is equal to the wicket:id="xxx" attribute value, but may be provided e.g. for
         * auto-tags
         */
        private String id;

        /**
         * In case of inherited markup, the base and the extended markups are merged and the information
         * about the tags origin is lost. In some cases like wicket:head and wicket:link this
         * information however is required.
         */
        private WeakReference<Class<? extends Component>> markupClassRef = null;

        /** added behaviors */
        private List<Behavior> behaviors;

        /** Filters and Handlers may add their own attributes to the tag */
        private Map<String, Object> userData;

        private IAutoComponentFactory autoComponentFactory;

        /**
         * Automatically create a XmlTag, assign the name and the type, and construct a ComponentTag
         * based on this XmlTag.
         * 
         * @param name
         *            The name of html tag
         * @param type
         *            The type of tag
         */
        public ComponentTag(final String name, final XmlTag.TagType type)
        {
                final XmlTag tag = new XmlTag();
                tag.setName(name);
                tag.setType(type);
                xmlTag = tag;
        }

        /**
         * Construct.
         * 
         * @param tag
         *            The underlying xml tag
         */
        public ComponentTag(final XmlTag tag)
        {
                super();
                xmlTag = tag;
        }

        /**
         * Constructor
         * 
         * @param tag
         *            The ComponentTag tag which this wicket tag is based upon.
         */
        public ComponentTag(final ComponentTag tag)
        {
                this(tag.getXmlTag());
                tag.copyPropertiesTo(this);
        }

        /**
         * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT!
         * 
         * @param flag
         *            The flag to set
         * @param set
         *            True to turn the flag on, false to turn it off
         */
        public final void setFlag(final int flag, final boolean set)
        {
                if (set)
                {
                        flags |= flag;
                }
                else
                {
                        flags &= ~flag;
                }
        }

        /**
         * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT!
         * 
         * @param flag
         *            The flag to test
         * @return True if the flag is set
         */
        public final boolean getFlag(final int flag)
        {
                return (flags & flag) != 0;
        }

        /**
         * Adds a behavior to this component tag.
         * 
         * @param behavior
         */
        public final void addBehavior(final Behavior behavior)
        {
                Args.notNull(behavior, "behavior");

                if (behaviors == null)
                {
                        behaviors = Generics.newArrayList();
                }
                behaviors.add(behavior);
        }

        /**
         * @return true if this tag has any behaviors added, false otherwise
         */
        public final boolean hasBehaviors()
        {
                return behaviors != null;
        }

        /**
         * @return read only iterator over added behaviors
         */
        // TODO change to return unmodifiable list which will never be null. See Component.getBehavior
        public final Iterator<? extends Behavior> getBehaviors()
        {
                if (behaviors == null)
                {
                        List<Behavior> lst = Collections.emptyList();
                        return lst.iterator();
                }

                return Collections.unmodifiableCollection(behaviors).iterator();
        }

        /**
         * Gets whether this tag closes the provided open tag.
         * 
         * @param open
         *            The open tag
         * @return True if this tag closes the given open tag
         */
        @Override
        public final boolean closes(final MarkupElement open)
        {
                if (open instanceof ComponentTag)
                {
                        return (openTag == open) || getXmlTag().closes(((ComponentTag)open).getXmlTag());
                }

                return false;
        }

        /**
         * If autolink is set to true, href attributes will automatically be converted into Wicket
         * bookmarkable URLs.
         * 
         * @param autolink
         *            enable/disable automatic href conversion
         */
        public final void enableAutolink(final boolean autolink)
        {
                setFlag(AUTOLINK, autolink);
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#getAttributes()
         * @return The tag#s attributes
         */
        public final IValueMap getAttributes()
        {
                return xmlTag.getAttributes();
        }

        /**
         * A convenient method. The same as getAttributes().getString(name)
         * 
         * @param name
         * @return The attributes value
         */
        public final String getAttribute(String name)
        {
                return xmlTag.getAttributes().getString(name);
        }

        /**
         * Get the tag's component id
         * 
         * @return The component id attribute of this tag
         */
        public final String getId()
        {
                return id;
        }

        /**
         * Gets the length of the tag in characters.
         * 
         * @return The tag's length
         */
        public final int getLength()
        {
                return xmlTag.getLength();
        }

        /**
         * @return The tag's name
         */
        public final String getName()
        {
                return xmlTag.getName();
        }

        /**
         * @return The tag's namespace
         */
        public final String getNamespace()
        {
                return xmlTag.getNamespace();
        }

        /**
         * If set, return the corresponding open tag (ComponentTag).
         * 
         * @return The corresponding open tag
         */
        public final ComponentTag getOpenTag()
        {
                return openTag;
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#getPos()
         * @return Tag location (index in input string)
         */
        public final int getPos()
        {
                return xmlTag.getPos();
        }

        /**
         * @return the tag type (OPEN, CLOSE or OPEN_CLOSE).
         */
        public final TagType getType()
        {
                return xmlTag.getType();
        }

        /**
         * True if autolink is enabled and the tag contains a href attribute.
         * 
         * @return True, if the href contained should automatically be converted
         */
        public final boolean isAutolinkEnabled()
        {
                return getFlag(AUTOLINK);
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#isClose()
         * @return True if this tag is a close tag
         */
        public final boolean isClose()
        {
                return xmlTag.isClose();
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#isOpen()
         * @return True if this tag is an open tag
         */
        public final boolean isOpen()
        {
                return xmlTag.isOpen();
        }

        /**
         * @param id
         *            Required component id
         * @return True if this tag is an open tag with the given component name
         * @see org.apache.wicket.markup.parser.XmlTag#isOpen()
         */
        public final boolean isOpen(String id)
        {
                return xmlTag.isOpen() && this.id.equals(id);
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#isOpenClose()
         * @return True if this tag is an open and a close tag
         */
        public final boolean isOpenClose()
        {
                return xmlTag.isOpenClose();
        }

        /**
         * @param id
         *            Required component id
         * @return True if this tag is an openclose tag with the given component id
         * @see org.apache.wicket.markup.parser.XmlTag#isOpenClose()
         */
        public final boolean isOpenClose(String id)
        {
                return xmlTag.isOpenClose() && this.id.equals(id);
        }

        /**
         * Makes this tag object immutable by making the attribute map unmodifiable. Immutable tags
         * cannot be made mutable again. They can only be copied into new mutable tag objects.
         */
        public final void makeImmutable()
        {
                xmlTag.makeImmutable();
        }

        /**
         * Gets this tag if it is already mutable, or a mutable copy of this tag if it is immutable.
         * 
         * @return This tag if it is already mutable, or a mutable copy of this tag if it is immutable.
         */
        public ComponentTag mutable()
        {
                if (xmlTag.isMutable())
                {
                        return this;
                }
                else
                {
                        ComponentTag tag = new ComponentTag(xmlTag.mutable());
                        copyPropertiesTo(tag);
                        return tag;
                }
        }

        /**
         * Copies all internal properties from this tag to <code>dest</code>. This is basically cloning
         * without instance creation.
         * 
         * @param dest
         *            tag whose properties will be set
         */
        void copyPropertiesTo(final ComponentTag dest)
        {
                dest.id = id;
                dest.flags = flags;
                dest.autoComponentFactory = autoComponentFactory;

                if (markupClassRef != null)
                {
                        dest.setMarkupClass(markupClassRef.get());
                }
                if (behaviors != null)
                {
                        dest.behaviors = new ArrayList<>(behaviors);
                }
                if (userData != null)
                {
                        dest.userData = new HashMap<>(userData);
                }
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#put(String, boolean)
         * @param key
         *            The key
         * @param value
         *            The value
         */
        public final void put(final String key, final boolean value)
        {
                xmlTag.put(key, value);
                setModified(true);
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#put(String, int)
         * @param key
         *            The key
         * @param value
         *            The value
         */
        public final void put(final String key, final int value)
        {
                xmlTag.put(key, value);
                setModified(true);
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#put(String, CharSequence)
         * @param key
         *            The key
         * @param value
         *            The value
         */
        public final void put(String key, CharSequence value)
        {
                checkIdAttribute(key);
                putInternal(key, value);
        }

        /**
         * THIS METHOD IS NOT PART OF THE PUBLIC API, DO NOT CALL IT
         * 
         * @see org.apache.wicket.markup.parser.XmlTag#put(String, CharSequence)
         * @param key
         *            The key
         * @param value
         *            The value
         */
        public final void putInternal(String key, CharSequence value)
        {
                xmlTag.put(key, value);
                setModified(true);
        }

        /**
         * @param key
         */
        private void checkIdAttribute(String key)
        {
                if ("id".equalsIgnoreCase(key))
                {
                        log.warn("Please use component.setMarkupId(String) to change the tag's 'id' attribute.");
                }
        }

        /**
         * Appends specified {@code value} to the attribute
         * 
         * @param key
         *            The key
         * @param value
         *            The value
         * @param separator
         *            The separator used to append the value
         */
        public final void append(String key, CharSequence value, String separator)
        {
                String current = getAttribute(key);
                if (Strings.isEmpty(current))
                {
                        xmlTag.put(key, value);
                }
                else
                {
                        xmlTag.put(key, current + separator + value);
                }

                setModified(true);
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#put(String, StringValue)
         * @param key
         *            The key
         * @param value
         *            The value
         */
        public final void put(String key, StringValue value)
        {
                xmlTag.put(key, value);
                setModified(true);
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#putAll(Map)
         * @param map
         *            a key/value map
         */
        public final void putAll(final Map<String, Object> map)
        {
                xmlTag.putAll(map);
                setModified(true);
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#remove(String)
         * @param key
         *            The key to remove
         */
        public final void remove(String key)
        {
                xmlTag.remove(key);
                setModified(true);
        }

        /**
         * Gets whether this tag does not require a closing tag.
         * 
         * @return True if this tag does not require a closing tag
         */
        public final boolean requiresCloseTag()
        {
                if (getNamespace() == null)
                {
                        return HtmlHandler.requiresCloseTag(getName());
                }
                else
                {
                        return HtmlHandler.requiresCloseTag(getNamespace() + ":" + getName());
                }
        }

        /**
         * Set the component's id. The value is usually taken from the tag's id attribute, e.g.
         * wicket:id="componentId".
         * 
         * @param id
         *            The component's id assigned to the tag.
         */
        public final void setId(final String id)
        {
                this.id = id;
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#setName(String)
         * @param name
         *            New tag name
         */
        public final void setName(String name)
        {
                xmlTag.setName(name);
        }

        /**
         * @see org.apache.wicket.markup.parser.XmlTag#setNamespace(String)
         * @param namespace
         *            New tag name namespace
         */
        public final void setNamespace(String namespace)
        {
                xmlTag.setNamespace(namespace);
        }

        /**
         * Assuming this is a close tag, assign it's corresponding open tag.
         * 
         * @param tag
         *            the open-tag
         * @throws RuntimeException
         *             if 'this' is not a close tag
         */
        public final void setOpenTag(final ComponentTag tag)
        {
                openTag = tag;
                getXmlTag().setOpenTag(tag.getXmlTag());
        }

        /**
         * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL IT.
         * 
         * @param type
         *            The new type
         */
        public final void setType(final TagType type)
        {
                if (type != xmlTag.getType())
                {
                        xmlTag.setType(type);
                        setModified(true);
                }
        }

        /**
         * Writes the synthetic close tag for this tag to the response
         * 
         * @param response
         *            The response to write to
         */
        public final void writeSyntheticCloseTag(Response response)
        {
                response.write("</");
                if (getNamespace() != null)
                {
                        response.write(getNamespace());
                        response.write(":");
                }
                response.write(getName());
                response.write(">");
        }

        /**
         * @see org.apache.wicket.markup.MarkupElement#toCharSequence()
         */
        @Override
        public CharSequence toCharSequence()
        {
                return xmlTag.toCharSequence();
        }

        /**
         * Converts this object to a string representation.
         * 
         * @return String version of this object
         */
        @Override
        public final String toString()
        {
                return toCharSequence().toString();
        }

        /**
         * Write the tag to the response
         * 
         * @param response
         *            The response to write to
         * @param stripWicketAttributes
         *            if true, wicket:id are removed from output
         * @param namespace
         *            Wicket's namespace to use
         */
        public final void writeOutput(final Response response, final boolean stripWicketAttributes,
                final String namespace)
        {
                response.write("<");

                if (getType() == TagType.CLOSE)
                {
                        response.write("/");
                }

                if (getNamespace() != null)
                {
                        response.write(getNamespace());
                        response.write(":");
                }

                response.write(getName());

                String namespacePrefix = null;
                if (stripWicketAttributes == true)
                {
                        namespacePrefix = namespace + ":";
                }

                if (getAttributes().size() > 0)
                {
                        for (String key : getAttributes().keySet())
                        {
                                if (key == null)
                                {
                                        continue;
                                }

                                if ((namespacePrefix == null) || (key.startsWith(namespacePrefix) == false))
                                {
                                        response.write(" ");
                                        response.write(key);
                                        CharSequence value = getAttribute(key);

                                        // attributes without values are possible, e.g.' disabled'
                                        if (value != null)
                                        {
                                                response.write("=\"");
                                                value = Strings.escapeMarkup(value);
                                                response.write(value);
                                                response.write("\"");
                                        }
                                }
                        }
                }

                if (getType() == TagType.OPEN_CLOSE)
                {
                        response.write("/");
                }

                response.write(">");
        }

        /**
         * Converts this object to a string representation including useful information for debugging
         * 
         * @return String version of this object
         */
        @Override
        public final String toUserDebugString()
        {
                return xmlTag.toUserDebugString();
        }

        /**
         * @return Returns the underlying xml tag.
         */
        public final XmlTag getXmlTag()
        {
                return xmlTag;
        }

        /**
         * Manually mark the ComponentTag being modified. Flagging the tag being modified does not
         * happen automatically.
         * 
         * @param modified
         */
        public final void setModified(final boolean modified)
        {
                setFlag(MODIFIED, modified);
        }

        /**
         * 
         * @return True, if the component tag has been marked modified
         */
        final boolean isModified()
        {
                return getFlag(MODIFIED);
        }

        /**
         * 
         * @return True if the HTML tag (e.g. br) has no close tag
         */
        public boolean hasNoCloseTag()
        {
                return getFlag(NO_CLOSE_TAG);
        }

        /**
         * True if the HTML tag (e.g. br) has no close tag
         * 
         * @param hasNoCloseTag
         */
        public void setHasNoCloseTag(boolean hasNoCloseTag)
        {
                setFlag(NO_CLOSE_TAG, hasNoCloseTag);
        }
        
        /**
         * Sets the flag to indicate if the current tag contains a child 
         * or a descendant with the "wicket:id" attribute. 
         *
         * @param containsWicketId
         */
        public void setContainsWicketId(boolean containsWicketId)
        {
                setFlag(CONTAINS_WICKET_ID, containsWicketId);
        }

        /**
         * Says if the current tag contains a child or a descendant with the "wicket:id" attribute.
         * @return true if the current tag contains a child or a descendant with the "wicket:id" attribute.
         */
    public boolean containsWicketId()
    {
        return getFlag(CONTAINS_WICKET_ID);
    }
    
        /**
         * In case of inherited markup, the base and the extended markups are merged and the information
         * about the tags origin is lost. In some cases like wicket:head and wicket:link this
         * information however is required.
         * 
         * @return wicketHeaderClass
         */
        public Class<? extends Component> getMarkupClass()
        {
                return (markupClassRef == null ? null : markupClassRef.get());
        }

        /**
         * Set the class of wicket component which contains the wicket:head tag.
         * 
         * @param <C>
         * 
         * @param wicketHeaderClass
         *            wicketHeaderClass
         */
        public <C extends Component> void setMarkupClass(Class<C> wicketHeaderClass)
        {
                if (wicketHeaderClass == null)
                {
                        markupClassRef = null;
                }
                else
                {
                        markupClassRef = new WeakReference<Class<? extends Component>>(wicketHeaderClass);
                }
        }

        /**
         * @see org.apache.wicket.markup.MarkupElement#equalTo(org.apache.wicket.markup.MarkupElement)
         */
        @Override
        public boolean equalTo(final MarkupElement element)
        {
                if (element instanceof ComponentTag)
                {
                        final ComponentTag that = (ComponentTag)element;
                        return getXmlTag().equalTo(that.getXmlTag());
                }
                return false;
        }

        /**
         * Gets ignore.
         * 
         * @return If true than MarkupParser will remove it from the markup
         */
        public boolean isIgnore()
        {
                return getFlag(IGNORE);
        }

        /**
         * Sets ignore.
         * 
         * @param ignore
         *            If true than MarkupParser will remove it from the markup
         */
        public void setIgnore(boolean ignore)
        {
                setFlag(IGNORE, ignore);
        }

        /**
         * @return True, if wicket:id has been automatically created (internal component)
         */
        public boolean isAutoComponentTag()
        {
                return getFlag(AUTO_COMPONENT);
        }

        /**
         * @param auto
         *            True, if wicket:id has been automatically created (internal component)
         */
        public void setAutoComponentTag(boolean auto)
        {
                setFlag(AUTO_COMPONENT, auto);
        }

        /**
         * Gets userData.
         * 
         * @param key
         *            The key to store and retrieve the value
         * @return userData
         */
        public Object getUserData(final String key)
        {
                if (userData == null)
                {
                        return null;
                }

                return userData.get(key);
        }

        /**
         * Sets userData.
         * 
         * @param key
         *            The key to store and retrieve the value
         * @param value
         *            The user specific value to store
         */
        public void setUserData(final String key, final Object value)
        {
                if (userData == null)
                {
                        userData = new HashMap<>();
                }
                userData.put(key, value);
        }

        /**
         * For subclasses to override. Gets called just before a Component gets rendered. It is
         * guaranteed that the markupStream is set on the Component and determineVisibility is not yet
         * called.
         * 
         * @param component
         *            The component that is about to be rendered
         * @param markupStream
         *            The current markup stream
         */
        public void onBeforeRender(final Component component, final MarkupStream markupStream)
        {
        }

        public IAutoComponentFactory getAutoComponentFactory()
        {
                return autoComponentFactory;
        }

        public void setAutoComponentFactory(IAutoComponentFactory autoComponentFactory)
        {
                this.autoComponentFactory = autoComponentFactory;
        }


}