/*

    Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>

                  2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>

    Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Library General Public

    License as published by the Free Software Foundation; either

    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License

    along with this library; see the file COPYING.LIB.  If not, write to

    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    Boston, MA 02110-1301, USA.

*/

#include "config.h"

#if ENABLE(SVG)

#include "SVGUseElement.h"

#include "Attribute.h"

#include "CSSStyleSelector.h"

#include "Document.h"

#include "Event.h"

#include "EventListener.h"

#include "HTMLNames.h"

#include "NodeRenderStyle.h"

#include "RegisteredEventListener.h"

#include "RenderSVGResource.h"

#include "RenderSVGShadowTreeRootContainer.h"

#include "SVGElementInstance.h"

#include "SVGElementInstanceList.h"

#include "SVGGElement.h"

#include "SVGLength.h"

#include "SVGPreserveAspectRatio.h"

#include "SVGSMILElement.h"

#include "SVGSVGElement.h"

#include "SVGShadowTreeElements.h"

#include "SVGSymbolElement.h"

#include "XLinkNames.h"

#include "XMLSerializer.h"

// Dump SVGElementInstance object tree - useful to debug instanceRoot problems

// #define DUMP_INSTANCE_TREE

// Dump the deep-expanded shadow tree (where the renderers are built from)

// #define DUMP_SHADOW_TREE

namespace WebCore {

SVGUseElement::SVGUseElement(const QualifiedName& tagName, Document* doc)

    : SVGStyledTransformableElement(tagName, doc)

    , SVGTests()

    , SVGLangSpace()

    , SVGExternalResourcesRequired()

    , SVGURIReference()

    , m_x(LengthModeWidth)

    , m_y(LengthModeHeight)

    , m_width(LengthModeWidth)

    , m_height(LengthModeHeight)

    , m_updatesBlocked(false)

    , m_isPendingResource(false)

    , m_needsShadowTreeRecreation(false)

{

}

SVGUseElement::~SVGUseElement()

{

}

SVGElementInstance* SVGUseElement::instanceRoot() const

{

    // If there is no element instance tree, force immediate SVGElementInstance tree

    // creation by asking the document to invoke our recalcStyle function - as we can't

    // wait for the lazy creation to happen if e.g. JS wants to access the instanceRoot

    // object right after creating the element on-the-fly

    if (!m_targetElementInstance)

        document()->updateLayoutIgnorePendingStylesheets();

    return m_targetElementInstance.get();

}

SVGElementInstance* SVGUseElement::animatedInstanceRoot() const

{

    // FIXME: Implement me.

    return 0;

}

void SVGUseElement::parseMappedAttribute(Attribute* attr)

{

    if (attr->name() == SVGNames::xAttr)

        setXBaseValue(SVGLength(LengthModeWidth, attr->value()));

    else if (attr->name() == SVGNames::yAttr)

        setYBaseValue(SVGLength(LengthModeHeight, attr->value()));

    else if (attr->name() == SVGNames::widthAttr) {

        setWidthBaseValue(SVGLength(LengthModeWidth, attr->value()));

        if (widthBaseValue().value(this) < 0.0)

            document()->accessSVGExtensions()->reportError("A negative value for use attribute <width> is not allowed");

    } else if (attr->name() == SVGNames::heightAttr) {

        setHeightBaseValue(SVGLength(LengthModeHeight, attr->value()));

        if (heightBaseValue().value(this) < 0.0)

            document()->accessSVGExtensions()->reportError("A negative value for use attribute <height> is not allowed");

    } else {

        if (SVGTests::parseMappedAttribute(attr))

            return;

        if (SVGLangSpace::parseMappedAttribute(attr))

            return;

        if (SVGExternalResourcesRequired::parseMappedAttribute(attr))

            return;

        if (SVGURIReference::parseMappedAttribute(attr))

            return;

        SVGStyledTransformableElement::parseMappedAttribute(attr);

    }

}

void SVGUseElement::insertedIntoDocument()

{

    // This functions exists to assure assumptions made in the code regarding SVGElementInstance creation/destruction are satisfied.

    SVGStyledTransformableElement::insertedIntoDocument();

    ASSERT(!m_targetElementInstance);

    ASSERT(!m_isPendingResource);

}

void SVGUseElement::removedFromDocument()

{

    m_targetElementInstance = 0;

    SVGStyledTransformableElement::removedFromDocument();

}

void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName)

