/*

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

#include "CSSComputedStyleDeclaration.h"

#include "CSSMutableStyleDeclaration.h"

#include "CSSParser.h"

#include "CSSProperty.h"

#include "CSSPropertyNames.h"

#include "CSSValueKeywords.h"

#include "Document.h"

#include "Editor.h"

#include "Frame.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"

#include <wtf/StdLibExtras.h>

namespace WebCore {

using namespace HTMLNames;

class StyleChange {

public:

    explicit StyleChange(CSSStyleDeclaration*, const Position&);

    String cssStyle() const { return m_cssStyle; }

    bool applyBold() const { return m_applyBold; }

    bool applyItalic() const { return m_applyItalic; }

    bool applyUnderline() const { return m_applyUnderline; }

    bool applyLineThrough() const { return m_applyLineThrough; }

    bool applySubscript() const { return m_applySubscript; }

    bool applySuperscript() const { return m_applySuperscript; }

    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; }

private:

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

    void reconcileTextDecorationProperties(CSSMutableStyleDeclaration*);

    void extractTextStyles(CSSMutableStyleDeclaration*);

    String m_cssStyle;

    bool m_applyBold;

    bool m_applyItalic;

    bool m_applyUnderline;

    bool m_applyLineThrough;

    bool m_applySubscript;

    bool m_applySuperscript;

    String m_applyFontColor;

    String m_applyFontFace;

    String m_applyFontSize;

};

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

    : m_applyBold(false)

    , m_applyItalic(false)

    , m_applyUnderline(false)

    , m_applyLineThrough(false)

    , m_applySubscript(false)

    , m_applySuperscript(false)

{

    init(style, position);

}

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

{

    Document* document = position.node() ? position.node()->document() : 0;

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

        return;

    RefPtr<CSSComputedStyleDeclaration> computedStyle = position.computedStyle();

    RefPtr<CSSMutableStyleDeclaration> mutableStyle = getPropertiesNotInComputedStyle(style.get(), computedStyle.get());

    reconcileTextDecorationProperties(mutableStyle.get());

    if (!document->frame()->editor()->shouldStyleWithCSS())

        extractTextStyles(mutableStyle.get());

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

    if (isTabSpanTextNode(position.node()) || isTabSpanNode((position.node())))

        mutableStyle->removeProperty(CSSPropertyWhiteSpace);

    // If unicode-bidi is present in mutableStyle and direction is not, then add direction to mutableStyle.

    // FIXME: Shouldn't this be done in getPropertiesNotInComputedStyle?

    if (mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi) && !style->getPropertyCSSValue(CSSPropertyDirection))

        mutableStyle->setProperty(CSSPropertyDirection, style->getPropertyValue(CSSPropertyDirection));

    // Save the result for later

    m_cssStyle = mutableStyle->cssText().stripWhiteSpace();

}

void StyleChange::reconcileTextDecorationProperties(CSSMutableStyleDeclaration* style)

{    

    RefPtr<CSSValue> textDecorationsInEffect = style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);

    RefPtr<CSSValue> textDecoration = style->getPropertyCSSValue(CSSPropertyTextDecoration);

    // We shouldn't have both text-decoration and -webkit-text-decorations-in-effect because that wouldn't make sense.

    ASSERT(!textDecorationsInEffect || !textDecoration);

    if (textDecorationsInEffect) {

        style->setProperty(CSSPropertyTextDecoration, textDecorationsInEffect->cssText());

        style->removeProperty(CSSPropertyWebkitTextDecorationsInEffect);

        textDecoration = textDecorationsInEffect;

    }

    // If text-decoration is set to "none", remove the property because we don't want to add redundant "text-decoration: none".

    if (textDecoration && !textDecoration->isValueList())

        style->removeProperty(CSSPropertyTextDecoration);

}

static int getIdentifierValue(CSSMutableStyleDeclaration* style, int propertyID)

{

    if (!style)

        return 0;

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

    if (!value || !value->isPrimitiveValue())

        return 0;

    return static_cast<CSSPrimitiveValue*>(value.get())->getIdent();

}

static void setTextDecorationProperty(CSSMutableStyleDeclaration* style, const CSSValueList* newTextDecoration, int propertyID)

{

    if (newTextDecoration->length())

        style->setProperty(propertyID, newTextDecoration->cssText(), style->getPropertyPriority(propertyID));

    else {

        // text-decoration: none is redundant since it does not remove any text decorations.

        ASSERT(!style->getPropertyPriority(propertyID));

        style->removeProperty(propertyID);

    }

}

void StyleChange::extractTextStyles(CSSMutableStyleDeclaration* style)

{

    ASSERT(style);

    if (getIdentifierValue(style, CSSPropertyFontWeight) == CSSValueBold) {

        style->removeProperty(CSSPropertyFontWeight);

        m_applyBold = true;

    }

    int fontStyle = getIdentifierValue(style, CSSPropertyFontStyle);

    if (fontStyle == CSSValueItalic || fontStyle == CSSValueOblique) {

        style->removeProperty(CSSPropertyFontStyle);

        m_applyItalic = true;

    }

    // Assuming reconcileTextDecorationProperties has been called, there should not be -webkit-text-decorations-in-effect

    // Furthermore, text-decoration: none has been trimmed so that text-decoration property is always a CSSValueList.

    if (RefPtr<CSSValue> textDecoration = style->getPropertyCSSValue(CSSPropertyTextDecoration)) {

        ASSERT(textDecoration->isValueList());

        DEFINE_STATIC_LOCAL(RefPtr<CSSPrimitiveValue>, underline, (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));

        DEFINE_STATIC_LOCAL(RefPtr<CSSPrimitiveValue>, lineThrough, (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));

        RefPtr<CSSValueList> newTextDecoration = static_cast<CSSValueList*>(textDecoration.get())->copy();

        if (newTextDecoration->removeAll(underline.get()))

            m_applyUnderline = true;

        if (newTextDecoration->removeAll(lineThrough.get()))

            m_applyLineThrough = true;

        // If trimTextDecorations, delete underline and line-through

        setTextDecorationProperty(style, newTextDecoration.get(), CSSPropertyTextDecoration);

    }

    int verticalAlign = getIdentifierValue(style, CSSPropertyVerticalAlign);

    switch (verticalAlign) {

    case CSSValueSub:

        style->removeProperty(CSSPropertyVerticalAlign);

        m_applySubscript = true;

        break;

    case CSSValueSuper:

        style->removeProperty(CSSPropertyVerticalAlign);

        m_applySuperscript = true;

        break;

    }

    if (RefPtr<CSSValue> colorValue = style->getPropertyCSSValue(CSSPropertyColor)) {

        ASSERT(colorValue->isPrimitiveValue());

        CSSPrimitiveValue* primitiveColor = static_cast<CSSPrimitiveValue*>(colorValue.get());

        RGBA32 rgba = 0;

        if (primitiveColor->primitiveType() != CSSPrimitiveValue::CSS_RGBCOLOR) {

            CSSParser::parseColor(rgba, colorValue->cssText());

            // Need to take care of named color such as green and black

            // This code should be removed after https://bugs.webkit.org/show_bug.cgi?id=28282 is fixed.

        } else

            rgba = primitiveColor->getRGBA32Value();

        m_applyFontColor = Color(rgba).name();

        style->removeProperty(CSSPropertyColor);

    }

    m_applyFontFace = style->getPropertyValue(CSSPropertyFontFamily);

    style->removeProperty(CSSPropertyFontFamily);

    if (RefPtr<CSSValue> fontSize = style->getPropertyCSSValue(CSSPropertyFontSize)) {

        if (!fontSize->isPrimitiveValue())

            style->removeProperty(CSSPropertyFontSize); // Can't make sense of the number. Put no font size.

        else {

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

            // Only accept absolute scale

            if (value->primitiveType() >= CSSPrimitiveValue::CSS_PX && value->primitiveType() <= CSSPrimitiveValue::CSS_PC) {

                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 Microsoft 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.

        }

    }

}

static String& styleSpanClassString()

{

    DEFINE_STATIC_LOCAL(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->isEmpty()) && elem->getAttribute(classAttr) == styleSpanClassString();

}

static bool isSpanWithoutAttributesOrUnstyleStyleSpan(const Node* node)

{

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

        return false;

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

    NamedNodeMap* attributes = elem->attributes(true); // readonly

    if (attributes->isEmpty())

        return true;

    return isUnstyledStyleSpan(node);

}

static bool isEmptyFontTag(const Node *node)

{

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

        return false;

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

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

    if (!map)

        return true;

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

}

static PassRefPtr<Element> createFontElement(Document* document)

{

    RefPtr<Element> fontNode = createHTMLElement(document, fontTag);

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

    return fontNode.release();

}

PassRefPtr<HTMLElement> createStyleSpanElement(Document* document)

{

    RefPtr<HTMLElement> styleElement = createHTMLElement(document, spanTag);

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

    return styleElement.release();

}

static void diffTextDecorations(CSSMutableStyleDeclaration* style, int propertID, CSSValue* refTextDecoration)

{

    RefPtr<CSSValue> textDecoration = style->getPropertyCSSValue(propertID);

    if (!textDecoration || !textDecoration->isValueList() || !refTextDecoration || !refTextDecoration->isValueList())

        return;

    RefPtr<CSSValueList> newTextDecoration = static_cast<CSSValueList*>(textDecoration.get())->copy();

    CSSValueList* valuesInRefTextDecoration = static_cast<CSSValueList*>(refTextDecoration);

    for (size_t i = 0; i < valuesInRefTextDecoration->length(); i++)

        newTextDecoration->removeAll(valuesInRefTextDecoration->item(i));

    setTextDecorationProperty(style, newTextDecoration.get(), propertID);

}

static bool fontWeightIsBold(CSSStyleDeclaration* style)

{

    ASSERT(style);

    RefPtr<CSSValue> fontWeight = style->getPropertyCSSValue(CSSPropertyFontWeight);

    if (!fontWeight)

        return false;

    if (!fontWeight->isPrimitiveValue())

        return false;

    // Because b tag can only bold text, there are only two states in plain html: bold and not bold.

    // Collapse all other values to either one of these two states for editing purposes.

    switch (static_cast<CSSPrimitiveValue*>(fontWeight.get())->getIdent()) {

        case CSSValue100:

        case CSSValue200:

        case CSSValue300:

        case CSSValue400:

        case CSSValue500:

        case CSSValueNormal:

            return false;

        case CSSValueBold:

        case CSSValue600:

        case CSSValue700:

        case CSSValue800:

        case CSSValue900:

            return true;

    }

    ASSERT_NOT_REACHED(); // For CSSValueBolder and CSSValueLighter

    return false; // Make compiler happy

}

RefPtr<CSSMutableStyleDeclaration> getPropertiesNotInComputedStyle(CSSStyleDeclaration* style, CSSComputedStyleDeclaration* computedStyle)

{

    ASSERT(style);

    ASSERT(computedStyle);

    RefPtr<CSSMutableStyleDeclaration> result = style->copy();

    computedStyle->diff(result.get());

    RefPtr<CSSValue> computedTextDecorationsInEffect = computedStyle->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);

    diffTextDecorations(result.get(), CSSPropertyTextDecoration, computedTextDecorationsInEffect.get());

    diffTextDecorations(result.get(), CSSPropertyWebkitTextDecorationsInEffect, computedTextDecorationsInEffect.get());

    if (fontWeightIsBold(result.get()) == fontWeightIsBold(computedStyle))

        result->removeProperty(CSSPropertyFontWeight);

    return result;

}

// Editing style properties must be preserved during editing operation.

// e.g. when a user inserts a new paragraph, all properties listed here must be copied to the new paragraph.

// FIXME: The current editingStyleProperties contains all inheritableProperties but we may not need to preserve all inheritable properties

static const int editingStyleProperties[] = {

    // CSS inheritable properties

    CSSPropertyBorderCollapse,

    CSSPropertyColor,

    CSSPropertyFontFamily,

    CSSPropertyFontSize,

    CSSPropertyFontStyle,

    CSSPropertyFontVariant,

    CSSPropertyFontWeight,

    CSSPropertyLetterSpacing,

    CSSPropertyLineHeight,

    CSSPropertyOrphans,

    CSSPropertyTextAlign,

    CSSPropertyTextIndent,

    CSSPropertyTextTransform,

    CSSPropertyWhiteSpace,

    CSSPropertyWidows,

    CSSPropertyWordSpacing,

    CSSPropertyWebkitBorderHorizontalSpacing,

    CSSPropertyWebkitBorderVerticalSpacing,

    CSSPropertyWebkitTextDecorationsInEffect,

    CSSPropertyWebkitTextFillColor,

    CSSPropertyWebkitTextSizeAdjust,

    CSSPropertyWebkitTextStrokeColor,

    CSSPropertyWebkitTextStrokeWidth,

};

size_t numEditingStyleProperties = sizeof(editingStyleProperties)/sizeof(editingStyleProperties[0]);

PassRefPtr<CSSMutableStyleDeclaration> ApplyStyleCommand::editingStyleAtPosition(Position pos, ShouldIncludeTypingStyle shouldIncludeTypingStyle)

{

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

    RefPtr<CSSMutableStyleDeclaration> style;

    if (!computedStyleAtPosition)

        style = CSSMutableStyleDeclaration::create();

    else

        style = computedStyleAtPosition->copyPropertiesInSet(editingStyleProperties, numEditingStyleProperties);

    if (style && pos.node() && pos.node()->computedStyle()) {

        RenderStyle* renderStyle = pos.node()->computedStyle();

        // If a node's text fill color is invalid, then its children use 

        // their font-color as their text fill color (they don't

        // inherit it).  Likewise for stroke color.

        ExceptionCode ec = 0;

        if (!renderStyle->textFillColor().isValid())

            style->removeProperty(CSSPropertyWebkitTextFillColor, ec);

        if (!renderStyle->textStrokeColor().isValid())

            style->removeProperty(CSSPropertyWebkitTextStrokeColor, ec);

        ASSERT(ec == 0);

        if (renderStyle->fontDescription().keywordSize())

            style->setProperty(CSSPropertyFontSize, computedStyleAtPosition->getFontSizeCSSValuePreferringKeyword()->cssText());

    }

    if (shouldIncludeTypingStyle == IncludeTypingStyle) {

        CSSMutableStyleDeclaration* typingStyle = pos.node()->document()->frame()->typingStyle();

        if (typingStyle)

            style->merge(typingStyle);

    }

    return style.release();

}

void prepareEditingStyleToApplyAt(CSSMutableStyleDeclaration* editingStyle, Position pos)

{

    // ReplaceSelectionCommand::handleStyleSpans() requires that this function only removes the editing style.

    // If this function was modified in the future to delete all redundant properties, then add a boolean value to indicate

    // which one of editingStyleAtPosition or computedStyle is called.

    RefPtr<CSSMutableStyleDeclaration> style = ApplyStyleCommand::editingStyleAtPosition(pos);

    style->diff(editingStyle);

    // if alpha value is zero, we don't add the background color.

    RefPtr<CSSValue> backgroundColor = editingStyle->getPropertyCSSValue(CSSPropertyBackgroundColor);

    if (backgroundColor && backgroundColor->isPrimitiveValue()) {

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

        Color color = Color(primitiveValue->getRGBA32Value());

        ExceptionCode ec;

        if (color.alpha() == 0)

            editingStyle->removeProperty(CSSPropertyBackgroundColor, ec);

    }

}

void removeStylesAddedByNode(CSSMutableStyleDeclaration* editingStyle, Node* node)

{

    ASSERT(node);

    ASSERT(node->parentNode());

    RefPtr<CSSMutableStyleDeclaration> parentStyle = ApplyStyleCommand::editingStyleAtPosition(Position(node->parentNode(), 0));

    RefPtr<CSSMutableStyleDeclaration> style = ApplyStyleCommand::editingStyleAtPosition(Position(node, 0));

    parentStyle->diff(style.get());

    style->diff(editingStyle);

}

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(PassRefPtr<Element> element, bool removeOnly, EditAction editingAction)

    : CompositeEditCommand(element->document())

    , m_style(CSSMutableStyleDeclaration::create())

    , 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(comparePositions(newEnd, newStart) >= 0);

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

        m_useEndingSelection = true;

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

    m_start = newStart;