/*

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

 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)

 * Copyright (C) 2009 Igalia S.L.

 *

 * 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 "Editor.h"

#include "AtomicString.h"

#include "CSSComputedStyleDeclaration.h"

#include "CSSMutableStyleDeclaration.h"

#include "CSSPropertyNames.h"

#include "CSSValueKeywords.h"

#include "Chrome.h"

#include "CreateLinkCommand.h"

#include "DocumentFragment.h"

#include "EditorClient.h"

#include "Event.h"

#include "EventHandler.h"

#include "FormatBlockCommand.h"

#include "Frame.h"

#include "FrameView.h"

#include "HTMLFontElement.h"

#include "HTMLHRElement.h"

#include "HTMLImageElement.h"

#include "IndentOutdentCommand.h"

#include "InsertListCommand.h"

#include "KillRing.h"

#include "Page.h"

#include "RenderBox.h"

#include "ReplaceSelectionCommand.h"

#include "Scrollbar.h"

#include "Settings.h"

#include "Sound.h"

#include "TypingCommand.h"

#include "UnlinkCommand.h"

#include "htmlediting.h"

#include "markup.h"

namespace WebCore {

using namespace HTMLNames;

class EditorInternalCommand {

public:

    bool (*execute)(Frame*, Event*, EditorCommandSource, const String&);

    bool (*isSupported)(Frame*, EditorCommandSource);

    bool (*isEnabled)(Frame*, Event*, EditorCommandSource);

    TriState (*state)(Frame*, Event*);

    String (*value)(Frame*, Event*);

    bool isTextInsertion;

    bool allowExecutionWhenDisabled;

};

typedef HashMap<String, const EditorInternalCommand*, CaseFoldingHash> CommandMap;

static const bool notTextInsertion = false;

static const bool isTextInsertion = true;

static const bool allowExecutionWhenDisabled = true;

static const bool doNotAllowExecutionWhenDisabled = false;

// Related to Editor::selectionForCommand.

// Certain operations continue to use the target control's selection even if the event handler

// already moved the selection outside of the text control.

static Frame* targetFrame(Frame* frame, Event* event)

{

    if (!event)

        return frame;

    Node* node = event->target()->toNode();

    if (!node)

        return frame;

    return node->document()->frame();

}

static bool applyCommandToFrame(Frame* frame, EditorCommandSource source, EditAction action, CSSMutableStyleDeclaration* style)

{

    // FIXME: We don't call shouldApplyStyle when the source is DOM; is there a good reason for that?

    switch (source) {

    case CommandFromMenuOrKeyBinding:

        frame->editor()->applyStyleToSelection(style, action);

        return true;

    case CommandFromDOM:

    case CommandFromDOMWithUserInterface:

        frame->editor()->applyStyle(style);

        return true;

    }

    ASSERT_NOT_REACHED();

    return false;

}

static bool executeApplyStyle(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, const String& propertyValue)

{

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

    style->setProperty(propertyID, propertyValue);

    return applyCommandToFrame(frame, source, action, style.get());

}

static bool executeApplyStyle(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, int propertyValue)

{

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

    style->setProperty(propertyID, propertyValue);

    return applyCommandToFrame(frame, source, action, style.get());

}

// FIXME: executeToggleStyleInList does not handle complicated cases such as <b><u>hello</u>world</b> properly.

//        This function must use Editor::selectionHasStyle to determine the current style but we cannot fix this

//        until https://bugs.webkit.org/show_bug.cgi?id=27818 is resolved.

static bool executeToggleStyleInList(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, CSSValue* value)

{

    ExceptionCode ec = 0;

    Node* nodeToRemove = 0;

    RefPtr<CSSComputedStyleDeclaration> selectionStyle = frame->selectionComputedStyle(nodeToRemove);

    RefPtr<CSSValue> selectedCSSValue = selectionStyle->getPropertyCSSValue(propertyID);

    String newStyle = "none";

    if (selectedCSSValue->isValueList()) {

        RefPtr<CSSValueList> selectedCSSValueList = static_cast<CSSValueList*>(selectedCSSValue.get());

        if (!selectedCSSValueList->removeAll(value))

            selectedCSSValueList->append(value);

        if (selectedCSSValueList->length())

            newStyle = selectedCSSValueList->cssText();

    } else if (selectedCSSValue->cssText() == "none")

        newStyle = value->cssText();

    ASSERT(!ec);

    if (nodeToRemove) {

        nodeToRemove->remove(ec);

        ASSERT(!ec);

    }

    // FIXME: We shouldn't be having to convert new style into text.  We should have setPropertyCSSValue.

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

    newMutableStyle->setProperty(propertyID, newStyle, ec);

    return applyCommandToFrame(frame, source, action, newMutableStyle.get());

}

static bool executeToggleStyle(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, const char* offValue, const char* onValue)

{

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

    style->setProperty(propertyID, onValue); // We need to add this style to pass it to selectionStartHasStyle / selectionHasStyle

    // Style is considered present when

    // mac: present at the beginning of selection

    // other: present throughout the selection

    // FIXME: Make stateStyle() to use this editing method too for the cases where it's used for queryCommandState.

    bool styleIsPresent;

    if (frame->editor()->behavior().shouldToggleStyleBasedOnStartOfSelection())

        styleIsPresent = frame->editor()->selectionStartHasStyle(style.get());

    else

        styleIsPresent = frame->editor()->selectionHasStyle(style.get()) == TrueTriState;

    style->setProperty(propertyID, styleIsPresent ? offValue : onValue);

    return applyCommandToFrame(frame, source, action, style.get());

}

static bool executeApplyParagraphStyle(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, const String& propertyValue)

{

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

    style->setProperty(propertyID, propertyValue);

    // FIXME: We don't call shouldApplyStyle when the source is DOM; is there a good reason for that?

    switch (source) {

    case CommandFromMenuOrKeyBinding:

        frame->editor()->applyParagraphStyleToSelection(style.get(), action);

        return true;

    case CommandFromDOM:

    case CommandFromDOMWithUserInterface:

        frame->editor()->applyParagraphStyle(style.get());

        return true;

    }

    ASSERT_NOT_REACHED();

    return false;

}

static bool executeInsertFragment(Frame* frame, PassRefPtr<DocumentFragment> fragment)

{

    applyCommand(ReplaceSelectionCommand::create(frame->document(), fragment,

        false, false, false, true, false, EditActionUnspecified));

    return true;

}

static bool executeInsertNode(Frame* frame, PassRefPtr<Node> content)

{

    RefPtr<DocumentFragment> fragment = DocumentFragment::create(frame->document());

    ExceptionCode ec = 0;

    fragment->appendChild(content, ec);

    if (ec)

        return false;

    return executeInsertFragment(frame, fragment.release());

}

static bool expandSelectionToGranularity(Frame* frame, TextGranularity granularity)

{

    VisibleSelection selection = frame->selection()->selection();

    selection.expandUsingGranularity(granularity);

    RefPtr<Range> newRange = selection.toNormalizedRange();

    if (!newRange)

        return false;

    ExceptionCode ec = 0;

    if (newRange->collapsed(ec))

        return false;

    RefPtr<Range> oldRange = frame->selection()->selection().toNormalizedRange();

    EAffinity affinity = frame->selection()->affinity();

    if (!frame->editor()->client()->shouldChangeSelectedRange(oldRange.get(), newRange.get(), affinity, false))

        return false;

    frame->selection()->setSelectedRange(newRange.get(), affinity, true);

    return true;

}

static TriState stateStyle(Frame* frame, int propertyID, const char* desiredValue)

{

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

    style->setProperty(propertyID, desiredValue);

    return frame->editor()->selectionHasStyle(style.get());

}

static String valueStyle(Frame* frame, int propertyID)

{

    return frame->selectionStartStylePropertyValue(propertyID);

}

static TriState stateTextWritingDirection(Frame* frame, WritingDirection direction)

{

    bool hasNestedOrMultipleEmbeddings;

    WritingDirection selectionDirection = frame->editor()->textDirectionForSelection(hasNestedOrMultipleEmbeddings);

    return (selectionDirection == direction && !hasNestedOrMultipleEmbeddings) ? TrueTriState : FalseTriState;

}

static int verticalScrollDistance(Frame* frame)

{

    Node* focusedNode = frame->document()->focusedNode();

    if (!focusedNode)

        return 0;

    RenderObject* renderer = focusedNode->renderer();

    if (!renderer || !renderer->isBox())

        return 0;

    RenderStyle* style = renderer->style();

    if (!style)

        return 0;

    if (!(style->overflowY() == OSCROLL || style->overflowY() == OAUTO || focusedNode->isContentEditable()))

        return 0;

    int height = std::min<int>(toRenderBox(renderer)->clientHeight(),

                               frame->view()->visibleHeight());

    return max(max<int>(height * Scrollbar::minFractionToStepWhenPaging(), height - Scrollbar::maxOverlapBetweenPages()), 1);

}

static RefPtr<Range> unionDOMRanges(Range* a, Range* b)

{

    ExceptionCode ec = 0;

    Range* start = a->compareBoundaryPoints(Range::START_TO_START, b, ec) <= 0 ? a : b;

    ASSERT(!ec);

    Range* end = a->compareBoundaryPoints(Range::END_TO_END, b, ec) <= 0 ? b : a;

    ASSERT(!ec);

    return Range::create(a->startContainer(ec)->ownerDocument(), start->startContainer(ec), start->startOffset(ec), end->endContainer(ec), end->endOffset(ec));

}

// Execute command functions

static bool executeBackColor(Frame* frame, Event*, EditorCommandSource source, const String& value)

{

    return executeApplyStyle(frame, source, EditActionSetBackgroundColor, CSSPropertyBackgroundColor, value);

}

static bool executeCopy(Frame* frame, Event*, EditorCommandSource, const String&)

{

    frame->editor()->copy();

    return true;

}

static bool executeCreateLink(Frame* frame, Event*, EditorCommandSource, const String& value)

{

    // FIXME: If userInterface is true, we should display a dialog box to let the user enter a URL.

    if (value.isEmpty())

        return false;

    applyCommand(CreateLinkCommand::create(frame->document(), value));

    return true;

}

static bool executeCut(Frame* frame, Event*, EditorCommandSource, const String&)

{

    frame->editor()->cut();

    return true;

}

static bool executeDelete(Frame* frame, Event*, EditorCommandSource source, const String&)

{

    switch (source) {

    case CommandFromMenuOrKeyBinding:

        // Doesn't modify the text if the current selection isn't a range.

        frame->editor()->performDelete();

        return true;

    case CommandFromDOM:

    case CommandFromDOMWithUserInterface:

        // If the current selection is a caret, delete the preceding character. IE performs forwardDelete, but we currently side with Firefox.

        // Doesn't scroll to make the selection visible, or modify the kill ring (this time, siding with IE, not Firefox).

        TypingCommand::deleteKeyPressed(frame->document(), frame->selectionGranularity() == WordGranularity);

        return true;

    }

    ASSERT_NOT_REACHED();

    return false;

}

static bool executeDeleteBackward(Frame* frame, Event*, EditorCommandSource, const String&)

{

    frame->editor()->deleteWithDirection(SelectionController::DirectionBackward, CharacterGranularity, false, true);

    return true;

}

static bool executeDeleteBackwardByDecomposingPreviousCharacter(Frame* frame, Event*, EditorCommandSource, const String&)

{

    LOG_ERROR("DeleteBackwardByDecomposingPreviousCharacter is not implemented, doing DeleteBackward instead");

    frame->editor()->deleteWithDirection(SelectionController::DirectionBackward, CharacterGranularity, false, true);

    return true;

}

static bool executeDeleteForward(Frame* frame, Event*, EditorCommandSource, const String&)

{

    frame->editor()->deleteWithDirection(SelectionController::DirectionForward, CharacterGranularity, false, true);

    return true;

}

static bool executeDeleteToBeginningOfLine(Frame* frame, Event*, EditorCommandSource, const String&)

{

    frame->editor()->deleteWithDirection(SelectionController::DirectionBackward, LineBoundary, true, false);

    return true;

}

static bool executeDeleteToBeginningOfParagraph(Frame* frame, Event*, EditorCommandSource, const String&)

{

    frame->editor()->deleteWithDirection(SelectionController::DirectionBackward, ParagraphBoundary, true, false);

    return true;

}

static bool executeDeleteToEndOfLine(Frame* frame, Event*, EditorCommandSource, const String&)

{

    // Despite its name, this command should delete the newline at the end of

    // a paragraph if you are at the end of a paragraph (like DeleteToEndOfParagraph).

    frame->editor()->deleteWithDirection(SelectionController::DirectionForward, LineBoundary, true, false);

    return true;

}

static bool executeDeleteToEndOfParagraph(Frame* frame, Event*, EditorCommandSource, const String&)

{

    // Despite its name, this command should delete the newline at the end of

    // a paragraph if you are at the end of a paragraph.

    frame->editor()->deleteWithDirection(SelectionController::DirectionForward, ParagraphBoundary, true, false);

    return true;

}

static bool executeDeleteToMark(Frame* frame, Event*, EditorCommandSource, const String&)

{

    RefPtr<Range> mark = frame->mark().toNormalizedRange();

    if (mark) {

        SelectionController* selection = frame->selection();

        bool selected = selection->setSelectedRange(unionDOMRanges(mark.get(), frame->editor()->selectedRange().get()).get(), DOWNSTREAM, true);

        ASSERT(selected);

        if (!selected)

            return false;

    }

    frame->editor()->performDelete();

    frame->setMark(frame->selection()->selection());

    return true;

}

static bool executeDeleteWordBackward(Frame* frame, Event*, EditorCommandSource, const String&)

{

    frame->editor()->deleteWithDirection(SelectionController::DirectionBackward, WordGranularity, true, false);

    return true;

}

static bool executeDeleteWordForward(Frame* frame, Event*, EditorCommandSource, const String&)

{

    frame->editor()->deleteWithDirection(SelectionController::DirectionForward, WordGranularity, true, false);

    return true;

}

static bool executeFindString(Frame* frame, Event*, EditorCommandSource, const String& value)

{

    return frame->findString(value, true, false, true, false);

}

static bool executeFontName(Frame* frame, Event*, EditorCommandSource source, const String& value)

{

    return executeApplyStyle(frame, source, EditActionSetFont, CSSPropertyFontFamily, value);

}

static bool executeFontSize(Frame* frame, Event*, EditorCommandSource source, const String& value)

{

    int size;

    if (!HTMLFontElement::cssValueFromFontSizeNumber(value, size))

        return false;

    return executeApplyStyle(frame, source, EditActionChangeAttributes, CSSPropertyFontSize, size);

}

static bool executeFontSizeDelta(Frame* frame, Event*, EditorCommandSource source, const String& value)

{

    return executeApplyStyle(frame, source, EditActionChangeAttributes, CSSPropertyWebkitFontSizeDelta, value);

}

static bool executeForeColor(Frame* frame, Event*, EditorCommandSource source, const String& value)

{

    return executeApplyStyle(frame, source, EditActionSetColor, CSSPropertyColor, value);

}

static bool executeFormatBlock(Frame* frame, Event*, EditorCommandSource, const String& value)

{

    String tagName = value.lower();

    if (tagName[0] == '<' && tagName[tagName.length() - 1] == '>')

        tagName = tagName.substring(1, tagName.length() - 2);

    if (!validBlockTag(tagName))

        return false;

    applyCommand(FormatBlockCommand::create(frame->document(), tagName));

    return true;

}

static bool executeForwardDelete(Frame* frame, Event*, EditorCommandSource source, const String&)

{

    switch (source) {

    case CommandFromMenuOrKeyBinding:

        frame->editor()->deleteWithDirection(SelectionController::DirectionForward, CharacterGranularity, false, true);

        return true;

    case CommandFromDOM:

    case CommandFromDOMWithUserInterface:

        // Doesn't scroll to make the selection visible, or modify the kill ring.

        // ForwardDelete is not implemented in IE or Firefox, so this behavior is only needed for

        // backward compatibility with ourselves, and for consistency with Delete.

        TypingCommand::forwardDeleteKeyPressed(frame->document());

        return true;

    }

    ASSERT_NOT_REACHED();

    return false;

}

static bool executeIgnoreSpelling(Frame* frame, Event*, EditorCommandSource, const String&)

{

    frame->editor()->ignoreSpelling();

    return true;

}

static bool executeIndent(Frame* frame, Event*, EditorCommandSource, const String&)

{

    applyCommand(IndentOutdentCommand::create(frame->document(), IndentOutdentCommand::Indent));

    return true;

}

static bool executeInsertBacktab(Frame* frame, Event* event, EditorCommandSource, const String&)

{

    return targetFrame(frame, event)->eventHandler()->handleTextInputEvent("\t", event, false, true);

}

static bool executeInsertHorizontalRule(Frame* frame, Event*, EditorCommandSource, const String& value)

{

    RefPtr<HTMLHRElement> rule = HTMLHRElement::create(frame->document());

    if (!value.isEmpty())

        rule->setIdAttribute(value);

    return executeInsertNode(frame, rule.release());

}

static bool executeInsertHTML(Frame* frame, Event*, EditorCommandSource, const String& value)

{

    return executeInsertFragment(frame, createFragmentFromMarkup(frame->document(), value, ""));

}

static bool executeInsertImage(Frame* frame, Event*, EditorCommandSource, const String& value)

{

    // FIXME: If userInterface is true, we should display a dialog box and let the user choose a local image.

    RefPtr<HTMLImageElement> image = HTMLImageElement::create(frame->document());

    image->setSrc(value);

    return executeInsertNode(frame, image.release());

}

static bool executeInsertLineBreak(Frame* frame, Event* event, EditorCommandSource source, const String&)

{

    switch (source) {

    case CommandFromMenuOrKeyBinding:

        return targetFrame(frame, event)->eventHandler()->handleTextInputEvent("\n", event, true);

    case CommandFromDOM:

    case CommandFromDOMWithUserInterface:

        // Doesn't scroll to make the selection visible, or modify the kill ring.

        // InsertLineBreak is not implemented in IE or Firefox, so this behavior is only needed for

        // backward compatibility with ourselves, and for consistency with other commands.

        TypingCommand::insertLineBreak(frame->document());

        return true;

    }

    ASSERT_NOT_REACHED();

    return false;

}

static bool executeInsertNewline(Frame* frame, Event* event, EditorCommandSource, const String&)

{

    Frame* targetFrame = WebCore::targetFrame(frame, event);

    return targetFrame->eventHandler()->handleTextInputEvent("\n", event, !targetFrame->editor()->canEditRichly());

}

static bool executeInsertNewlineInQuotedContent(Frame* frame, Event*, EditorCommandSource, const String&)

{

    TypingCommand::insertParagraphSeparatorInQuotedContent(frame->document());

    return true;

}

static bool executeInsertOrderedList(Frame* frame, Event*, EditorCommandSource, const String&)

{

    applyCommand(InsertListCommand::create(frame->document(), InsertListCommand::OrderedList));

    return true;