/*

 * Copyright (C) 2006, 2008 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 (IndentOutdentCommandINCLUDING, 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 "IndentOutdentCommand.h"

#include "Document.h"

#include "Element.h"

#include "HTMLBlockquoteElement.h"

#include "HTMLNames.h"

#include "InsertLineBreakCommand.h"

#include "InsertListCommand.h"

#include "Range.h"

#include "SplitElementCommand.h"

#include "Text.h"

#include "TextIterator.h"

#include "htmlediting.h"

#include "visible_units.h"

#include <wtf/StdLibExtras.h>

namespace WebCore {

using namespace HTMLNames;

static String indentBlockquoteString()

{

    DEFINE_STATIC_LOCAL(String, string, ("webkit-indent-blockquote"));

    return string;

}

static PassRefPtr<HTMLBlockquoteElement> createIndentBlockquoteElement(Document* document)

{

    RefPtr<HTMLBlockquoteElement> element = HTMLBlockquoteElement::create(document);

    element->setAttribute(classAttr, indentBlockquoteString());

    element->setAttribute(styleAttr, "margin: 0 0 0 40px; border: none; padding: 0px;");

    return element.release();

}

static bool isListOrIndentBlockquote(const Node* node)

{

    return node && (node->hasTagName(ulTag) || node->hasTagName(olTag) || node->hasTagName(blockquoteTag));

}

// This function can return -1 if we are unable to count the paragraphs between |start| and |end|.

static int countParagraphs(const VisiblePosition& endOfFirstParagraph, const VisiblePosition& endOfLastParagraph)

{

    int count = 0;

    VisiblePosition cur = endOfFirstParagraph;

    while (cur != endOfLastParagraph) {

        ++count;

        cur = endOfParagraph(cur.next());

        // If start is before a table and end is inside a table, we will never hit end because the

        // whole table is considered a single paragraph.

        if (cur.isNull())

            return -1;

    }

    return count;

}

IndentOutdentCommand::IndentOutdentCommand(Document* document, EIndentType typeOfAction, int marginInPixels)

    : CompositeEditCommand(document), m_typeOfAction(typeOfAction), m_marginInPixels(marginInPixels)

{

}

bool IndentOutdentCommand::tryIndentingAsListItem(const VisiblePosition& endOfCurrentParagraph)

{

    // If our selection is not inside a list, bail out.

    Node* lastNodeInSelectedParagraph = endOfCurrentParagraph.deepEquivalent().node();

    RefPtr<Element> listNode = enclosingList(lastNodeInSelectedParagraph);

    if (!listNode)

        return false;

    // Find the block that we want to indent.  If it's not a list item (e.g., a div inside a list item), we bail out.

    Element* selectedListItem = static_cast<Element*>(enclosingBlock(lastNodeInSelectedParagraph));

    // FIXME: we need to deal with the case where there is no li (malformed HTML)

    if (!selectedListItem->hasTagName(liTag))

        return false;

    // FIXME: previousElementSibling does not ignore non-rendered content like <span></span>.  Should we?

    Element* previousList = selectedListItem->previousElementSibling();

    Element* nextList = selectedListItem->nextElementSibling();

    RefPtr<Element> newList = document()->createElement(listNode->tagQName(), false);

    insertNodeBefore(newList, selectedListItem);

    moveParagraphWithClones(startOfParagraph(endOfCurrentParagraph), endOfCurrentParagraph, newList.get(), selectedListItem);

    if (canMergeLists(previousList, newList.get()))

        mergeIdenticalElements(previousList, newList);

    if (canMergeLists(newList.get(), nextList))

        mergeIdenticalElements(newList, nextList);

    return true;

}

void IndentOutdentCommand::indentIntoBlockquote(const VisiblePosition& endOfCurrentParagraph, const VisiblePosition& endOfNextParagraph, RefPtr<Element>& targetBlockquote)

{

    Node* enclosingCell = 0;

    Position start = startOfParagraph(endOfCurrentParagraph).deepEquivalent();

    enclosingCell = enclosingNodeOfType(start, &isTableCell);

    Node* nodeToSplitTo;

    if (enclosingCell)

        nodeToSplitTo = enclosingCell;

    else if (enclosingList(start.node()))

        nodeToSplitTo = enclosingBlock(start.node());

    else

        nodeToSplitTo = editableRootForPosition(start);

    RefPtr<Node> outerBlock = (start.node() == nodeToSplitTo) ? start.node() : splitTreeToNode(start.node(), nodeToSplitTo);

    if (!targetBlockquote) {

        // Create a new blockquote and insert it as a child of the root editable element. We accomplish

        // this by splitting all parents of the current paragraph up to that point.

        targetBlockquote = createIndentBlockquoteElement(document());

        insertNodeBefore(targetBlockquote, outerBlock);

    }

    moveParagraphWithClones(startOfParagraph(endOfCurrentParagraph), endOfCurrentParagraph, targetBlockquote.get(), outerBlock.get());

    // Don't put the next paragraph in the blockquote we just created for this paragraph unless 

    // the next paragraph is in the same cell.

    if (enclosingCell && enclosingCell != enclosingNodeOfType(endOfNextParagraph.deepEquivalent(), &isTableCell))

        targetBlockquote = 0;

}

void IndentOutdentCommand::indentRegion(const VisiblePosition& startOfSelection, const VisiblePosition& endOfSelection)

{

    // Special case empty unsplittable elements because there's nothing to split

    // and there's nothing to move.

    Position start = startOfSelection.deepEquivalent().downstream();

    if (isAtUnsplittableElement(start)) {

        RefPtr<Element> blockquote = createIndentBlockquoteElement(document());

        insertNodeAt(blockquote, start);

        RefPtr<Element> placeholder = createBreakElement(document());

        appendNode(placeholder, blockquote);

        setEndingSelection(VisibleSelection(Position(placeholder.get(), 0), DOWNSTREAM));

        return;

    }

    RefPtr<Element> blockquoteForNextIndent;

    VisiblePosition endOfCurrentParagraph = endOfParagraph(startOfSelection);

    VisiblePosition endAfterSelection = endOfParagraph(endOfParagraph(endOfSelection).next());

    int endOfCurrentParagraphIndex = indexForVisiblePosition(endOfCurrentParagraph);

    int endAfterSelectionIndex = indexForVisiblePosition(endAfterSelection);

    // When indenting within a <pre> tag, we need to split each paragraph into a separate node for moveParagraphWithClones to work.

    // However, splitting text nodes can cause endOfCurrentParagraph and endAfterSelection to point to an invalid position if we

    // changed the text node it was pointing at.  So we have to reset these positions.

    int numParagraphs = countParagraphs(endOfCurrentParagraph, endAfterSelection);

    if (splitTextNodes(startOfParagraph(startOfSelection), numParagraphs + 1)) {

        RefPtr<Range> endOfCurrentParagraphRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), endOfCurrentParagraphIndex, 0, true);

        RefPtr<Range> endAfterSelectionRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), endAfterSelectionIndex, 0, true);

        if (!endOfCurrentParagraphRange.get() || !endAfterSelectionRange.get()) {

            ASSERT_NOT_REACHED();

            return;

        }

        endOfCurrentParagraph = VisiblePosition(endOfCurrentParagraphRange->startPosition(), DOWNSTREAM);

        endAfterSelection = VisiblePosition(endAfterSelectionRange->startPosition(), DOWNSTREAM);

    }

    while (endOfCurrentParagraph != endAfterSelection) {

        // Iterate across the selected paragraphs...

        VisiblePosition endOfNextParagraph = endOfParagraph(endOfCurrentParagraph.next());

        if (tryIndentingAsListItem(endOfCurrentParagraph))

            blockquoteForNextIndent = 0;

        else

            indentIntoBlockquote(endOfCurrentParagraph, endOfNextParagraph, blockquoteForNextIndent);

        // indentIntoBlockquote could move more than one paragraph if the paragraph

        // is in a list item or a table. As a result, endAfterSelection could refer to a position

        // no longer in the document.

        if (endAfterSelection.isNotNull() && !endAfterSelection.deepEquivalent().node()->inDocument())

            break;

        // Sanity check: Make sure our moveParagraph calls didn't remove endOfNextParagraph.deepEquivalent().node()

        // If somehow we did, return to prevent crashes.

        if (endOfNextParagraph.isNotNull() && !endOfNextParagraph.deepEquivalent().node()->inDocument()) {

            ASSERT_NOT_REACHED();

            return;

        }

        endOfCurrentParagraph = endOfNextParagraph;

    }   

}

// Returns true if at least one text node was split.

bool IndentOutdentCommand::splitTextNodes(const VisiblePosition& start, int numParagraphs)

{

    VisiblePosition currentParagraphStart = start;

    bool hasSplit = false;

    int paragraphCount;

    for (paragraphCount = 0; paragraphCount < numParagraphs; ++paragraphCount) {

        // If there are multiple paragraphs in a single text node, we split the text node into a separate node for each paragraph.

        if (currentParagraphStart.deepEquivalent().node()->isTextNode() && currentParagraphStart.deepEquivalent().node() == startOfParagraph(currentParagraphStart.previous()).deepEquivalent().node()) {

            Text* textNode = static_cast<Text *>(currentParagraphStart.deepEquivalent().node());

            int offset = currentParagraphStart.deepEquivalent().offsetInContainerNode();

            splitTextNode(textNode, offset);

            currentParagraphStart = VisiblePosition(textNode, 0, VP_DEFAULT_AFFINITY);

            hasSplit = true;

        }

        VisiblePosition nextParagraph = startOfParagraph(endOfParagraph(currentParagraphStart).next());

        if (nextParagraph.isNull())

            break;

        currentParagraphStart = nextParagraph;

    }

    return hasSplit;

}

void IndentOutdentCommand::outdentParagraph()

{

    VisiblePosition visibleStartOfParagraph = startOfParagraph(endingSelection().visibleStart());

    VisiblePosition visibleEndOfParagraph = endOfParagraph(visibleStartOfParagraph);

    Node* enclosingNode = enclosingNodeOfType(visibleStartOfParagraph.deepEquivalent(), &isListOrIndentBlockquote);

    if (!enclosingNode || !enclosingNode->parentNode()->isContentEditable())  // We can't outdent if there is no place to go!

        return;

    // Use InsertListCommand to remove the selection from the list

    if (enclosingNode->hasTagName(olTag)) {

        applyCommandToComposite(InsertListCommand::create(document(), InsertListCommand::OrderedList));

        return;        

    }

    if (enclosingNode->hasTagName(ulTag)) {

        applyCommandToComposite(InsertListCommand::create(document(), InsertListCommand::UnorderedList));

        return;

    }

    // The selection is inside a blockquote i.e. enclosingNode is a blockquote

    VisiblePosition positionInEnclosingBlock = VisiblePosition(Position(enclosingNode, 0));

    VisiblePosition startOfEnclosingBlock = startOfBlock(positionInEnclosingBlock);

    VisiblePosition lastPositionInEnclosingBlock = VisiblePosition(Position(enclosingNode, enclosingNode->childNodeCount()));

    VisiblePosition endOfEnclosingBlock = endOfBlock(lastPositionInEnclosingBlock);

    if (visibleStartOfParagraph == startOfEnclosingBlock &&

        visibleEndOfParagraph == endOfEnclosingBlock) {

        // The blockquote doesn't contain anything outside the paragraph, so it can be totally removed.

        Node* splitPoint = enclosingNode->nextSibling();

        removeNodePreservingChildren(enclosingNode);

        // outdentRegion() assumes it is operating on the first paragraph of an enclosing blockquote, but if there are multiply nested blockquotes and we've

        // just removed one, then this assumption isn't true. By splitting the next containing blockquote after this node, we keep this assumption true

        if (splitPoint) {

            if (Node* splitPointParent = splitPoint->parentNode()) {

                if (splitPointParent->hasTagName(blockquoteTag)

                    && !splitPoint->hasTagName(blockquoteTag)

                    && splitPointParent->parentNode()->isContentEditable()) // We can't outdent if there is no place to go!

                    splitElement(static_cast<Element*>(splitPointParent), splitPoint);

            }

        }

        updateLayout();

        visibleStartOfParagraph = VisiblePosition(visibleStartOfParagraph.deepEquivalent());

        visibleEndOfParagraph = VisiblePosition(visibleEndOfParagraph.deepEquivalent());

        if (visibleStartOfParagraph.isNotNull() && !isStartOfParagraph(visibleStartOfParagraph))

            insertNodeAt(createBreakElement(document()), visibleStartOfParagraph.deepEquivalent());

        if (visibleEndOfParagraph.isNotNull() && !isEndOfParagraph(visibleEndOfParagraph))

            insertNodeAt(createBreakElement(document()), visibleEndOfParagraph.deepEquivalent());

        return;

    }

    Node* enclosingBlockFlow = enclosingBlock(visibleStartOfParagraph.deepEquivalent().node());

    RefPtr<Node> splitBlockquoteNode = enclosingNode;

    if (enclosingBlockFlow != enclosingNode)

        splitBlockquoteNode = splitTreeToNode(enclosingBlockFlow, enclosingNode, true);

    else {

        // We split the blockquote at where we start outdenting.

        splitElement(static_cast<Element*>(enclosingNode), visibleStartOfParagraph.deepEquivalent().node());

    }

    RefPtr<Node> placeholder = createBreakElement(document());

    insertNodeBefore(placeholder, splitBlockquoteNode);

    moveParagraph(startOfParagraph(visibleStartOfParagraph), endOfParagraph(visibleEndOfParagraph), VisiblePosition(Position(placeholder.get(), 0)), true);

}

void IndentOutdentCommand::outdentRegion(const VisiblePosition& startOfSelection, const VisiblePosition& endOfSelection)

{

    VisiblePosition endOfLastParagraph = endOfParagraph(endOfSelection);

    if (endOfParagraph(startOfSelection) == endOfLastParagraph) {

        outdentParagraph();

        return;

    }

    Position originalSelectionEnd = endingSelection().end();

    VisiblePosition endOfCurrentParagraph = endOfParagraph(startOfSelection);

    VisiblePosition endAfterSelection = endOfParagraph(endOfParagraph(endOfSelection).next());

    while (endOfCurrentParagraph != endAfterSelection) {

        VisiblePosition endOfNextParagraph = endOfParagraph(endOfCurrentParagraph.next());

        if (endOfCurrentParagraph == endOfLastParagraph)

            setEndingSelection(VisibleSelection(originalSelectionEnd, DOWNSTREAM));

        else

            setEndingSelection(endOfCurrentParagraph);

        outdentParagraph();

        // outdentParagraph could move more than one paragraph if the paragraph

        // is in a list item. As a result, endAfterSelection and endOfNextParagraph

        // could refer to positions no longer in the document.

        if (endAfterSelection.isNotNull() && !endAfterSelection.deepEquivalent().node()->inDocument())

            break;

        if (endOfNextParagraph.isNotNull() && !endOfNextParagraph.deepEquivalent().node()->inDocument()) {

            endOfCurrentParagraph = endingSelection().end();

            endOfNextParagraph = endOfParagraph(endOfCurrentParagraph.next());

        }

        endOfCurrentParagraph = endOfNextParagraph;

    }

}

void IndentOutdentCommand::doApply()

{

    if (endingSelection().isNone())

        return;

    if (!endingSelection().rootEditableElement())

        return;

    VisiblePosition visibleEnd = endingSelection().visibleEnd();

    VisiblePosition visibleStart = endingSelection().visibleStart();

    // When a selection ends at the start of a paragraph, we rarely paint 

    // the selection gap before that paragraph, because there often is no gap.  

    // In a case like this, it's not obvious to the user that the selection 

    // ends "inside" that paragraph, so it would be confusing if Indent/Outdent 

    // operated on that paragraph.

    // FIXME: We paint the gap before some paragraphs that are indented with left 

    // margin/padding, but not others.  We should make the gap painting more consistent and 

    // then use a left margin/padding rule here.

    if (visibleEnd != visibleStart && isStartOfParagraph(visibleEnd))

        setEndingSelection(VisibleSelection(visibleStart, visibleEnd.previous(true)));

    VisibleSelection selection = selectionForParagraphIteration(endingSelection());

    VisiblePosition startOfSelection = selection.visibleStart();

    VisiblePosition endOfSelection = selection.visibleEnd();

    int startIndex = indexForVisiblePosition(startOfSelection);

    int endIndex = indexForVisiblePosition(endOfSelection);

    ASSERT(!startOfSelection.isNull());

    ASSERT(!endOfSelection.isNull());

    if (m_typeOfAction == Indent)

        indentRegion(startOfSelection, endOfSelection);

    else

        outdentRegion(startOfSelection, endOfSelection);

    updateLayout();

    RefPtr<Range> startRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), startIndex, 0, true);

    RefPtr<Range> endRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), endIndex, 0, true);

    if (startRange && endRange)

        setEndingSelection(VisibleSelection(startRange->startPosition(), endRange->startPosition(), DOWNSTREAM));

}

}