/*

 * Copyright (C) 2005, 2006 Apple Computer, 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 "ApplyStyleCommand.h"

#include "CSSComputedStyleDeclaration.h"

#include "CSSProperty.h"

#include "CSSPropertyNames.h"

#include "Document.h"

#include "HTMLElement.h"

#include "HTMLInterchange.h"

#include "HTMLNames.h"

#include "NodeList.h"

#include "Range.h"

#include "RenderObject.h"

#include "Text.h"

#include "TextIterator.h"

#include "htmlediting.h"

#include "visible_units.h"

namespace WebCore {

using namespace HTMLNames;

class StyleChange {

public:

    enum ELegacyHTMLStyles { DoNotUseLegacyHTMLStyles, UseLegacyHTMLStyles };

    explicit StyleChange(CSSStyleDeclaration *, ELegacyHTMLStyles usesLegacyStyles=UseLegacyHTMLStyles);

    StyleChange(CSSStyleDeclaration *, const Position &, ELegacyHTMLStyles usesLegacyStyles=UseLegacyHTMLStyles);

    static ELegacyHTMLStyles styleModeForParseMode(bool);

    String cssStyle() const { return m_cssStyle; }

    bool applyBold() const { return m_applyBold; }

    bool applyItalic() const { return m_applyItalic; }

    bool applyFontColor() const { return m_applyFontColor.length() > 0; }

    bool applyFontFace() const { return m_applyFontFace.length() > 0; }

    bool applyFontSize() const { return m_applyFontSize.length() > 0; }

    String fontColor() { return m_applyFontColor; }

    String fontFace() { return m_applyFontFace; }

    String fontSize() { return m_applyFontSize; }

    bool usesLegacyStyles() const { return m_usesLegacyStyles; }

private:

    void init(PassRefPtr<CSSStyleDeclaration>, const Position &);

    bool checkForLegacyHTMLStyleChange(const CSSProperty *);

    static bool currentlyHasStyle(const Position &, const CSSProperty *);

    String m_cssStyle;

    bool m_applyBold;

    bool m_applyItalic;

    String m_applyFontColor;

    String m_applyFontFace;

    String m_applyFontSize;

    bool m_usesLegacyStyles;

};

StyleChange::StyleChange(CSSStyleDeclaration *style, ELegacyHTMLStyles usesLegacyStyles)

    : m_applyBold(false), m_applyItalic(false), m_usesLegacyStyles(usesLegacyStyles)

{

    init(style, Position());

}

StyleChange::StyleChange(CSSStyleDeclaration *style, const Position &position, ELegacyHTMLStyles usesLegacyStyles)

    : m_applyBold(false), m_applyItalic(false), m_usesLegacyStyles(usesLegacyStyles)

{

    init(style, position);

}

void StyleChange::init(PassRefPtr<CSSStyleDeclaration> style, const Position &position)

{

    RefPtr<CSSMutableStyleDeclaration> mutableStyle = style->makeMutable();

    String styleText("");

    DeprecatedValueListConstIterator<CSSProperty> end;

    for (DeprecatedValueListConstIterator<CSSProperty> it = mutableStyle->valuesIterator(); it != end; ++it) {

        const CSSProperty *property = &*it;

        // If position is empty or the position passed in already has the 

        // style, just move on.

        if (position.isNotNull() && currentlyHasStyle(position, property))

            continue;

        // Changing the whitespace style in a tab span would collapse the tab into a space.

        if (property->id() == CSS_PROP_WHITE_SPACE && (isTabSpanTextNode(position.node()) || isTabSpanNode((position.node()))))

            continue;

        // If needed, figure out if this change is a legacy HTML style change.

        if (m_usesLegacyStyles && checkForLegacyHTMLStyleChange(property))

            continue;

        // Add this property

        if (property->id() == CSS_PROP__WEBKIT_TEXT_DECORATIONS_IN_EFFECT) {

            // we have to special-case text decorations

            CSSProperty alteredProperty = CSSProperty(CSS_PROP_TEXT_DECORATION, property->value(), property->isImportant());

            styleText += alteredProperty.cssText();

        } else

            styleText += property->cssText();

    }

    // Save the result for later

    m_cssStyle = styleText.stripWhiteSpace();

}

StyleChange::ELegacyHTMLStyles StyleChange::styleModeForParseMode(bool isQuirksMode)

{

    return isQuirksMode ? UseLegacyHTMLStyles : DoNotUseLegacyHTMLStyles;

}

bool StyleChange::checkForLegacyHTMLStyleChange(const CSSProperty *property)

{

    if (!property || !property->value()) {

        return false;

    }

    String valueText(property->value()->cssText());

    switch (property->id()) {

        case CSS_PROP_FONT_WEIGHT:

            if (equalIgnoringCase(valueText, "bold")) {

                m_applyBold = true;

                return true;

            }

            break;

        case CSS_PROP_FONT_STYLE:

            if (equalIgnoringCase(valueText, "italic") || equalIgnoringCase(valueText, "oblique")) {

                m_applyItalic = true;

                return true;

            }

            break;

        case CSS_PROP_COLOR: {

            Color color(CSSParser::parseColor(valueText));

            m_applyFontColor = color.name();

            return true;

        }

        case CSS_PROP_FONT_FAMILY:

            m_applyFontFace = valueText;

            return true;

        case CSS_PROP_FONT_SIZE:

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

                CSSPrimitiveValue *value = static_cast<CSSPrimitiveValue *>(property->value());

                if (value->primitiveType() < CSSPrimitiveValue::CSS_PX || value->primitiveType() > CSSPrimitiveValue::CSS_PC)

                    // Size keyword or relative unit.

                    return false;

                float number = value->getFloatValue(CSSPrimitiveValue::CSS_PX);

                if (number <= 9)

                    m_applyFontSize = "1";

                else if (number <= 10)

                    m_applyFontSize = "2";

                else if (number <= 13)

                    m_applyFontSize = "3";

                else if (number <= 16)

                    m_applyFontSize = "4";

                else if (number <= 18)

                    m_applyFontSize = "5";

                else if (number <= 24)

                    m_applyFontSize = "6";

                else

                    m_applyFontSize = "7";

                // Huge quirk in Microsft Entourage is that they understand CSS font-size, but also write 

                // out legacy 1-7 values in font tags (I guess for mailers that are not CSS-savvy at all, 

                // like Eudora). Yes, they write out *both*. We need to write out both as well. Return false.

                return false; 

            }

            else {

                // Can't make sense of the number. Put no font size.

                return true;

            }

    }

    return false;

}

bool StyleChange::currentlyHasStyle(const Position &pos, const CSSProperty *property)

{

    ASSERT(pos.isNotNull());

    RefPtr<CSSComputedStyleDeclaration> style = pos.computedStyle();

    RefPtr<CSSValue> value = style->getPropertyCSSValue(property->id(), DoNotUpdateLayout);

    if (!value)

        return false;

    return equalIgnoringCase(value->cssText(), property->value()->cssText());

}

static String &styleSpanClassString()

{

    static String styleSpanClassString = AppleStyleSpanClass;

    return styleSpanClassString;

}

bool isStyleSpan(const Node *node)

{

    if (!node || !node->isHTMLElement())

        return false;

    const HTMLElement *elem = static_cast<const HTMLElement *>(node);

    return elem->hasLocalName(spanAttr) && elem->getAttribute(classAttr) == styleSpanClassString();

}

static bool isUnstyledStyleSpan(const Node *node)

{

    if (!node || !node->isHTMLElement() || !node->hasTagName(spanTag))

        return false;

    const HTMLElement *elem = static_cast<const HTMLElement *>(node);

    CSSMutableStyleDeclaration *inlineStyleDecl = elem->inlineStyleDecl();

    return (!inlineStyleDecl || inlineStyleDecl->length() == 0) && elem->getAttribute(classAttr) == styleSpanClassString();

}

static bool isEmptyFontTag(const Node *node)

{

    if (!node || !node->hasTagName(fontTag))

        return false;

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

    NamedAttrMap *map = elem->attributes(true); // true for read-only

    return (!map || map->length() == 1) && elem->getAttribute(classAttr) == styleSpanClassString();

}

static PassRefPtr<Element> createFontElement(Document* document)

{

    ExceptionCode ec = 0;

    RefPtr<Element> fontNode = document->createElementNS(xhtmlNamespaceURI, "font", ec);

    ASSERT(ec == 0);

    fontNode->setAttribute(classAttr, styleSpanClassString());

    return fontNode.release();

}

PassRefPtr<HTMLElement> createStyleSpanElement(Document* document)

{

    ExceptionCode ec = 0;

    RefPtr<Element> styleElement = document->createElementNS(xhtmlNamespaceURI, "span", ec);

    ASSERT(ec == 0);

    styleElement->setAttribute(classAttr, styleSpanClassString());

    return static_pointer_cast<HTMLElement>(styleElement.release());

}

ApplyStyleCommand::ApplyStyleCommand(Document* document, CSSStyleDeclaration* style, EditAction editingAction, EPropertyLevel propertyLevel)

    : CompositeEditCommand(document)

    , m_style(style->makeMutable())

    , m_editingAction(editingAction)

    , m_propertyLevel(propertyLevel)

    , m_start(endingSelection().start().downstream())

    , m_end(endingSelection().end().upstream())

    , m_useEndingSelection(true)

    , m_styledInlineElement(0)

    , m_removeOnly(false)

{

}

ApplyStyleCommand::ApplyStyleCommand(Document* document, CSSStyleDeclaration* style, const Position& start, const Position& end, EditAction editingAction, EPropertyLevel propertyLevel)

    : CompositeEditCommand(document)

    , m_style(style->makeMutable())

    , m_editingAction(editingAction)

    , m_propertyLevel(propertyLevel)

    , m_start(start)

    , m_end(end)

    , m_useEndingSelection(false)

    , m_styledInlineElement(0)

    , m_removeOnly(false)

{

}

ApplyStyleCommand::ApplyStyleCommand(Element* element, bool removeOnly, EditAction editingAction)

    : CompositeEditCommand(element->document())

    , m_style(new CSSMutableStyleDeclaration())

    , m_editingAction(editingAction)

    , m_propertyLevel(PropertyDefault)

    , m_start(endingSelection().start().downstream())

    , m_end(endingSelection().end().upstream())

    , m_useEndingSelection(true)

    , m_styledInlineElement(element)

    , m_removeOnly(removeOnly)

{

}

void ApplyStyleCommand::updateStartEnd(const Position& newStart, const Position& newEnd)

{

    ASSERT(Range::compareBoundaryPoints(newEnd, newStart) >= 0);

    if (!m_useEndingSelection && (newStart != m_start || newEnd != m_end))

        m_useEndingSelection = true;

    setEndingSelection(Selection(newStart, newEnd, VP_DEFAULT_AFFINITY));

    m_start = newStart;

    m_end = newEnd;

}

Position ApplyStyleCommand::startPosition()

{

    if (m_useEndingSelection)

        return endingSelection().start();

    return m_start;

}

Position ApplyStyleCommand::endPosition()

{

    if (m_useEndingSelection)

        return endingSelection().end();

    return m_end;

}

void ApplyStyleCommand::doApply()

{

    switch (m_propertyLevel) {

        case PropertyDefault: {

            // apply the block-centric properties of the style

            RefPtr<CSSMutableStyleDeclaration> blockStyle = m_style->copyBlockProperties();

            if (blockStyle->length())

                applyBlockStyle(blockStyle.get());

            // apply any remaining styles to the inline elements

            // NOTE: hopefully, this string comparison is the same as checking for a non-null diff

            if (blockStyle->length() < m_style->length() || m_styledInlineElement) {

                RefPtr<CSSMutableStyleDeclaration> inlineStyle = m_style->copy();

                applyRelativeFontStyleChange(inlineStyle.get());

                blockStyle->diff(inlineStyle.get());

                applyInlineStyle(inlineStyle.get());

            }

            break;

        }

        case ForceBlockProperties:

            // Force all properties to be applied as block styles.

            applyBlockStyle(m_style.get());

            break;

    }

}

EditAction ApplyStyleCommand::editingAction() const

{

    return m_editingAction;

}

void ApplyStyleCommand::applyBlockStyle(CSSMutableStyleDeclaration *style)

{

    // update document layout once before removing styles

    // so that we avoid the expense of updating before each and every call

    // to check a computed style

    updateLayout();

    // get positions we want to use for applying style

    Position start = startPosition();

    Position end = endPosition();

    if (Range::compareBoundaryPoints(end, start) < 0) {

        Position swap = start;

        start = end;

        end = swap;

    }

    VisiblePosition visibleStart(start);

    VisiblePosition visibleEnd(end);

    // Save and restore the selection endpoints using their indices in the document, since

    // addBlockStyleIfNeeded may moveParagraphs, which can remove these endpoints.

    // Calculate start and end indices from the start of the tree that they're in.

    Node* scope = highestAncestor(visibleStart.deepEquivalent().node());

    Position rangeStart(scope, 0);

    RefPtr<Range> startRange = new Range(document(), rangeStart, rangeCompliantEquivalent(visibleStart.deepEquivalent()));

    RefPtr<Range> endRange = new Range(document(), rangeStart, rangeCompliantEquivalent(visibleEnd.deepEquivalent()));

    int startIndex = TextIterator::rangeLength(startRange.get(), true);

    int endIndex = TextIterator::rangeLength(endRange.get(), true);

    VisiblePosition paragraphStart(startOfParagraph(visibleStart));

    VisiblePosition nextParagraphStart(endOfParagraph(paragraphStart).next());

    VisiblePosition beyondEnd(endOfParagraph(visibleEnd).next());

    while (paragraphStart.isNotNull() && paragraphStart != beyondEnd) {

        StyleChange styleChange(style, paragraphStart.deepEquivalent(), StyleChange::styleModeForParseMode(document()->inCompatMode()));

        if (styleChange.cssStyle().length() > 0 || m_removeOnly) {

            Node* block = enclosingBlock(paragraphStart.deepEquivalent().node());

            Node* newBlock = moveParagraphContentsToNewBlockIfNecessary(paragraphStart.deepEquivalent());

            if (newBlock)

                block = newBlock;

            ASSERT(block->isHTMLElement());

            if (block->isHTMLElement()) {

                removeCSSStyle(style, static_cast<HTMLElement*>(block));

                if (!m_removeOnly)

                    addBlockStyle(styleChange, static_cast<HTMLElement*>(block));

            }

        }

        paragraphStart = nextParagraphStart;

        nextParagraphStart = endOfParagraph(paragraphStart).next();

    }

    startRange = TextIterator::rangeFromLocationAndLength(static_cast<Element*>(scope), startIndex, 0, true);

    endRange = TextIterator::rangeFromLocationAndLength(static_cast<Element*>(scope), endIndex, 0, true);

    if (startRange && endRange)

        updateStartEnd(startRange->startPosition(), endRange->startPosition());

}

#define NoFontDelta (0.0f)

#define MinimumFontSize (0.1f)

void ApplyStyleCommand::applyRelativeFontStyleChange(CSSMutableStyleDeclaration *style)

{

    RefPtr<CSSValue> value = style->getPropertyCSSValue(CSS_PROP_FONT_SIZE);

    if (value) {

        // Explicit font size overrides any delta.

        style->removeProperty(CSS_PROP__WEBKIT_FONT_SIZE_DELTA);

        return;

    }

    // Get the adjustment amount out of the style.

    value = style->getPropertyCSSValue(CSS_PROP__WEBKIT_FONT_SIZE_DELTA);

    if (!value)

        return;

    float adjustment = NoFontDelta;

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

        CSSPrimitiveValue *primitiveValue = static_cast<CSSPrimitiveValue *>(value.get());

        if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_PX) {

            // Only PX handled now. If we handle more types in the future, perhaps

            // a switch statement here would be more appropriate.

            adjustment = primitiveValue->getFloatValue();

        }

    }

    style->removeProperty(CSS_PROP__WEBKIT_FONT_SIZE_DELTA);

    if (adjustment == NoFontDelta)

        return;

    Position start = startPosition();

    Position end = endPosition();

    if (Range::compareBoundaryPoints(end, start) < 0) {

        Position swap = start;

        start = end;

        end = swap;

    }

    // Join up any adjacent text nodes.

    if (start.node()->isTextNode()) {

        joinChildTextNodes(start.node()->parentNode(), start, end);

        start = startPosition();

        end = endPosition();

    }

    if (end.node()->isTextNode() && start.node()->parentNode() != end.node()->parentNode()) {

        joinChildTextNodes(end.node()->parentNode(), start, end);

        start = startPosition();

        end = endPosition();

    }

    // Split the start text nodes if needed to apply style.

    bool splitStart = splitTextAtStartIfNeeded(start, end); 

    if (splitStart) {

        start = startPosition();

        end = endPosition();

    }

    bool splitEnd = splitTextAtEndIfNeeded(start, end);

    if (splitEnd) {

        start = startPosition();

        end = endPosition();

    }

    // Calculate loop end point.

    // If the end node is before the start node (can only happen if the end node is

    // an ancestor of the start node), we gather nodes up to the next sibling of the end node

    Node *beyondEnd;

    if (start.node()->isDescendantOf(end.node()))

        beyondEnd = end.node()->traverseNextSibling();

    else

        beyondEnd = end.node()->traverseNextNode();

    start = start.upstream(); // Move upstream to ensure we do not add redundant spans.

    Node *startNode = start.node();

    if (startNode->isTextNode() && start.offset() >= startNode->caretMaxOffset()) // Move out of text node if range does not include its characters.

        startNode = startNode->traverseNextNode();

    // Store away font size before making any changes to the document.

    // This ensures that changes to one node won't effect another.

    HashMap<Node*, float> startingFontSizes;

    for (Node *node = startNode; node != beyondEnd; node = node->traverseNextNode())

        startingFontSizes.set(node, computedFontSize(node));

    // These spans were added by us. If empty after font size changes, they can be removed.

    DeprecatedPtrList<Node> unstyledSpans;

    Node *lastStyledNode = 0;

    for (Node *node = startNode; node != beyondEnd; node = node->traverseNextNode()) {

        HTMLElement *elem = 0;

        if (node->isHTMLElement()) {

            // Only work on fully selected nodes.

            if (!nodeFullySelected(node, start, end))

                continue;

            elem = static_cast<HTMLElement *>(node);

        } else if (node->isTextNode() && node->renderer() && node->parentNode() != lastStyledNode) {

            // Last styled node was not parent node of this text node, but we wish to style this

            // text node. To make this possible, add a style span to surround this text node.

            RefPtr<HTMLElement> span = createStyleSpanElement(document());

            insertNodeBefore(span.get(), node);

            surroundNodeRangeWithElement(node, node, span.get());

            elem = span.get();

        }  else {

            // Only handle HTML elements and text nodes.

            continue;

        }

        lastStyledNode = node;

        CSSMutableStyleDeclaration* inlineStyleDecl = elem->getInlineStyleDecl();

        float currentFontSize = computedFontSize(node);

        float desiredFontSize = max(MinimumFontSize, startingFontSizes.get(node) + adjustment);

        RefPtr<CSSValue> value = inlineStyleDecl->getPropertyCSSValue(CSS_PROP_FONT_SIZE);