/*

 * Copyright (C) 2007, 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. 

 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

 *     its contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission. 

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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 "EventSender.h"

#include "DraggingInfo.h"

#include "DumpRenderTree.h"

#include <WebCore/COMPtr.h>

#include <wtf/ASCIICType.h>

#include <wtf/Platform.h>

#include <JavaScriptCore/JavaScriptCore.h>

#include <JavaScriptCore/Assertions.h>

#include <WebKit/WebKit.h>

#include <windows.h>

#define WM_DRT_SEND_QUEUED_EVENT (WM_APP+1)

static bool down;

static bool dragMode = true;

static bool replayingSavedEvents;

static int timeOffset;

static POINT lastMousePosition;

struct DelayedMessage {

    MSG msg;

    unsigned delay;

};

static DelayedMessage msgQueue[1024];

static unsigned endOfQueue;

static unsigned startOfQueue;

static bool didDragEnter;

DraggingInfo* draggingInfo = 0;

static JSValueRef getDragModeCallback(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)

{

    return JSValueMakeBoolean(context, dragMode);

}

static bool setDragModeCallback(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)

{

    dragMode = JSValueToBoolean(context, value);

    return true;

}

static JSValueRef getConstantCallback(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)

{

    if (JSStringIsEqualToUTF8CString(propertyName, "WM_KEYDOWN"))

        return JSValueMakeNumber(context, WM_KEYDOWN);

    if (JSStringIsEqualToUTF8CString(propertyName, "WM_KEYUP"))

        return JSValueMakeNumber(context, WM_KEYUP);

    if (JSStringIsEqualToUTF8CString(propertyName, "WM_CHAR"))

        return JSValueMakeNumber(context, WM_CHAR);

    if (JSStringIsEqualToUTF8CString(propertyName, "WM_DEADCHAR"))

        return JSValueMakeNumber(context, WM_DEADCHAR);

    if (JSStringIsEqualToUTF8CString(propertyName, "WM_SYSKEYDOWN"))

        return JSValueMakeNumber(context, WM_SYSKEYDOWN);

    if (JSStringIsEqualToUTF8CString(propertyName, "WM_SYSKEYUP"))

        return JSValueMakeNumber(context, WM_SYSKEYUP);

    if (JSStringIsEqualToUTF8CString(propertyName, "WM_SYSCHAR"))

        return JSValueMakeNumber(context, WM_SYSCHAR);

    if (JSStringIsEqualToUTF8CString(propertyName, "WM_SYSDEADCHAR"))

        return JSValueMakeNumber(context, WM_SYSDEADCHAR);

    ASSERT_NOT_REACHED();

    return JSValueMakeUndefined(context);

}

static JSValueRef leapForwardCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

    if (argumentCount > 0) {

        msgQueue[endOfQueue].delay = JSValueToNumber(context, arguments[0], exception);

        ASSERT(!exception || !*exception);

    }

    return JSValueMakeUndefined(context);

}

static DWORD currentEventTime()

{

    return ::GetTickCount() + timeOffset;

}

static MSG makeMsg(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

{

    MSG result = {0};

    result.hwnd = hwnd;

    result.message = message;

    result.wParam = wParam;

    result.lParam = lParam;

    result.time = currentEventTime();

    result.pt = lastMousePosition;

    return result;

}

static LRESULT dispatchMessage(const MSG* msg)

{

    ASSERT(msg);

    ::TranslateMessage(msg);

    return ::DispatchMessage(msg);

}

static JSValueRef contextClickCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

    COMPtr<IWebFramePrivate> framePrivate;

    if (SUCCEEDED(frame->QueryInterface(&framePrivate)))

        framePrivate->layout();

    down = true;

    MSG msg = makeMsg(webViewWindow, WM_RBUTTONDOWN, 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));

    dispatchMessage(&msg);

    down = false;

    msg = makeMsg(webViewWindow, WM_RBUTTONUP, 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));

    dispatchMessage(&msg);

    return JSValueMakeUndefined(context);

}

static WPARAM buildModifierFlags(JSContextRef context, const JSValueRef modifiers)

{

    JSObjectRef modifiersArray = JSValueToObject(context, modifiers, 0);

    if (!modifiersArray)

        return 0;

    WPARAM flags = 0;

    int modifiersCount = JSValueToNumber(context, JSObjectGetProperty(context, modifiersArray, JSStringCreateWithUTF8CString("length"), 0), 0);

    for (int i = 0; i < modifiersCount; ++i) {

        JSValueRef value = JSObjectGetPropertyAtIndex(context, modifiersArray, i, 0);

        JSStringRef string = JSValueToStringCopy(context, value, 0);

        if (JSStringIsEqualToUTF8CString(string, "ctrlKey")

            || JSStringIsEqualToUTF8CString(string, "addSelectionKey"))

            flags |= MK_CONTROL;

        else if (JSStringIsEqualToUTF8CString(string, "shiftKey")

                 || JSStringIsEqualToUTF8CString(string, "rangeSelectionKey"))

            flags |= MK_SHIFT;

        // No way to specifiy altKey in a MSG.

        JSStringRelease(string);

    }

    return flags;

}

static JSValueRef mouseDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

    COMPtr<IWebFramePrivate> framePrivate;

    if (SUCCEEDED(frame->QueryInterface(&framePrivate)))

        framePrivate->layout();

    down = true;

    int mouseType = WM_LBUTTONDOWN;

    if (argumentCount >= 1) {

        int mouseNumber = JSValueToNumber(context, arguments[0], exception);

        switch (mouseNumber) {

        case 0:

            mouseType = WM_LBUTTONDOWN;

            break;

        case 1:

            mouseType = WM_MBUTTONDOWN;

            break;

        case 2:

            mouseType = WM_RBUTTONDOWN;

            break;

        case 3:

            // fast/events/mouse-click-events expects the 4th button has event.button = 1, so send an WM_BUTTONDOWN

            mouseType = WM_MBUTTONDOWN;

            break;

        default:

            mouseType = WM_LBUTTONDOWN;

            break;

        }

    }

    WPARAM wparam = 0;

    if (argumentCount >= 2)

        wparam |= buildModifierFlags(context, arguments[1]);

    MSG msg = makeMsg(webViewWindow, mouseType, wparam, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));

    if (!msgQueue[endOfQueue].delay)

        dispatchMessage(&msg);

    else {

        // replaySavedEvents has the required logic to make leapForward delays work

        msgQueue[endOfQueue++].msg = msg;

        replaySavedEvents();

    }

    return JSValueMakeUndefined(context);

}

static inline POINTL pointl(const POINT& point)

{

    POINTL result;

    result.x = point.x;

    result.y = point.y;

    return result;

}

static void doMouseUp(MSG msg, HRESULT* oleDragAndDropReturnValue = 0)

{

    COMPtr<IWebFramePrivate> framePrivate;

    if (SUCCEEDED(frame->QueryInterface(&framePrivate)))

        framePrivate->layout();

    dispatchMessage(&msg);

    down = false;

    if (draggingInfo) {

        COMPtr<IWebView> webView;

        COMPtr<IDropTarget> webViewDropTarget;

        if (SUCCEEDED(frame->webView(&webView)) && SUCCEEDED(webView->QueryInterface(IID_IDropTarget, (void**)&webViewDropTarget))) {

            POINT screenPoint = msg.pt;

            DWORD effect = 0;

            ::ClientToScreen(webViewWindow, &screenPoint);

            if (!didDragEnter) {

                webViewDropTarget->DragEnter(draggingInfo->dataObject(), 0, pointl(screenPoint), &effect);

                didDragEnter = true;

            }

            HRESULT hr = draggingInfo->dropSource()->QueryContinueDrag(0, 0);

            if (oleDragAndDropReturnValue)

                *oleDragAndDropReturnValue = hr;

            webViewDropTarget->DragOver(0, pointl(screenPoint), &effect);

            if (hr == DRAGDROP_S_DROP && effect != DROPEFFECT_NONE) {

                DWORD effect = 0;

                webViewDropTarget->Drop(draggingInfo->dataObject(), 0, pointl(screenPoint), &effect);

                draggingInfo->setPerformedDropEffect(effect);

            } else

                webViewDropTarget->DragLeave();

            // Reset didDragEnter so that another drag started within the same frame works properly.

            didDragEnter = false;

        }

    }

}

static JSValueRef mouseUpCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

    int mouseType = WM_LBUTTONUP;

    if (argumentCount >= 1) {

        int mouseNumber = JSValueToNumber(context, arguments[0], exception);

        switch (mouseNumber) {

        case 0:

            mouseType = WM_LBUTTONUP;

            break;

        case 1:

            mouseType = WM_MBUTTONUP;

            break;

        case 2:

            mouseType = WM_RBUTTONUP;

            break;

        case 3:

            // fast/events/mouse-click-events expects the 4th button has event.button = 1, so send an WM_MBUTTONUP

            mouseType = WM_MBUTTONUP;

            break;

        default:

            mouseType = WM_LBUTTONUP;

            break;

        }

    }

    WPARAM wparam = 0;

    if (argumentCount >= 2)

        wparam |= buildModifierFlags(context, arguments[1]);

    MSG msg = makeMsg(webViewWindow, mouseType, wparam, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));

    if ((dragMode && !replayingSavedEvents) || msgQueue[endOfQueue].delay) {

        msgQueue[endOfQueue++].msg = msg;

        replaySavedEvents();

    } else

        doMouseUp(msg);

    return JSValueMakeUndefined(context);

}

static void doMouseMove(MSG msg)

{

    COMPtr<IWebFramePrivate> framePrivate;

    if (SUCCEEDED(frame->QueryInterface(&framePrivate)))

        framePrivate->layout();

    dispatchMessage(&msg);

    if (down && draggingInfo) {

        POINT screenPoint = msg.pt;

        ::ClientToScreen(webViewWindow, &screenPoint);

        IWebView* webView;

        COMPtr<IDropTarget> webViewDropTarget;

        if (SUCCEEDED(frame->webView(&webView)) && SUCCEEDED(webView->QueryInterface(IID_IDropTarget, (void**)&webViewDropTarget))) {

            DWORD effect = 0;

            if (didDragEnter)

                webViewDropTarget->DragOver(MK_LBUTTON, pointl(screenPoint), &effect);

            else {

                webViewDropTarget->DragEnter(draggingInfo->dataObject(), 0, pointl(screenPoint), &effect);

                didDragEnter = true;

            }

            draggingInfo->dropSource()->GiveFeedback(effect);

        }

    }

}

static JSValueRef mouseMoveToCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

    if (argumentCount < 2)

        return JSValueMakeUndefined(context);

    lastMousePosition.x = (int)JSValueToNumber(context, arguments[0], exception);

    ASSERT(!exception || !*exception);

    lastMousePosition.y = (int)JSValueToNumber(context, arguments[1], exception);

    ASSERT(!exception || !*exception);

    MSG msg = makeMsg(webViewWindow, WM_MOUSEMOVE, down ? MK_LBUTTON : 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));

    if (dragMode && down && !replayingSavedEvents) {

        msgQueue[endOfQueue++].msg = msg;

        return JSValueMakeUndefined(context);

    }

    doMouseMove(msg);

    return JSValueMakeUndefined(context);

}

void replaySavedEvents(HRESULT* oleDragAndDropReturnValue)

{

    replayingSavedEvents = true;

    MSG msg = { 0 };

    while (startOfQueue < endOfQueue && !msgQueue[startOfQueue].delay) {

        msg = msgQueue[startOfQueue++].msg;

        switch (msg.message) {

            case WM_LBUTTONUP:

            case WM_RBUTTONUP:

            case WM_MBUTTONUP:

                doMouseUp(msg, oleDragAndDropReturnValue);

                break;

            case WM_MOUSEMOVE:

                doMouseMove(msg);

                break;

            case WM_LBUTTONDOWN:

            case WM_RBUTTONDOWN:

            case WM_MBUTTONDOWN:

                dispatchMessage(&msg);

                break;

            default:

                // Not reached

                break;

        }

    }

    int numQueuedMessages = endOfQueue - startOfQueue;

    if (!numQueuedMessages) {

        startOfQueue = 0;

        endOfQueue = 0;

        replayingSavedEvents = false;

        ASSERT(!down);

        return;

    }

    if (msgQueue[startOfQueue].delay) {

        ::Sleep(msgQueue[startOfQueue].delay);

        msgQueue[startOfQueue].delay = 0;

    }

    ::PostMessage(webViewWindow, WM_DRT_SEND_QUEUED_EVENT, 0, 0);

    while (::GetMessage(&msg, webViewWindow, 0, 0)) {

        // FIXME: Why do we get a WM_MOUSELEAVE? it breaks tests

        if (msg.message == WM_MOUSELEAVE)

            continue;

        if (msg.message != WM_DRT_SEND_QUEUED_EVENT) {

            dispatchMessage(&msg);

            continue;

        }

        msg = msgQueue[startOfQueue++].msg;

        switch (msg.message) {

            case WM_LBUTTONUP:

            case WM_RBUTTONUP:

            case WM_MBUTTONUP:

                doMouseUp(msg, oleDragAndDropReturnValue);

                break;

            case WM_MOUSEMOVE:

                doMouseMove(msg);

                break;

            case WM_LBUTTONDOWN:

            case WM_RBUTTONDOWN:

            case WM_MBUTTONDOWN:

                dispatchMessage(&msg);

                break;

            default:

                // Not reached

                break;

        }

        if (startOfQueue >= endOfQueue)

            break;

        ::Sleep(msgQueue[startOfQueue].delay);

        msgQueue[startOfQueue].delay = 0;

        ::PostMessage(webViewWindow, WM_DRT_SEND_QUEUED_EVENT, 0, 0);

    }

    startOfQueue = 0;

    endOfQueue = 0;

    replayingSavedEvents = false;

}

static JSValueRef keyDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

    if (argumentCount < 1)

        return JSValueMakeUndefined(context);

    static const JSStringRef lengthProperty = JSStringCreateWithUTF8CString("length");

    COMPtr<IWebFramePrivate> framePrivate;

    if (SUCCEEDED(frame->QueryInterface(&framePrivate)))

        framePrivate->layout();

    JSStringRef character = JSValueToStringCopy(context, arguments[0], exception);

    ASSERT(!*exception);

    int virtualKeyCode;

    int charCode = 0;

    int keyData = 1;

    bool needsShiftKeyModifier = false;

    if (JSStringIsEqualToUTF8CString(character, "leftArrow")) {

        virtualKeyCode = VK_LEFT;

        keyData += KF_EXTENDED << 16; // In this case, extended means "not keypad".

    } else if (JSStringIsEqualToUTF8CString(character, "rightArrow")) {

        virtualKeyCode = VK_RIGHT;

        keyData += KF_EXTENDED << 16;

    } else if (JSStringIsEqualToUTF8CString(character, "upArrow")) {

        virtualKeyCode = VK_UP;

        keyData += KF_EXTENDED << 16;

    } else if (JSStringIsEqualToUTF8CString(character, "downArrow")) {

        virtualKeyCode = VK_DOWN;

        keyData += KF_EXTENDED << 16;

    } else if (JSStringIsEqualToUTF8CString(character, "pageUp"))

        virtualKeyCode = VK_PRIOR;

    else if (JSStringIsEqualToUTF8CString(character, "pageDown"))

        virtualKeyCode = VK_NEXT;

    else if (JSStringIsEqualToUTF8CString(character, "home"))

        virtualKeyCode = VK_HOME;

    else if (JSStringIsEqualToUTF8CString(character, "end"))

        virtualKeyCode = VK_END;

    else if (JSStringIsEqualToUTF8CString(character, "delete"))

        virtualKeyCode = VK_DELETE;

    else {

        charCode = JSStringGetCharactersPtr(character)[0];

        virtualKeyCode = LOBYTE(VkKeyScan(charCode));

        if (WTF::isASCIIUpper(charCode))

            needsShiftKeyModifier = true;

    }

    JSStringRelease(character);

    BYTE keyState[256];

    if (argumentCount > 1 || needsShiftKeyModifier) {

        ::GetKeyboardState(keyState);

        BYTE newKeyState[256];

        memcpy(newKeyState, keyState, sizeof(keyState));

        if (needsShiftKeyModifier)

            newKeyState[VK_SHIFT] = 0x80;

        if (argumentCount > 1) {

            JSObjectRef modifiersArray = JSValueToObject(context, arguments[1], 0);

            if (modifiersArray) {

                int modifiersCount = JSValueToNumber(context, JSObjectGetProperty(context, modifiersArray, lengthProperty, 0), 0);

                for (int i = 0; i < modifiersCount; ++i) {

                    JSValueRef value = JSObjectGetPropertyAtIndex(context, modifiersArray, i, 0);

                    JSStringRef string = JSValueToStringCopy(context, value, 0);

                    if (JSStringIsEqualToUTF8CString(string, "ctrlKey") || JSStringIsEqualToUTF8CString(string, "addSelectionKey"))

                        newKeyState[VK_CONTROL] = 0x80;

                    else if (JSStringIsEqualToUTF8CString(string, "shiftKey") || JSStringIsEqualToUTF8CString(string, "rangeSelectionKey"))

                        newKeyState[VK_SHIFT] = 0x80;

                    else if (JSStringIsEqualToUTF8CString(string, "altKey"))

                        newKeyState[VK_MENU] = 0x80;

                    JSStringRelease(string);

                }

            }

        }

        ::SetKeyboardState(newKeyState);

    }

    MSG msg = makeMsg(webViewWindow, (::GetKeyState(VK_MENU) & 0x8000) ? WM_SYSKEYDOWN : WM_KEYDOWN, virtualKeyCode, keyData);

    if (virtualKeyCode != 255)

        dispatchMessage(&msg);

    else {

        // For characters that do not exist in the active keyboard layout,

        // ::Translate will not work, so we post an WM_CHAR event ourselves.

        ::PostMessage(webViewWindow, WM_CHAR, charCode, 0);

    }

    // Tests expect that all messages are processed by the time keyDown() returns.

    if (::PeekMessage(&msg, webViewWindow, WM_CHAR, WM_CHAR, PM_REMOVE) || ::PeekMessage(&msg, webViewWindow, WM_SYSCHAR, WM_SYSCHAR, PM_REMOVE))

        ::DispatchMessage(&msg);

    MSG msgUp = makeMsg(webViewWindow, (::GetKeyState(VK_MENU) & 0x8000) ? WM_SYSKEYUP : WM_KEYUP, virtualKeyCode, keyData);

    ::DispatchMessage(&msgUp);

    if (argumentCount > 1 || needsShiftKeyModifier)