{

    SVGStyledTransformableElement::svgAttributeChanged(attrName);

    bool isXYAttribute = attrName == SVGNames::xAttr || attrName == SVGNames::yAttr;

    bool isWidthHeightAttribute = attrName == SVGNames::widthAttr || attrName == SVGNames::heightAttr;

    if (isXYAttribute || isWidthHeightAttribute)

        updateRelativeLengthsInformation();

    RenderObject* object = renderer();

    if (!object)

        return;

    if (SVGURIReference::isKnownAttribute(attrName)) {

        if (m_isPendingResource) {

            document()->accessSVGExtensions()->removePendingResource(m_resourceId);

            m_resourceId = String();

            m_isPendingResource = false;

        }

        invalidateShadowTree();

        return;

    }

    if (isXYAttribute) {

        updateContainerOffsets();

        return;

    }

    if (isWidthHeightAttribute) {

        updateContainerSizes();

        return;

    }

    // Be very careful here, if svgAttributeChanged() has been called because a SVG CSS property changed, we do NOT want to reclone the tree!

    if (SVGStyledElement::isKnownAttribute(attrName)) {

        setNeedsStyleRecalc();

        return;

    }

    if (SVGStyledTransformableElement::isKnownAttribute(attrName)) {

        object->setNeedsTransformUpdate();

        RenderSVGResource::markForLayoutAndParentResourceInvalidation(object);

        return;

    }

    if (SVGTests::isKnownAttribute(attrName)

        || SVGLangSpace::isKnownAttribute(attrName)

        || SVGExternalResourcesRequired::isKnownAttribute(attrName))

        invalidateShadowTree();

}

void SVGUseElement::synchronizeProperty(const QualifiedName& attrName)

{

    SVGStyledTransformableElement::synchronizeProperty(attrName);

    if (attrName == anyQName()) {

        synchronizeX();

        synchronizeY();

        synchronizeWidth();

        synchronizeHeight();

        synchronizeExternalResourcesRequired();

        synchronizeHref();

        return;

    }

    if (attrName == SVGNames::xAttr)

        synchronizeX();

    else if (attrName == SVGNames::yAttr)

        synchronizeY();

    else if (attrName == SVGNames::widthAttr)

        synchronizeWidth();

    else if (attrName == SVGNames::heightAttr)

        synchronizeHeight();

    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))

        synchronizeExternalResourcesRequired();

    else if (SVGURIReference::isKnownAttribute(attrName))

        synchronizeHref();

}

static void updateContainerSize(SVGUseElement* useElement, SVGElementInstance* targetInstance)

