/*

 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)

 *           (C) 1999 Antti Koivisto (koivisto@kde.org)

 *           (C) 2001 Peter Kelly (pmk@post.com)

 *           (C) 2001 Dirk Mueller (mueller@kde.org)

 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.

 *           (C) 2007 Eric Seidel (eric@webkit.org)

 *

 * 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"

#include "NamedNodeMap.h"

#include "Attr.h"

#include "Document.h"

#include "Element.h"

#include "ExceptionCode.h"

#include "HTMLNames.h"

namespace WebCore {

using namespace HTMLNames;

static inline bool shouldIgnoreAttributeCase(const Element* e)

{

    return e && e->document()->isHTMLDocument() && e->isHTMLElement();

}

inline void NamedNodeMap::detachAttributesFromElement()

{

    size_t size = m_attributes.size();

    for (size_t i = 0; i < size; i++) {

        if (Attr* attr = m_attributes[i]->attr())

            attr->m_element = 0;

    }

}

NamedNodeMap::~NamedNodeMap()

{

    detachAttributesFromElement();

}

PassRefPtr<Node> NamedNodeMap::getNamedItem(const String& name) const

{

    Attribute* a = getAttributeItem(name, shouldIgnoreAttributeCase(m_element));

    if (!a)

        return 0;

    return a->createAttrIfNeeded(m_element);

}

PassRefPtr<Node> NamedNodeMap::getNamedItemNS(const String& namespaceURI, const String& localName) const

{

    return getNamedItem(QualifiedName(nullAtom, localName, namespaceURI));

}

PassRefPtr<Node> NamedNodeMap::removeNamedItem(const String& name, ExceptionCode& ec)

{

    Attribute* a = getAttributeItem(name, shouldIgnoreAttributeCase(m_element));

    if (!a) {

        ec = NOT_FOUND_ERR;

        return 0;

    }

    return removeNamedItem(a->name(), ec);

}

PassRefPtr<Node> NamedNodeMap::removeNamedItemNS(const String& namespaceURI, const String& localName, ExceptionCode& ec)

{

    return removeNamedItem(QualifiedName(nullAtom, localName, namespaceURI), ec);

}

PassRefPtr<Node> NamedNodeMap::getNamedItem(const QualifiedName& name) const

{

    Attribute* a = getAttributeItem(name);

    if (!a)

        return 0;

    return a->createAttrIfNeeded(m_element);

}

PassRefPtr<Node> NamedNodeMap::setNamedItem(Node* arg, ExceptionCode& ec)

{

    if (!m_element || !arg) {

        ec = NOT_FOUND_ERR;

        return 0;

    }

    // WRONG_DOCUMENT_ERR: Raised if arg was created from a different document than the one that created this map.

    if (arg->document() != m_element->document()) {

        ec = WRONG_DOCUMENT_ERR;

        return 0;

    }

    // Not mentioned in spec: throw a HIERARCHY_REQUEST_ERROR if the user passes in a non-attribute node

    if (!arg->isAttributeNode()) {

        ec = HIERARCHY_REQUEST_ERR;

        return 0;

    }

    Attr *attr = static_cast<Attr*>(arg);

    Attribute* a = attr->attr();

    Attribute* old = getAttributeItem(a->name());

    if (old == a)

        return RefPtr<Node>(arg); // we know about it already

    // INUSE_ATTRIBUTE_ERR: Raised if arg is an Attr that is already an attribute of another Element object.

    // The DOM user must explicitly clone Attr nodes to re-use them in other elements.

    if (attr->ownerElement()) {

        ec = INUSE_ATTRIBUTE_ERR;

        return 0;

    }

    if (attr->isId())

        m_element->updateId(old ? old->value() : nullAtom, a->value());

    // ### slightly inefficient - resizes attribute array twice.

    RefPtr<Node> r;

    if (old) {

        r = old->createAttrIfNeeded(m_element);

        removeAttribute(a->name());

    }

    addAttribute(a);

    return r.release();

}

PassRefPtr<Node> NamedNodeMap::setNamedItemNS(Node* node, ExceptionCode& ec)

{

    return setNamedItem(node, ec);

}

// The DOM2 spec doesn't say that removeAttribute[NS] throws NOT_FOUND_ERR

// if the attribute is not found, but at this level we have to throw NOT_FOUND_ERR

// because of removeNamedItem, removeNamedItemNS, and removeAttributeNode.

PassRefPtr<Node> NamedNodeMap::removeNamedItem(const QualifiedName& name, ExceptionCode& ec)

{

    Attribute* a = getAttributeItem(name);

    if (!a) {

        ec = NOT_FOUND_ERR;

        return 0;

    }

    RefPtr<Attr> r = a->createAttrIfNeeded(m_element);

    if (r->isId())

        m_element->updateId(a->value(), nullAtom);

    removeAttribute(name);

    return r.release();

}

PassRefPtr<Node> NamedNodeMap::item(unsigned index) const

{

    if (index >= length())

        return 0;

    return m_attributes[index]->createAttrIfNeeded(m_element);

}

void NamedNodeMap::copyAttributesToVector(Vector<RefPtr<Attribute> >& copy)

{

    copy = m_attributes;

}

Attribute* NamedNodeMap::getAttributeItemSlowCase(const String& name, bool shouldIgnoreAttributeCase) const

{

    unsigned len = length();

    // Continue to checking case-insensitively and/or full namespaced names if necessary:

    for (unsigned i = 0; i < len; ++i) {

        const QualifiedName& attrName = m_attributes[i]->name();

        if (!attrName.hasPrefix()) {

            if (shouldIgnoreAttributeCase && equalIgnoringCase(name, attrName.localName()))

                return m_attributes[i].get();

        } else {

            // FIXME: Would be faster to do this comparison without calling toString, which

            // generates a temporary string by concatenation. But this branch is only reached

            // if the attribute name has a prefix, which is rare in HTML.

            if (equalPossiblyIgnoringCase(name, attrName.toString(), shouldIgnoreAttributeCase))

                return m_attributes[i].get();

        }

    }

    return 0;

}

void NamedNodeMap::clearAttributes()

{

    m_classNames.clear();

    m_mappedAttributeCount = 0;

    detachAttributesFromElement();

    m_attributes.clear();

}

void NamedNodeMap::detachFromElement()

{

    // This can't happen if the holder of the map is JavaScript, because we mark the

    // element if the map is alive. So it has no impact on web page behavior. Because

    // of that, we can simply clear all the attributes to avoid accessing stale

    // pointers to do things like create Attr objects.

    m_element = 0;

    clearAttributes();

}

void NamedNodeMap::setAttributes(const NamedNodeMap& other)

{

    // clone all attributes in the other map, but attach to our element

    if (!m_element)

        return;

    // If assigning the map changes the id attribute, we need to call

    // updateId.

    Attribute* oldId = getAttributeItem(m_element->document()->idAttributeName());

    Attribute* newId = other.getAttributeItem(m_element->document()->idAttributeName());

    if (oldId || newId)

        m_element->updateId(oldId ? oldId->value() : nullAtom, newId ? newId->value() : nullAtom);

    clearAttributes();

    unsigned newLength = other.length();

    m_attributes.resize(newLength);

    for (unsigned i = 0; i < newLength; i++)

        m_attributes[i] = other.m_attributes[i]->clone();

    // FIXME: This is wasteful.  The class list could be preserved on a copy, and we

    // wouldn't have to waste time reparsing the attribute.

    // The derived class, HTMLNamedNodeMap, which manages a parsed class list for the CLASS attribute,

    // will update its member variable when parse attribute is called.

    for (unsigned i = 0; i < newLength; i++)

        m_element->attributeChanged(m_attributes[i].get(), true);

}

void NamedNodeMap::addAttribute(PassRefPtr<Attribute> prpAttribute)

{

    RefPtr<Attribute> attribute = prpAttribute;

    // Add the attribute to the list

    m_attributes.append(attribute);

    if (Attr* attr = attribute->attr())

        attr->m_element = m_element;

    // Notify the element that the attribute has been added, and dispatch appropriate mutation events

    // Note that element may be null here if we are called from insertAttribute() during parsing

    if (m_element) {

        m_element->attributeChanged(attribute.get());

        // Because of our updateStyleAttribute() style modification events are never sent at the right time, so don't bother sending them.

        if (attribute->name() != styleAttr) {

            m_element->dispatchAttrAdditionEvent(attribute.get());

            m_element->dispatchSubtreeModifiedEvent();

        }

    }

}

void NamedNodeMap::removeAttribute(const QualifiedName& name)

{

    unsigned len = length();

    unsigned index = len;

    for (unsigned i = 0; i < len; ++i) {

        if (m_attributes[i]->name().matches(name)) {

            index = i;

            break;

        }

    }

    if (index >= len)

        return;

    // Remove the attribute from the list

    RefPtr<Attribute> attr = m_attributes[index].get();

    if (Attr* a = m_attributes[index]->attr())

        a->m_element = 0;

    m_attributes.remove(index);

    // Notify the element that the attribute has been removed

    // dispatch appropriate mutation events

    if (m_element && !attr->m_value.isNull()) {

        AtomicString value = attr->m_value;

        attr->m_value = nullAtom;

        m_element->attributeChanged(attr.get());

        attr->m_value = value;

    }

    if (m_element) {

        m_element->dispatchAttrRemovalEvent(attr.get());

        m_element->dispatchSubtreeModifiedEvent();

    }

}

void NamedNodeMap::setClass(const String& classStr) 

{ 

    if (!element()->hasClass()) { 

        m_classNames.clear(); 

        return;

    }

    m_classNames.set(classStr, element()->document()->inCompatMode()); 

}

int NamedNodeMap::declCount() const

{

    int result = 0;

    for (unsigned i = 0; i < length(); i++) {

        Attribute* attr = attributeItem(i);

        if (attr->decl()) {

            ASSERT(attr->isMappedAttribute());

            result++;

        }

    }

    return result;

}

bool NamedNodeMap::mapsEquivalent(const NamedNodeMap* otherMap) const

{

    if (!otherMap)

        return false;

    unsigned len = length();

    if (len != otherMap->length())

        return false;

    for (unsigned i = 0; i < len; i++) {

        Attribute* attr = attributeItem(i);

        Attribute* otherAttr = otherMap->getAttributeItem(attr->name());

        if (!otherAttr || attr->value() != otherAttr->value())

            return false;

    }

    return true;

}

bool NamedNodeMap::mappedMapsEquivalent(const NamedNodeMap* otherMap) const

{

    // The # of decls must match.

    if (declCount() != otherMap->declCount())

        return false;

    // The values for each decl must match.

    for (unsigned i = 0; i < length(); i++) {

        Attribute* attr = attributeItem(i);

        if (attr->decl()) {

            ASSERT(attr->isMappedAttribute());

            Attribute* otherAttr = otherMap->getAttributeItem(attr->name());

            if (!otherAttr || attr->value() != otherAttr->value())

                return false;

        }

    }

    return true;

}

} // namespace WebCore