/*
    Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>

    This file is part of the KDE project

    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 "wtf/Platform.h"

#if ENABLE(SVG)
#include "SVGElementInstance.h"

/*#include "Event.h"
#include "EventListener.h"*/
#include "SVGElementInstanceList.h"
#include "SVGUseElement.h"

#include <wtf/Assertions.h>

namespace WebCore
{

SVGElementInstance::SVGElementInstance(SVGUseElement *useElement, PassRefPtr<SVGElement> originalElement)
    : m_refCount(0)
    , m_parent(nullptr)
    , m_useElement(useElement)
    , m_element(originalElement)
    , m_shadowTreeElement(nullptr)
    , m_previousSibling(nullptr)
    , m_nextSibling(nullptr)
    , m_firstChild(nullptr)
    , m_lastChild(nullptr)
{
    ASSERT(m_useElement);
    ASSERT(m_element);

    // Register as instance for passed element.
    m_element->document()->accessSVGExtensions()->mapInstanceToElement(this, m_element.get());
}

SVGElementInstance::~SVGElementInstance()
{
    for (RefPtr<SVGElementInstance> child = m_firstChild; child; child = child->m_nextSibling) {
        child->setParent(nullptr);
    }

    // Deregister as instance for passed element.
    m_element->document()->accessSVGExtensions()->removeInstanceMapping(this, m_element.get());
}

SVGElement *SVGElementInstance::correspondingElement() const
{
    return m_element.get();
}

SVGUseElement *SVGElementInstance::correspondingUseElement() const
{
    return m_useElement;
}

SVGElementInstance *SVGElementInstance::parentNode() const
{
    return parent();
}

PassRefPtr<SVGElementInstanceList> SVGElementInstance::childNodes()
{
    return SVGElementInstanceList::create(this);
}

SVGElementInstance *SVGElementInstance::previousSibling() const
{
    return m_previousSibling;
}

SVGElementInstance *SVGElementInstance::nextSibling() const
{
    return m_nextSibling;
}

SVGElementInstance *SVGElementInstance::firstChild() const
{
    return m_firstChild;
}

SVGElementInstance *SVGElementInstance::lastChild() const
{
    return m_lastChild;
}

SVGElement *SVGElementInstance::shadowTreeElement() const
{
    return m_shadowTreeElement;
}

void SVGElementInstance::setShadowTreeElement(SVGElement *element)
{
    ASSERT(element);
    m_shadowTreeElement = element;
}

void SVGElementInstance::appendChild(PassRefPtr<SVGElementInstance> child)
{
    child->setParent(this);

    if (m_lastChild) {
        child->m_previousSibling = m_lastChild;
        m_lastChild->m_nextSibling = child.get();
    } else {
        m_firstChild = child.get();
    }

    m_lastChild = child.get();
}

// Helper function for updateInstance
static bool containsUseChildNode(Node *start)
{
    if (start->hasTagName(SVGNames::useTag)) {
        return true;
    }

    for (Node *current = start->firstChild(); current; current = current->nextSibling()) {
        if (containsUseChildNode(current)) {
            return true;
        }
    }

    return false;
}

void SVGElementInstance::updateInstance(SVGElement *element)
{
    ASSERT(element == m_element);
    ASSERT(m_shadowTreeElement);
    Q_UNUSED(element);

    // TODO: Eventually come up with a more optimized updating logic for the cases below:
    //
    // <symbol>: We can't just clone the original element, we need to apply
    // the same "replace by generated content" logic that SVGUseElement does.
    //
    // <svg>: <use> on <svg> is too rare to actually implement it faster.
    // If someone still wants to do it: recloning, adjusting width/height attributes is enough.
    //
    // <use>: Too hard to get it right in a fast way. Recloning seems the only option.

    if (m_element->hasTagName(SVGNames::symbolTag) ||
            m_element->hasTagName(SVGNames::svgTag) ||
            containsUseChildNode(m_element.get())) {
        m_useElement->buildPendingResource();
        return;
    }

    // For all other nodes this logic is sufficient.
    WTF::PassRefPtr<Node> clone = m_element->cloneNode(true);
    SVGUseElement::removeDisallowedElementsFromSubtree(clone.get());
    SVGElement *svgClone = nullptr;
    if (clone && clone->isSVGElement()) {
        svgClone = static_cast<SVGElement *>(clone.get());
    }
    ASSERT(svgClone);

    // Replace node in the <use> shadow tree
    /*ExceptionCode*//*khtml*/int ec = 0;
    m_shadowTreeElement->parentNode()->replaceChild(clone.releaseRef(), m_shadowTreeElement, ec);
    ASSERT(ec == 0);

    m_shadowTreeElement = svgClone;
}

SVGElementInstance *SVGElementInstance::toSVGElementInstance()
{
    return this;
}

EventTargetNode *SVGElementInstance::toNode()
{
    return m_element.get();
}

void SVGElementInstance::addEventListener(const AtomicString &eventType, PassRefPtr<EventListener> eventListener, bool useCapture)
{
    Q_UNUSED(eventType);
    Q_UNUSED(eventListener);
    Q_UNUSED(useCapture);
    // FIXME!
}

void SVGElementInstance::removeEventListener(const AtomicString &eventType, EventListener *eventListener, bool useCapture)
{
    Q_UNUSED(eventType);
    Q_UNUSED(eventListener);
    Q_UNUSED(useCapture);
    // FIXME!
}

bool SVGElementInstance::dispatchEvent(PassRefPtr<Event>, ExceptionCode &ec, bool tempEvent)
{
    Q_UNUSED(ec);
    Q_UNUSED(tempEvent);
    // FIXME!
    return false;
}

}

#endif // ENABLE(SVG)

