/*

 * Copyright (C) 2007, 2009, 2010 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 "DragController.h"

#if ENABLE(DRAG_SUPPORT)

#include "CSSStyleDeclaration.h"

#include "Clipboard.h"

#include "ClipboardAccessPolicy.h"

#include "DocLoader.h"

#include "Document.h"

#include "DocumentFragment.h"

#include "DragActions.h"

#include "DragClient.h"

#include "DragData.h"

#include "Editor.h"

#include "EditorClient.h"

#include "Element.h"

#include "EventHandler.h"

#include "FloatRect.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameView.h"

#include "HTMLAnchorElement.h"

#include "HTMLInputElement.h"

#include "HTMLNames.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "Image.h"

#include "MoveSelectionCommand.h"

#include "Node.h"

#include "Page.h"

#include "PlatformKeyboardEvent.h"

#include "RenderFileUploadControl.h"

#include "RenderImage.h"

#include "RenderLayer.h"

#include "RenderView.h"

#include "ReplaceSelectionCommand.h"

#include "ResourceRequest.h"

#include "SelectionController.h"

#include "Settings.h"

#include "Text.h"

#include "htmlediting.h"

#include "markup.h"

#include <wtf/CurrentTime.h>

#include <wtf/RefPtr.h>

namespace WebCore {

static PlatformMouseEvent createMouseEvent(DragData* dragData)

{

    bool shiftKey, ctrlKey, altKey, metaKey;

    shiftKey = ctrlKey = altKey = metaKey = false;

    PlatformKeyboardEvent::getCurrentModifierState(shiftKey, ctrlKey, altKey, metaKey);

    return PlatformMouseEvent(dragData->clientPosition(), dragData->globalPosition(),

                              LeftButton, MouseEventMoved, 0, shiftKey, ctrlKey, altKey,

                              metaKey, currentTime());

}

DragController::DragController(Page* page, DragClient* client)

    : m_page(page)

    , m_client(client)

    , m_documentUnderMouse(0)

    , m_dragInitiator(0)

    , m_dragDestinationAction(DragDestinationActionNone)

    , m_dragSourceAction(DragSourceActionNone)

    , m_didInitiateDrag(false)

    , m_isHandlingDrag(false)

    , m_sourceDragOperation(DragOperationNone)

{

}

DragController::~DragController()

{

    m_client->dragControllerDestroyed();

}

static PassRefPtr<DocumentFragment> documentFragmentFromDragData(DragData* dragData, RefPtr<Range> context,

                                          bool allowPlainText, bool& chosePlainText)

{

    ASSERT(dragData);

    chosePlainText = false;

    Document* document = context->ownerDocument();

    ASSERT(document);

    if (document && dragData->containsCompatibleContent()) {

        if (PassRefPtr<DocumentFragment> fragment = dragData->asFragment(document))

            return fragment;

        if (dragData->containsURL(DragData::DoNotConvertFilenames)) {

            String title;

            String url = dragData->asURL(DragData::DoNotConvertFilenames, &title);

            if (!url.isEmpty()) {

                RefPtr<HTMLAnchorElement> anchor = HTMLAnchorElement::create(document);

                anchor->setHref(url);

                if (title.isEmpty()) {

                    // Try the plain text first because the url might be normalized or escaped.

                    if (dragData->containsPlainText())

                        title = dragData->asPlainText();

                    if (title.isEmpty())

                        title = url;

                }

                RefPtr<Node> anchorText = document->createTextNode(title);

                ExceptionCode ec;

                anchor->appendChild(anchorText, ec);

                RefPtr<DocumentFragment> fragment = document->createDocumentFragment();

                fragment->appendChild(anchor, ec);

                return fragment.get();

            }

        }

    }

    if (allowPlainText && dragData->containsPlainText()) {

        chosePlainText = true;

        return createFragmentFromText(context.get(), dragData->asPlainText()).get();

    }

    return 0;

}

bool DragController::dragIsMove(SelectionController* selection)

{

    return m_documentUnderMouse == m_dragInitiator && selection->isContentEditable() && !isCopyKeyDown();

}

// FIXME: This method is poorly named.  We're just clearing the selection from the document this drag is exiting.

void DragController::cancelDrag()

{

    m_page->dragCaretController()->clear();

}

void DragController::dragEnded()

{

    m_dragInitiator = 0;

    m_didInitiateDrag = false;

    m_page->dragCaretController()->clear();

}

DragOperation DragController::dragEntered(DragData* dragData)

{

    return dragEnteredOrUpdated(dragData);

}

void DragController::dragExited(DragData* dragData)

{

    ASSERT(dragData);

    Frame* mainFrame = m_page->mainFrame();

    if (RefPtr<FrameView> v = mainFrame->view()) {

        ClipboardAccessPolicy policy = (!m_documentUnderMouse || m_documentUnderMouse->securityOrigin()->isLocal()) ? ClipboardReadable : ClipboardTypesReadable;

        RefPtr<Clipboard> clipboard = dragData->createClipboard(policy);

        clipboard->setSourceOperation(dragData->draggingSourceOperationMask());

        mainFrame->eventHandler()->cancelDragAndDrop(createMouseEvent(dragData), clipboard.get());

        clipboard->setAccessPolicy(ClipboardNumb);    // invalidate clipboard here for security

    }

    mouseMovedIntoDocument(0);

}

DragOperation DragController::dragUpdated(DragData* dragData)

{

    return dragEnteredOrUpdated(dragData);

}

bool DragController::performDrag(DragData* dragData)

{

    ASSERT(dragData);

    m_documentUnderMouse = m_page->mainFrame()->documentAtPoint(dragData->clientPosition());

    if (m_isHandlingDrag) {

        ASSERT(m_dragDestinationAction & DragDestinationActionDHTML);

        m_client->willPerformDragDestinationAction(DragDestinationActionDHTML, dragData);

        RefPtr<Frame> mainFrame = m_page->mainFrame();

        if (mainFrame->view()) {

            // Sending an event can result in the destruction of the view and part.

            RefPtr<Clipboard> clipboard = dragData->createClipboard(ClipboardReadable);

            clipboard->setSourceOperation(dragData->draggingSourceOperationMask());

            mainFrame->eventHandler()->performDragAndDrop(createMouseEvent(dragData), clipboard.get());

            clipboard->setAccessPolicy(ClipboardNumb);    // invalidate clipboard here for security

        }

        m_documentUnderMouse = 0;

        return true;

    }

    if ((m_dragDestinationAction & DragDestinationActionEdit) && concludeEditDrag(dragData)) {

        m_documentUnderMouse = 0;

        return true;

    }

    m_documentUnderMouse = 0;

    if (operationForLoad(dragData) == DragOperationNone)

        return false;

    m_client->willPerformDragDestinationAction(DragDestinationActionLoad, dragData);

    m_page->mainFrame()->loader()->load(ResourceRequest(dragData->asURL()), false);

    return true;

}

void DragController::mouseMovedIntoDocument(Document* newDocument)

{

    if (m_documentUnderMouse == newDocument)

        return;

    // If we were over another document clear the selection

    if (m_documentUnderMouse)

        cancelDrag();

    m_documentUnderMouse = newDocument;

}

DragOperation DragController::dragEnteredOrUpdated(DragData* dragData)

{

    ASSERT(dragData);

    ASSERT(m_page->mainFrame()); // It is not possible in Mac WebKit to have a Page without a mainFrame()

    mouseMovedIntoDocument(m_page->mainFrame()->documentAtPoint(dragData->clientPosition()));

    m_dragDestinationAction = m_client->actionMaskForDrag(dragData);

    if (m_dragDestinationAction == DragDestinationActionNone) {

        cancelDrag(); // FIXME: Why not call mouseMovedIntoDocument(0)?

        return DragOperationNone;

    }

    DragOperation operation = DragOperationNone;

    bool handledByDocument = tryDocumentDrag(dragData, m_dragDestinationAction, operation);

    if (!handledByDocument && (m_dragDestinationAction & DragDestinationActionLoad))

        return operationForLoad(dragData);

    return operation;

}

static HTMLInputElement* asFileInput(Node* node)

{

    ASSERT(node);

    // The button for a FILE input is a sub element with no set input type

    // In order to get around this problem we assume any non-FILE input element

    // is this internal button, and try querying the shadow parent node.

    if (node->hasTagName(HTMLNames::inputTag) && node->isShadowNode() && static_cast<HTMLInputElement*>(node)->inputType() != HTMLInputElement::FILE)

      node = node->shadowParentNode();

    if (!node || !node->hasTagName(HTMLNames::inputTag))

        return 0;

    HTMLInputElement* inputElem = static_cast<HTMLInputElement*>(node);

    if (inputElem->inputType() == HTMLInputElement::FILE)

        return inputElem;

    return 0;

}

static Element* elementUnderMouse(Document* documentUnderMouse, const IntPoint& p)

{

    FrameView* view = documentUnderMouse->view();

    float zoomFactor = view ? view->pageZoomFactor() : 1;

    IntPoint point = roundedIntPoint(FloatPoint(p.x() * zoomFactor, p.y() * zoomFactor));

    HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);

    HitTestResult result(point);

    documentUnderMouse->renderView()->layer()->hitTest(request, result);

    Node* n = result.innerNode();

    while (n && !n->isElementNode())

        n = n->parentNode();

    if (n)

        n = n->shadowAncestorNode();

    ASSERT(n);

    return static_cast<Element*>(n);

}

bool DragController::tryDocumentDrag(DragData* dragData, DragDestinationAction actionMask, DragOperation& operation)

{

    ASSERT(dragData);

    if (!m_documentUnderMouse)

        return false;

    m_isHandlingDrag = false;

    if (actionMask & DragDestinationActionDHTML) {

        m_isHandlingDrag = tryDHTMLDrag(dragData, operation);

        // Do not continue if m_documentUnderMouse has been reset by tryDHTMLDrag.

        // tryDHTMLDrag fires dragenter event. The event listener that listens

        // to this event may create a nested message loop (open a modal dialog),

        // which could process dragleave event and reset m_documentUnderMouse in

        // dragExited.

        if (!m_documentUnderMouse)

            return false;

    }

    // It's unclear why this check is after tryDHTMLDrag.

    // We send drag events in tryDHTMLDrag and that may be the reason.

    RefPtr<FrameView> frameView = m_documentUnderMouse->view();

    if (!frameView)

        return false;

    if (m_isHandlingDrag) {

        m_page->dragCaretController()->clear();

        return true;

    } else if ((actionMask & DragDestinationActionEdit) && canProcessDrag(dragData)) {

        if (dragData->containsColor()) {

            operation = DragOperationGeneric;

            return true;

        }

        IntPoint point = frameView->windowToContents(dragData->clientPosition());

        Element* element = elementUnderMouse(m_documentUnderMouse.get(), point);

        if (!asFileInput(element)) {

            VisibleSelection dragCaret = m_documentUnderMouse->frame()->visiblePositionForPoint(point);

            m_page->dragCaretController()->setSelection(dragCaret);

        }

        Frame* innerFrame = element->document()->frame();

        operation = dragIsMove(innerFrame->selection()) ? DragOperationMove : DragOperationCopy;

        return true;

    }

    // If we're not over an editable region, make sure we're clearing any prior drag cursor.

    m_page->dragCaretController()->clear();

    return false;

}

DragSourceAction DragController::delegateDragSourceAction(const IntPoint& windowPoint)

{

    m_dragSourceAction = m_client->dragSourceActionMaskForPoint(windowPoint);

    return m_dragSourceAction;

}

DragOperation DragController::operationForLoad(DragData* dragData)

{

    ASSERT(dragData);

    Document* doc = m_page->mainFrame()->documentAtPoint(dragData->clientPosition());

    if (doc && (m_didInitiateDrag || doc->isPluginDocument() || (doc->frame() && doc->frame()->editor()->clientIsEditable())))

        return DragOperationNone;

    return dragOperation(dragData);

}

static bool setSelectionToDragCaret(Frame* frame, VisibleSelection& dragCaret, RefPtr<Range>& range, const IntPoint& point)

{

    frame->selection()->setSelection(dragCaret);

    if (frame->selection()->isNone()) {

        dragCaret = frame->visiblePositionForPoint(point);

        frame->selection()->setSelection(dragCaret);

        range = dragCaret.toNormalizedRange();

    }

    return !frame->selection()->isNone() && frame->selection()->isContentEditable();

}

bool DragController::concludeEditDrag(DragData* dragData)

{

    ASSERT(dragData);

    ASSERT(!m_isHandlingDrag);

    if (!m_documentUnderMouse)

        return false;

    IntPoint point = m_documentUnderMouse->view()->windowToContents(dragData->clientPosition());

    Element* element = elementUnderMouse(m_documentUnderMouse.get(), point);

    Frame* innerFrame = element->ownerDocument()->frame();

    ASSERT(innerFrame);

    if (dragData->containsColor()) {

        Color color = dragData->asColor();

        if (!color.isValid())

            return false;

        if (!innerFrame)

            return false;

        RefPtr<Range> innerRange = innerFrame->selection()->toNormalizedRange();

        RefPtr<CSSStyleDeclaration> style = m_documentUnderMouse->createCSSStyleDeclaration();

        ExceptionCode ec;

        style->setProperty("color", color.name(), ec);

        if (!innerFrame->editor()->shouldApplyStyle(style.get(), innerRange.get()))

            return false;

        m_client->willPerformDragDestinationAction(DragDestinationActionEdit, dragData);

        innerFrame->editor()->applyStyle(style.get(), EditActionSetColor);

        return true;

    }

    if (!m_page->dragController()->canProcessDrag(dragData)) {

        m_page->dragCaretController()->clear();

        return false;

    }

    if (HTMLInputElement* fileInput = asFileInput(element)) {

        if (fileInput->disabled())

            return false;

        if (!dragData->containsFiles())

            return false;

        Vector<String> filenames;

        dragData->asFilenames(filenames);

        if (filenames.isEmpty())

            return false;

        // Ugly. For security none of the APIs available to us can set the input value

        // on file inputs. Even forcing a change in HTMLInputElement doesn't work as

        // RenderFileUploadControl clears the file when doing updateFromElement().

        RenderFileUploadControl* renderer = toRenderFileUploadControl(fileInput->renderer());

        if (!renderer)

            return false;

        renderer->receiveDroppedFiles(filenames);

        return true;

    }

    VisibleSelection dragCaret(m_page->dragCaretController()->selection());

    m_page->dragCaretController()->clear();

    RefPtr<Range> range = dragCaret.toNormalizedRange();

    // For range to be null a WebKit client must have done something bad while

    // manually controlling drag behaviour

    if (!range)

        return false;

    DocLoader* loader = range->ownerDocument()->docLoader();

    loader->setAllowStaleResources(true);

    if (dragIsMove(innerFrame->selection()) || dragCaret.isContentRichlyEditable()) {

        bool chosePlainText = false;

        RefPtr<DocumentFragment> fragment = documentFragmentFromDragData(dragData, range, true, chosePlainText);

        if (!fragment || !innerFrame->editor()->shouldInsertFragment(fragment, range, EditorInsertActionDropped)) {

            loader->setAllowStaleResources(false);

            return false;

        }

        m_client->willPerformDragDestinationAction(DragDestinationActionEdit, dragData);

        if (dragIsMove(innerFrame->selection())) {

            // NSTextView behavior is to always smart delete on moving a selection,

            // but only to smart insert if the selection granularity is word granularity.

            bool smartDelete = innerFrame->editor()->smartInsertDeleteEnabled();

            bool smartInsert = smartDelete && innerFrame->selectionGranularity() == WordGranularity && dragData->canSmartReplace();

            applyCommand(MoveSelectionCommand::create(fragment, dragCaret.base(), smartInsert, smartDelete));

        } else {

            if (setSelectionToDragCaret(innerFrame, dragCaret, range, point))

                applyCommand(ReplaceSelectionCommand::create(m_documentUnderMouse.get(), fragment, true, dragData->canSmartReplace(), chosePlainText));

        }

    } else {

        String text = dragData->asPlainText();

        if (text.isEmpty() || !innerFrame->editor()->shouldInsertText(text, range.get(), EditorInsertActionDropped)) {

            loader->setAllowStaleResources(false);

            return false;

        }

        m_client->willPerformDragDestinationAction(DragDestinationActionEdit, dragData);

        if (setSelectionToDragCaret(innerFrame, dragCaret, range, point))

            applyCommand(ReplaceSelectionCommand::create(m_documentUnderMouse.get(), createFragmentFromText(range.get(), text), true, false, true));

    }

    loader->setAllowStaleResources(false);

    return true;

}

bool DragController::canProcessDrag(DragData* dragData)

{

    ASSERT(dragData);

    if (!dragData->containsCompatibleContent())

        return false;

    IntPoint point = m_page->mainFrame()->view()->windowToContents(dragData->clientPosition());

    HitTestResult result = HitTestResult(point);

    if (!m_page->mainFrame()->contentRenderer())

        return false;

    result = m_page->mainFrame()->eventHandler()->hitTestResultAtPoint(point, true);

    if (!result.innerNonSharedNode())

        return false;

    if (dragData->containsFiles() && asFileInput(result.innerNonSharedNode()))

        return true;

    if (!result.innerNonSharedNode()->isContentEditable())

        return false;

    if (m_didInitiateDrag && m_documentUnderMouse == m_dragInitiator && result.isSelected())

        return false;

    return true;

}

static DragOperation defaultOperationForDrag(DragOperation srcOpMask)

{

    // This is designed to match IE's operation fallback for the case where

    // the page calls preventDefault() in a drag event but doesn't set dropEffect.

    if (srcOpMask == DragOperationEvery)

        return DragOperationCopy;

    if (srcOpMask == DragOperationNone)

        return DragOperationNone;

    if (srcOpMask & DragOperationMove || srcOpMask & DragOperationGeneric)

        return DragOperationMove;

    if (srcOpMask & DragOperationCopy)

        return DragOperationCopy;

    if (srcOpMask & DragOperationLink)

        return DragOperationLink;

    // FIXME: Does IE really return "generic" even if no operations were allowed by the source?

    return DragOperationGeneric;

}

bool DragController::tryDHTMLDrag(DragData* dragData, DragOperation& operation)

{

    ASSERT(dragData);

    ASSERT(m_documentUnderMouse);

    RefPtr<Frame> mainFrame = m_page->mainFrame();

    RefPtr<FrameView> viewProtector = mainFrame->view();

    if (!viewProtector)

        return false;

    ClipboardAccessPolicy policy = m_documentUnderMouse->securityOrigin()->isLocal() ? ClipboardReadable : ClipboardTypesReadable;

    RefPtr<Clipboard> clipboard = dragData->createClipboard(policy);

    DragOperation srcOpMask = dragData->draggingSourceOperationMask();

    clipboard->setSourceOperation(srcOpMask);