/*

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

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#include "markup.h"

#include "CDATASection.h"

#include "CharacterNames.h"

#include "Comment.h"

#include "CSSComputedStyleDeclaration.h"

#include "CSSMutableStyleDeclaration.h"

#include "CSSPrimitiveValue.h"

#include "CSSProperty.h"

#include "CSSPropertyNames.h"

#include "CSSRule.h"

#include "CSSRuleList.h"

#include "CSSStyleRule.h"

#include "CSSStyleSelector.h"

#include "CSSValue.h"

#include "CSSValueKeywords.h"

#include "DeleteButtonController.h"

#include "DocumentFragment.h"

#include "DocumentType.h"

#include "Editor.h"

#include "Frame.h"

#include "HTMLElement.h"

#include "HTMLNames.h"

#include "InlineTextBox.h"

#include "KURL.h"

#include "Logging.h"

#include "ProcessingInstruction.h"

#include "Range.h"

#include "VisibleSelection.h"

#include "TextIterator.h"

#include "XMLNSNames.h"

#include "htmlediting.h"

#include "visible_units.h"

#include <wtf/StdLibExtras.h>

#include "ApplyStyleCommand.h"

using namespace std;

namespace WebCore {

using namespace HTMLNames;

static inline bool shouldSelfClose(const Node *node);

class AttributeChange {

public:

    AttributeChange()

        : m_name(nullAtom, nullAtom, nullAtom)

    {

    }

    AttributeChange(PassRefPtr<Element> element, const QualifiedName& name, const String& value)

        : m_element(element), m_name(name), m_value(value)

    {

    }

    void apply()

    {

        m_element->setAttribute(m_name, m_value);

    }

private:

    RefPtr<Element> m_element;

    QualifiedName m_name;

    String m_value;

};

static void appendAttributeValue(Vector<UChar>& result, const String& attr, bool escapeNBSP)

{

    const UChar* uchars = attr.characters();

    unsigned len = attr.length();

    unsigned lastCopiedFrom = 0;

    DEFINE_STATIC_LOCAL(const String, ampEntity, ("&"));

    DEFINE_STATIC_LOCAL(const String, gtEntity, (">"));

    DEFINE_STATIC_LOCAL(const String, ltEntity, ("<"));

    DEFINE_STATIC_LOCAL(const String, quotEntity, ("""));

    DEFINE_STATIC_LOCAL(const String, nbspEntity, (" "));

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

        UChar c = uchars[i];

        switch (c) {

            case '&':

                result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);

                append(result, ampEntity);

                lastCopiedFrom = i + 1;

                break;

            case '<':

                result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);

                append(result, ltEntity);

                lastCopiedFrom = i + 1;

                break;

            case '>':

                result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);

                append(result, gtEntity);

                lastCopiedFrom = i + 1;

                break;

            case '"':

                result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);

                append(result, quotEntity);

                lastCopiedFrom = i + 1;

                break;

            case noBreakSpace:

                if (escapeNBSP) {

                    result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);

                    append(result, nbspEntity);

                    lastCopiedFrom = i + 1;

                }

                break;

        }

    }

    result.append(uchars + lastCopiedFrom, len - lastCopiedFrom);

}

static void appendEscapedContent(Vector<UChar>& result, pair<const UChar*, size_t> range, bool escapeNBSP)

{

    const UChar* uchars = range.first;

    unsigned len = range.second;

    unsigned lastCopiedFrom = 0;

    DEFINE_STATIC_LOCAL(const String, ampEntity, ("&"));

    DEFINE_STATIC_LOCAL(const String, gtEntity, (">"));

    DEFINE_STATIC_LOCAL(const String, ltEntity, ("<"));

    DEFINE_STATIC_LOCAL(const String, nbspEntity, (" "));

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

        UChar c = uchars[i];

        switch (c) {

            case '&':

                result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);

                append(result, ampEntity);

                lastCopiedFrom = i + 1;

                break;

            case '<':

                result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);

                append(result, ltEntity);

                lastCopiedFrom = i + 1;

                break;

            case '>':

                result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);

                append(result, gtEntity);

                lastCopiedFrom = i + 1;

                break;

            case noBreakSpace:

                if (escapeNBSP) {

                    result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);

                    append(result, nbspEntity);

                    lastCopiedFrom = i + 1;

                }

                break;

        }

    }

    result.append(uchars + lastCopiedFrom, len - lastCopiedFrom);

}    

static String escapeContentText(const String& in, bool escapeNBSP)

{

    Vector<UChar> buffer;

    appendEscapedContent(buffer, make_pair(in.characters(), in.length()), escapeNBSP);

    return String::adopt(buffer);

}

static void appendQuotedURLAttributeValue(Vector<UChar>& result, const String& urlString)

{

    UChar quoteChar = '\"';

    String strippedURLString = urlString.stripWhiteSpace();

    if (protocolIsJavaScript(strippedURLString)) {

        // minimal escaping for javascript urls

        if (strippedURLString.contains('"')) {

            if (strippedURLString.contains('\''))

                strippedURLString.replace('\"', """);

            else

                quoteChar = '\'';

        }

        result.append(quoteChar);

        append(result, strippedURLString);

        result.append(quoteChar);

        return;

    }

    // FIXME: This does not fully match other browsers. Firefox percent-escapes non-ASCII characters for innerHTML.

    result.append(quoteChar);

    appendAttributeValue(result, urlString, false);

    result.append(quoteChar);    

}

static String stringValueForRange(const Node* node, const Range* range)

{

    if (!range)

        return node->nodeValue();

    String str = node->nodeValue();

    ExceptionCode ec;

    if (node == range->endContainer(ec))

        str.truncate(range->endOffset(ec));

    if (node == range->startContainer(ec))

        str.remove(0, range->startOffset(ec));

    return str;

}

static inline pair<const UChar*, size_t> ucharRange(const Node *node, const Range *range)

{

    String str = node->nodeValue();

    const UChar* characters = str.characters();

    size_t length = str.length();

    if (range) {

        ExceptionCode ec;

        if (node == range->endContainer(ec))

            length = range->endOffset(ec);

        if (node == range->startContainer(ec)) {

            size_t start = range->startOffset(ec);

            characters += start;

            length -= start;

        }

    }

    return make_pair(characters, length);

}

static inline void appendUCharRange(Vector<UChar>& result, const pair<const UChar*, size_t> range)

{

    result.append(range.first, range.second);

}

static String renderedText(const Node* node, const Range* range)

{

    if (!node->isTextNode())

        return String();

    ExceptionCode ec;

    const Text* textNode = static_cast<const Text*>(node);

    unsigned startOffset = 0;

    unsigned endOffset = textNode->length();

    if (range && node == range->startContainer(ec))

        startOffset = range->startOffset(ec);

    if (range && node == range->endContainer(ec))

        endOffset = range->endOffset(ec);

    Position start(const_cast<Node*>(node), startOffset);

    Position end(const_cast<Node*>(node), endOffset);

    return plainText(Range::create(node->document(), start, end).get());

}

static PassRefPtr<CSSMutableStyleDeclaration> styleFromMatchedRulesForElement(Element* element, bool authorOnly = true)

{

    RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create();

    RefPtr<CSSRuleList> matchedRules = element->document()->styleSelector()->styleRulesForElement(element, authorOnly);

    if (matchedRules) {

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

            if (matchedRules->item(i)->type() == CSSRule::STYLE_RULE) {

                RefPtr<CSSMutableStyleDeclaration> s = static_cast<CSSStyleRule*>(matchedRules->item(i))->style();

                style->merge(s.get(), true);

            }

        }

    }

    return style.release();

}

static void removeEnclosingMailBlockquoteStyle(CSSMutableStyleDeclaration* style, Node* node)

{

    Node* blockquote = nearestMailBlockquote(node);

    if (!blockquote || !blockquote->parentNode())

        return;

    removeStylesAddedByNode(style, blockquote);

}

static void removeDefaultStyles(CSSMutableStyleDeclaration* style, Document* document)

{

    if (!document || !document->documentElement())

        return;

    prepareEditingStyleToApplyAt(style, Position(document->documentElement(), 0));

}

static bool shouldAddNamespaceElem(const Element* elem)

{

    // Don't add namespace attribute if it is already defined for this elem.

    const AtomicString& prefix = elem->prefix();

    AtomicString attr = !prefix.isEmpty() ? "xmlns:" + prefix : "xmlns";

    return !elem->hasAttribute(attr);

}

static bool shouldAddNamespaceAttr(const Attribute* attr, HashMap<AtomicStringImpl*, AtomicStringImpl*>& namespaces)

{

    namespaces.checkConsistency();

    // Don't add namespace attributes twice

    if (attr->name() == XMLNSNames::xmlnsAttr) {

        namespaces.set(emptyAtom.impl(), attr->value().impl());

        return false;

    }

    QualifiedName xmlnsPrefixAttr(xmlnsAtom, attr->localName(), XMLNSNames::xmlnsNamespaceURI);

    if (attr->name() == xmlnsPrefixAttr) {

        namespaces.set(attr->localName().impl(), attr->value().impl());

        return false;

    }

    return true;

}

static void appendNamespace(Vector<UChar>& result, const AtomicString& prefix, const AtomicString& ns, HashMap<AtomicStringImpl*, AtomicStringImpl*>& namespaces)

{

    namespaces.checkConsistency();

    if (ns.isEmpty())

        return;

    // Use emptyAtoms's impl() for both null and empty strings since the HashMap can't handle 0 as a key

    AtomicStringImpl* pre = prefix.isEmpty() ? emptyAtom.impl() : prefix.impl();

    AtomicStringImpl* foundNS = namespaces.get(pre);

    if (foundNS != ns.impl()) {

        namespaces.set(pre, ns.impl());

        result.append(' ');

        append(result, xmlnsAtom.string());

        if (!prefix.isEmpty()) {

            result.append(':');

            append(result, prefix);

        }

        result.append('=');

        result.append('"');

        appendAttributeValue(result, ns, false);

        result.append('"');

    }

}

static void appendDocumentType(Vector<UChar>& result, const DocumentType* n)

{

    if (n->name().isEmpty())

        return;

    append(result, "<!DOCTYPE ");

    append(result, n->name());

    if (!n->publicId().isEmpty()) {

        append(result, " PUBLIC \"");

        append(result, n->publicId());

        append(result, "\"");

        if (!n->systemId().isEmpty()) {

            append(result, " \"");

            append(result, n->systemId());

            append(result, "\"");

        }

    } else if (!n->systemId().isEmpty()) {

        append(result, " SYSTEM \"");

        append(result, n->systemId());

        append(result, "\"");

    }

    if (!n->internalSubset().isEmpty()) {

        append(result, " [");

        append(result, n->internalSubset());

        append(result, "]");

    }

    append(result, ">");

}

static void removeExteriorStyles(CSSMutableStyleDeclaration* style)

{

    style->removeProperty(CSSPropertyFloat);

}

enum RangeFullySelectsNode { DoesFullySelectNode, DoesNotFullySelectNode };

static void appendStartMarkup(Vector<UChar>& result, const Node* node, const Range* range, EAnnotateForInterchange annotate, EAbsoluteURLs absoluteURLs, bool convertBlocksToInlines, HashMap<AtomicStringImpl*, AtomicStringImpl*>* namespaces, RangeFullySelectsNode rangeFullySelectsNode = DoesFullySelectNode)

{

    if (namespaces)

        namespaces->checkConsistency();

    bool documentIsHTML = node->document()->isHTMLDocument();

    switch (node->nodeType()) {

        case Node::TEXT_NODE: {

            if (Node* parent = node->parentNode()) {

                if (parent->hasTagName(scriptTag)

                    || parent->hasTagName(styleTag)

                    || parent->hasTagName(xmpTag)) {

                    appendUCharRange(result, ucharRange(node, range));

                    break;

                } else if (parent->hasTagName(textareaTag)) {

                    appendEscapedContent(result, ucharRange(node, range), documentIsHTML);                    

                    break;

                }

            }

            if (!annotate) {

                appendEscapedContent(result, ucharRange(node, range), documentIsHTML);

                break;

            }

            bool useRenderedText = !enclosingNodeWithTag(Position(const_cast<Node*>(node), 0), selectTag);

            String markup = escapeContentText(useRenderedText ? renderedText(node, range) : stringValueForRange(node, range), false);

            markup = convertHTMLTextToInterchangeFormat(markup, static_cast<const Text*>(node));

            append(result, markup);

            break;

        }

        case Node::COMMENT_NODE:

            // FIXME: Comment content is not escaped, but XMLSerializer (and possibly other callers) should raise an exception if it includes "-->".

            append(result, "<!--");

            append(result, static_cast<const Comment*>(node)->data());

            append(result, "-->");

            break;

        case Node::DOCUMENT_NODE:

        case Node::DOCUMENT_FRAGMENT_NODE:

            break;

        case Node::DOCUMENT_TYPE_NODE:

            appendDocumentType(result, static_cast<const DocumentType*>(node));

            break;

        case Node::PROCESSING_INSTRUCTION_NODE: {

            // FIXME: PI data is not escaped, but XMLSerializer (and possibly other callers) this should raise an exception if it includes "?>".

            const ProcessingInstruction* n = static_cast<const ProcessingInstruction*>(node);

            append(result, "<?");

            append(result, n->target());

            append(result, " ");

            append(result, n->data());

            append(result, "?>");

            break;

        }

        case Node::ELEMENT_NODE: {

            result.append('<');

            const Element* el = static_cast<const Element*>(node);

            bool convert = convertBlocksToInlines && isBlock(const_cast<Node*>(node));

            append(result, el->nodeNamePreservingCase());

            NamedNodeMap *attrs = el->attributes();

            unsigned length = attrs->length();

            if (!documentIsHTML && namespaces && shouldAddNamespaceElem(el))

                appendNamespace(result, el->prefix(), el->namespaceURI(), *namespaces);

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

                Attribute *attr = attrs->attributeItem(i);

                // We'll handle the style attribute separately, below.

                if (attr->name() == styleAttr && el->isHTMLElement() && (annotate || convert))

                    continue;

                result.append(' ');

                if (documentIsHTML)

                    append(result, attr->name().localName());

                else

                    append(result, attr->name().toString());

                result.append('=');

                if (el->isURLAttribute(attr)) {

                    // We don't want to complete file:/// URLs because it may contain sensitive information

                    // about the user's system.

                    if (absoluteURLs == AbsoluteURLs && !node->document()->url().isLocalFile())

                        appendQuotedURLAttributeValue(result, node->document()->completeURL(attr->value()).string());

                    else

                        appendQuotedURLAttributeValue(result, attr->value().string());

                } else {

                    result.append('\"');

                    appendAttributeValue(result, attr->value(), documentIsHTML);

                    result.append('\"');

                }

                if (!documentIsHTML && namespaces && shouldAddNamespaceAttr(attr, *namespaces))

                    appendNamespace(result, attr->prefix(), attr->namespaceURI(), *namespaces);

            }

            if (el->isHTMLElement() && (annotate || convert)) {

                Element* element = const_cast<Element*>(el);

                RefPtr<CSSMutableStyleDeclaration> style = static_cast<HTMLElement*>(element)->getInlineStyleDecl()->copy();

                if (annotate) {

                    RefPtr<CSSMutableStyleDeclaration> styleFromMatchedRules = styleFromMatchedRulesForElement(const_cast<Element*>(el));

                    // Styles from the inline style declaration, held in the variable "style", take precedence 

                    // over those from matched rules.

                    styleFromMatchedRules->merge(style.get());

                    style = styleFromMatchedRules;

                    RefPtr<CSSComputedStyleDeclaration> computedStyleForElement = computedStyle(element);

                    RefPtr<CSSMutableStyleDeclaration> fromComputedStyle = CSSMutableStyleDeclaration::create();

                    {

                        CSSMutableStyleDeclaration::const_iterator end = style->end();

                        for (CSSMutableStyleDeclaration::const_iterator it = style->begin(); it != end; ++it) {

                            const CSSProperty& property = *it;

                            CSSValue* value = property.value();

                            // The property value, if it's a percentage, may not reflect the actual computed value.  

                            // For example: style="height: 1%; overflow: visible;" in quirksmode

                            // FIXME: There are others like this, see <rdar://problem/5195123> Slashdot copy/paste fidelity problem

                            if (value->cssValueType() == CSSValue::CSS_PRIMITIVE_VALUE)

                                if (static_cast<CSSPrimitiveValue*>(value)->primitiveType() == CSSPrimitiveValue::CSS_PERCENTAGE)

                                    if (RefPtr<CSSValue> computedPropertyValue = computedStyleForElement->getPropertyCSSValue(property.id()))

                                        fromComputedStyle->addParsedProperty(CSSProperty(property.id(), computedPropertyValue));

                        }

                    }

                    style->merge(fromComputedStyle.get());

                }

                if (convert)

                    style->setProperty(CSSPropertyDisplay, CSSValueInline, true);

                // If the node is not fully selected by the range, then we don't want to keep styles that affect its relationship to the nodes around it

                // only the ones that affect it and the nodes within it.

                if (rangeFullySelectsNode == DoesNotFullySelectNode)

                    removeExteriorStyles(style.get());

                if (style->length() > 0) {

                    DEFINE_STATIC_LOCAL(const String, stylePrefix, (" style=\""));

                    append(result, stylePrefix);

                    appendAttributeValue(result, style->cssText(), documentIsHTML);

                    result.append('\"');