{

    // Depth-first used to write the method in early exit style, no particular other reason.

    for (SVGElementInstance* instance = targetInstance->firstChild(); instance; instance = instance->nextSibling())

        updateContainerSize(useElement, instance);

    SVGElement* correspondingElement = targetInstance->correspondingElement();

    ASSERT(correspondingElement);

    bool isSymbolTag = correspondingElement->hasTagName(SVGNames::symbolTag);

    if (!correspondingElement->hasTagName(SVGNames::svgTag) && !isSymbolTag)

        return;

    SVGElement* shadowTreeElement = targetInstance->shadowTreeElement();

    ASSERT(shadowTreeElement);

    ASSERT(shadowTreeElement->hasTagName(SVGNames::svgTag));

    // Spec (<use> on <symbol>): This generated 'svg' will always have explicit values for attributes width and height.

    // If attributes width and/or height are provided on the 'use' element, then these attributes

    // will be transferred to the generated 'svg'. If attributes width and/or height are not specified,

    // the generated 'svg' element will use values of 100% for these attributes.

    // Spec (<use> on <svg>): If attributes width and/or height are provided on the 'use' element, then these

    // values will override the corresponding attributes on the 'svg' in the generated tree.

    if (useElement->hasAttribute(SVGNames::widthAttr))

        shadowTreeElement->setAttribute(SVGNames::widthAttr, useElement->getAttribute(SVGNames::widthAttr));

    else if (isSymbolTag && shadowTreeElement->hasAttribute(SVGNames::widthAttr))

        shadowTreeElement->setAttribute(SVGNames::widthAttr, "100%");

    if (useElement->hasAttribute(SVGNames::heightAttr))

        shadowTreeElement->setAttribute(SVGNames::heightAttr, useElement->getAttribute(SVGNames::heightAttr));

    else if (isSymbolTag && shadowTreeElement->hasAttribute(SVGNames::heightAttr))

        shadowTreeElement->setAttribute(SVGNames::heightAttr, "100%");

}   

void SVGUseElement::updateContainerSizes()

{

    if (!m_targetElementInstance)

        return;

    // Update whole subtree, scanning for shadow container elements, that correspond to <svg>/<symbol> tags

    updateContainerSize(this, m_targetElementInstance.get());

    if (RenderObject* object = renderer())

        RenderSVGResource::markForLayoutAndParentResourceInvalidation(object);

}

static void updateContainerOffset(SVGElementInstance* targetInstance)

{

    // Depth-first used to write the method in early exit style, no particular other reason.

    for (SVGElementInstance* instance = targetInstance->firstChild(); instance; instance = instance->nextSibling())

        updateContainerOffset(instance);

    SVGElement* correspondingElement = targetInstance->correspondingElement();

    ASSERT(correspondingElement);

    if (!correspondingElement->hasTagName(SVGNames::useTag))

        return;

    SVGElement* shadowTreeElement = targetInstance->shadowTreeElement();

    ASSERT(shadowTreeElement);

    ASSERT(shadowTreeElement->hasTagName(SVGNames::gTag));

    if (!static_cast<SVGGElement*>(shadowTreeElement)->isShadowTreeContainerElement())

        return;

    // Spec: An additional transformation translate(x,y) is appended to the end

    // (i.e., right-side) of the transform attribute on the generated 'g', where x

    // and y represent the values of the x and y attributes on the 'use' element. 

    SVGUseElement* useElement = static_cast<SVGUseElement*>(correspondingElement);

    SVGShadowTreeContainerElement* containerElement = static_cast<SVGShadowTreeContainerElement*>(shadowTreeElement);

    containerElement->setContainerOffset(useElement->x(), useElement->y());

}

void SVGUseElement::updateContainerOffsets()

{

    if (!m_targetElementInstance)

        return;

    // Update root container offset (not reachable through instance tree)

    SVGElement* shadowRoot = m_targetElementInstance->shadowTreeElement();

    ASSERT(shadowRoot);

    Node* parentNode = shadowRoot->parentNode();

    ASSERT(parentNode);

    ASSERT(parentNode->isSVGElement());

    ASSERT(parentNode->hasTagName(SVGNames::gTag));

    ASSERT(static_cast<SVGGElement*>(parentNode)->isShadowTreeContainerElement());

    SVGShadowTreeContainerElement* containerElement = static_cast<SVGShadowTreeContainerElement*>(parentNode);

    containerElement->setContainerOffset(x(), y());

    // Update whole subtree, scanning for shadow container elements, marking a cloned use subtree

    updateContainerOffset(m_targetElementInstance.get());

    if (RenderObject* object = renderer())

        RenderSVGResource::markForLayoutAndParentResourceInvalidation(object);

}

void SVGUseElement::recalcStyle(StyleChange change)

{

    // Eventually mark shadow root element needing style recalc

    if (needsStyleRecalc() && m_targetElementInstance && !m_updatesBlocked) {

        if (SVGElement* shadowRoot = m_targetElementInstance->shadowTreeElement())

            shadowRoot->setNeedsStyleRecalc();

    }

    SVGStyledTransformableElement::recalcStyle(change);

    // Assure that the shadow tree has not been marked for recreation, while we're building it.

    if (m_updatesBlocked)

        ASSERT(!m_needsShadowTreeRecreation);

    bool needsStyleUpdate = !m_needsShadowTreeRecreation;

    if (m_needsShadowTreeRecreation) {

        static_cast<RenderSVGShadowTreeRootContainer*>(renderer())->markShadowTreeForRecreation();

        m_needsShadowTreeRecreation = false;

    }

    RenderSVGShadowTreeRootContainer* shadowRoot = static_cast<RenderSVGShadowTreeRootContainer*>(renderer());

    if (!shadowRoot)

        return;

    shadowRoot->updateFromElement();

    if (!needsStyleUpdate)

        return;

    shadowRoot->updateStyle(change);

}

#ifdef DUMP_INSTANCE_TREE

void dumpInstanceTree(unsigned int& depth, String& text, SVGElementInstance* targetInstance)

{

    SVGElement* element = targetInstance->correspondingElement();

    ASSERT(element);

    SVGElement* shadowTreeElement = targetInstance->shadowTreeElement();

    ASSERT(shadowTreeElement);

    String elementId = element->getIdAttribute();

    String elementNodeName = element->nodeName();

    String shadowTreeElementNodeName = shadowTreeElement->nodeName();

    String parentNodeName = element->parentNode() ? element->parentNode()->nodeName() : "null";

    String firstChildNodeName = element->firstChild() ? element->firstChild()->nodeName() : "null";

    for (unsigned int i = 0; i < depth; ++i)

        text += "  ";

    text += String::format("SVGElementInstance this=%p, (parentNode=%s (%p), firstChild=%s (%p), correspondingElement=%s (%p), shadowTreeElement=%s (%p), id=%s)\n",

                           targetInstance, parentNodeName.latin1().data(), element->parentNode(), firstChildNodeName.latin1().data(), element->firstChild(),

                           elementNodeName.latin1().data(), element, shadowTreeElementNodeName.latin1().data(), shadowTreeElement, elementId.latin1().data());

    for (unsigned int i = 0; i < depth; ++i)

        text += "  ";

    const HashSet<SVGElementInstance*>& elementInstances = element->instancesForElement();

    text += String::format("Corresponding element is associated with %i instance(s):\n", elementInstances.size());

    const HashSet<SVGElementInstance*>::const_iterator end = elementInstances.end();

    for (HashSet<SVGElementInstance*>::const_iterator it = elementInstances.begin(); it != end; ++it) {

        for (unsigned int i = 0; i < depth; ++i)

            text += "  ";

        text += String::format(" -> SVGElementInstance this=%p, (refCount: %i, shadowTreeElement in document? %i)\n",

                               *it, (*it)->refCount(), (*it)->shadowTreeElement()->inDocument());

    }

    ++depth;

    for (SVGElementInstance* instance = targetInstance->firstChild(); instance; instance = instance->nextSibling())

        dumpInstanceTree(depth, text, instance);

    --depth;

}

#endif

static bool isDisallowedElement(Node* element)

{

#if ENABLE(SVG_FOREIGN_OBJECT)

    // <foreignObject> should never be contained in a <use> tree. Too dangerous side effects possible.

    if (element->hasTagName(SVGNames::foreignObjectTag))

        return true;

#endif

#if ENABLE(SVG_ANIMATION)

    if (SVGSMILElement::isSMILElement(element))

        return true;

#endif

    return false;

}

static bool subtreeContainsDisallowedElement(Node* start)

{

    if (isDisallowedElement(start))

        return true;

    for (Node* cur = start->firstChild(); cur; cur = cur->nextSibling()) {

        if (subtreeContainsDisallowedElement(cur))

            return true;

    }

    return false;

}

void SVGUseElement::buildPendingResource()

{

    // If we're called the first time (during shadow tree root creation from RenderSVGShadowTreeRootContainer)

    // we either determine that our target is available or not - then we add ourselves to the pending resource list

    // Once the pending resource appears, it will call buildPendingResource(), so we're called a second time.

    String id = SVGURIReference::getTarget(href());

    Element* targetElement = document()->getElementById(id);

    ASSERT(!m_targetElementInstance);

    if (!targetElement) {

        if (m_isPendingResource || id.isEmpty())

            return;

        m_isPendingResource = true;

        m_resourceId = id;

        document()->accessSVGExtensions()->addPendingResource(id, this);

        return;

    }

    if (m_isPendingResource) {

        ASSERT(!m_targetElementInstance);

        m_isPendingResource = false;    

        invalidateShadowTree();

    }

}

void SVGUseElement::buildShadowAndInstanceTree(SVGShadowTreeRootElement* shadowRoot)

{

    struct ShadowTreeUpdateBlocker {

        ShadowTreeUpdateBlocker(SVGUseElement* currentUseElement)

            : useElement(currentUseElement)

        {

            useElement->setUpdatesBlocked(true);

        }

        ~ShadowTreeUpdateBlocker()

        {

            useElement->setUpdatesBlocked(false);

        }

        SVGUseElement* useElement;

    };

    // When cloning the target nodes, they may decide to synchronize style and/or animated SVG attributes.

    // That causes calls to SVGElementInstance::updateAllInstancesOfElement(), which mark the shadow tree for recreation.

    // Solution: block any updates to the shadow tree while we're building it.

    ShadowTreeUpdateBlocker blocker(this);

    String id = SVGURIReference::getTarget(href());

    Element* targetElement = document()->getElementById(id);

    if (!targetElement) {

        // The only time we should get here is when the use element has not been

        // given a resource to target.

        ASSERT(m_resourceId.isEmpty());

        return;

    }

    // Do not build the shadow/instance tree for <use> elements living in a shadow tree.

    // The will be expanded soon anyway - see expandUseElementsInShadowTree().

    Node* parent = parentNode();

    while (parent) {

        if (parent->isShadowNode())

            return;

        parent = parent->parentNode();

    }

    SVGElement* target = 0;

    if (targetElement && targetElement->isSVGElement())

        target = static_cast<SVGElement*>(targetElement);

    if (m_targetElementInstance)

        m_targetElementInstance = 0;

    // Do not allow self-referencing.

    // 'target' may be null, if it's a non SVG namespaced element.

    if (!target || target == this)

        return;

    // Why a seperated instance/shadow tree? SVG demands it:

    // The instance tree is accesable from JavaScript, and has to

    // expose a 1:1 copy of the referenced tree, whereas internally we need

    // to alter the tree for correct "use-on-symbol", "use-on-svg" support.  

    // Build instance tree. Create root SVGElementInstance object for the first sub-tree node.

    //

    // Spec: If the 'use' element references a simple graphics element such as a 'rect', then there is only a

    // single SVGElementInstance object, and the correspondingElement attribute on this SVGElementInstance object

    // is the SVGRectElement that corresponds to the referenced 'rect' element.

    m_targetElementInstance = SVGElementInstance::create(this, target);

    // Eventually enter recursion to build SVGElementInstance objects for the sub-tree children

    bool foundProblem = false;

    buildInstanceTree(target, m_targetElementInstance.get(), foundProblem);

    // SVG specification does not say a word about <use> & cycles. My view on this is: just ignore it!

    // Non-appearing <use> content is easier to debug, then half-appearing content.

    if (foundProblem) {

        m_targetElementInstance = 0;

        return;

    }

    // Assure instance tree building was successfull

    ASSERT(m_targetElementInstance);

    ASSERT(!m_targetElementInstance->shadowTreeElement());

    ASSERT(m_targetElementInstance->correspondingUseElement() == this);