// -*- c-basic-offset: 4 -*-

/*

 *  Copyright (C) 2000 Harri Porten (porten@kde.org)

 *  Copyright (C) 2006 Jon Shier (jshier@iastate.edu)

 *  Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reseved.

 *  Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Lesser General Public

 *  License as published by the Free Software Foundation; either

 *  version 2 of the License, or (at your option) any later version.

 *

 *  This library is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *  Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include "config.h"

#if PLATFORM(SYMBIAN)

#include "../../bidi.h"

#endif

#include "kjs_window.h"

#include "Base64.h"

#include "CString.h"

#include "Chrome.h"

#include "DOMWindow.h"

#include "Element.h"

#include "EventListener.h"

#include "EventNames.h"

#include "ExceptionCode.h"

#include "FloatRect.h"

#include "Frame.h"

#include "FrameLoadRequest.h"

#include "FrameLoader.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "GCController.h"

#include "HTMLDocument.h"

#include "JSCSSRule.h"

#include "JSCSSValue.h"

#include "JSDOMExceptionConstructor.h"

#include "JSDOMWindow.h"

#include "JSEvent.h"

#include "JSHTMLCollection.h"

#include "JSHTMLOptionElementConstructor.h"

#include "JSMutationEvent.h"

#include "JSNode.h"

#include "JSNodeFilter.h"

#include "JSRange.h"

#include "JSXMLHttpRequest.h"

#include "Logging.h"

#include "Page.h"

#include "PlatformScreen.h"

#include "PlugInInfoStore.h"

#include "RenderView.h"

#include "SecurityOrigin.h"

#include "Settings.h"

#include "WindowFeatures.h"

#include "htmlediting.h"

#include "kjs_css.h"

#include "kjs_events.h"

#include "kjs_navigator.h"

#include "kjs_proxy.h"

#include <wtf/MathExtras.h>

#include "symbian/kjs_console.h"

#if ENABLE(XSLT)

#include "JSXSLTProcessor.h"

#endif

using namespace WebCore;

using namespace EventNames;

namespace KJS {

static int lastUsedTimeoutId;

static int timerNestingLevel = 0;

const int cMaxTimerNestingLevel = 5;

const double cMinimumTimerInterval = 0.010;

struct WindowPrivate {

    WindowPrivate()

        : loc(0)

        , m_evt(0)

        , m_dialogArguments(0)

        , m_returnValueSlot(0)

    {

    }

    Window::ListenersMap jsEventListeners;

    Window::ListenersMap jsHTMLEventListeners;

    Window::UnprotectedListenersMap jsUnprotectedEventListeners;

    Window::UnprotectedListenersMap jsUnprotectedHTMLEventListeners;

    mutable Location* loc;

    WebCore::Event *m_evt;

    JSValue* m_dialogArguments;

    JSValue** m_returnValueSlot;

    typedef HashMap<int, DOMWindowTimer*> TimeoutsMap;

    TimeoutsMap m_timeouts;

};

class DOMWindowTimer : public TimerBase {

public:

    DOMWindowTimer(int timeoutId, int nestingLevel, Window* o, ScheduledAction* a)

        : m_timeoutId(timeoutId), m_nestingLevel(nestingLevel), m_object(o), m_action(a) { }

    virtual ~DOMWindowTimer()

    {

        JSLock lock;

        delete m_action;

    }

    int timeoutId() const { return m_timeoutId; }

    int nestingLevel() const { return m_nestingLevel; }

    void setNestingLevel(int n) { m_nestingLevel = n; }

    ScheduledAction* action() const { return m_action; }

    ScheduledAction* takeAction() { ScheduledAction* a = m_action; m_action = 0; return a; }

private:

    virtual void fired();

    int m_timeoutId;

    int m_nestingLevel;

    Window* m_object;

    ScheduledAction* m_action;

};

class PausedTimeout {

public:

    int timeoutId;

    int nestingLevel;

    double nextFireInterval;

    double repeatInterval;

    ScheduledAction *action;

};

} // namespace KJS

#include "kjs_window.lut.h"

namespace KJS {

////////////////////// Window Object ////////////////////////

const ClassInfo Window::info = { "Window", 0, &WindowTable, 0 };

/*

@begin WindowTable 119

# Warning, when adding a function to this object you need to add a case in Window::get

# -- Functions --

  atob                  Window::AToB                DontDelete|Function 1

  btoa                  Window::BToA                DontDelete|Function 1

  scroll                Window::Scroll              DontDelete|Function 2

  scrollBy              Window::ScrollBy            DontDelete|Function 2

  scrollTo              Window::ScrollTo            DontDelete|Function 2

  moveBy                Window::MoveBy              DontDelete|Function 2

  moveTo                Window::MoveTo              DontDelete|Function 2

  resizeBy              Window::ResizeBy            DontDelete|Function 2

  resizeTo              Window::ResizeTo            DontDelete|Function 2

  open                  Window::Open                DontDelete|Function 3

  setTimeout            Window::SetTimeout          DontDelete|Function 2

  clearTimeout          Window::ClearTimeout        DontDelete|Function 1

  setInterval           Window::SetInterval         DontDelete|Function 2

  clearInterval         Window::ClearInterval       DontDelete|Function 1

  captureEvents         Window::CaptureEvents       DontDelete|Function 0

  releaseEvents         Window::ReleaseEvents       DontDelete|Function 0

  addEventListener      Window::AddEventListener    DontDelete|Function 3

  removeEventListener   Window::RemoveEventListener DontDelete|Function 3

  showModalDialog       Window::ShowModalDialog     DontDelete|Function 1

# -- Attributes --

  crypto                Window::Crypto              DontDelete|ReadOnly

  event                 Window::Event_              DontDelete

  location              Window::Location_           DontDelete

  navigator             Window::Navigator_          DontDelete|ReadOnly

  clientInformation     Window::ClientInformation   DontDelete|ReadOnly

  console				Window::Console_			DontDelete

# -- Event Listeners --

  onabort               Window::Onabort             DontDelete

  onblur                Window::Onblur              DontDelete

  onchange              Window::Onchange            DontDelete

  onclick               Window::Onclick             DontDelete

  ondblclick            Window::Ondblclick          DontDelete

  onerror               Window::Onerror             DontDelete

  onfocus               Window::Onfocus             DontDelete

  onkeydown             Window::Onkeydown           DontDelete

  onkeypress            Window::Onkeypress          DontDelete

  onkeyup               Window::Onkeyup             DontDelete

  onload                Window::Onload              DontDelete

  onmousedown           Window::Onmousedown         DontDelete

  onmousemove           Window::Onmousemove         DontDelete

  onmouseout            Window::Onmouseout          DontDelete

  onmouseover           Window::Onmouseover         DontDelete

  onmouseup             Window::Onmouseup           DontDelete

  onmousewheel          Window::OnWindowMouseWheel  DontDelete

  onreset               Window::Onreset             DontDelete

  onresize              Window::Onresize            DontDelete

  onscroll              Window::Onscroll            DontDelete

  onsearch              Window::Onsearch            DontDelete

  onselect              Window::Onselect            DontDelete

  onsubmit              Window::Onsubmit            DontDelete

  onunload              Window::Onunload            DontDelete

  onbeforeunload        Window::Onbeforeunload      DontDelete

# -- Constructors --

  DOMException          Window::DOMException        DontDelete

  Image                 Window::Image               DontDelete

  Option                Window::Option              DontDelete

  XMLHttpRequest        Window::XMLHttpRequest      DontDelete

  XSLTProcessor         Window::XSLTProcessor_      DontDelete

@end

*/

Window::Window(DOMWindow* window)

  : m_impl(window)

  , d(new WindowPrivate)

{

}

Window::~Window()

{

    clearAllTimeouts();

    // Clear any backpointers to the window

    ListenersMap::iterator i2 = d->jsEventListeners.begin();

    ListenersMap::iterator e2 = d->jsEventListeners.end();

    for (; i2 != e2; ++i2)

        i2->second->clearWindowObj();

    i2 = d->jsHTMLEventListeners.begin();

    e2 = d->jsHTMLEventListeners.end();

    for (; i2 != e2; ++i2)

        i2->second->clearWindowObj();

    UnprotectedListenersMap::iterator i1 = d->jsUnprotectedEventListeners.begin();

    UnprotectedListenersMap::iterator e1 = d->jsUnprotectedEventListeners.end();

    for (; i1 != e1; ++i1)

        i1->second->clearWindowObj();

    i1 = d->jsUnprotectedHTMLEventListeners.begin();

    e1 = d->jsUnprotectedHTMLEventListeners.end();

    for (; i1 != e1; ++i1)

        i1->second->clearWindowObj();

}

ScriptInterpreter* Window::interpreter() const

{

    Frame* frame = impl()->frame();

    if (!frame)

        return 0;

    return frame->scriptProxy()->interpreter();

}

Window *Window::retrieveWindow(Frame *f)

{

    JSObject *o = retrieve(f)->getObject();

    ASSERT(o || !f->settings() || !f->settings()->isJavaScriptEnabled());

    return static_cast<Window *>(o);

}

Window *Window::retrieveActive(ExecState *exec)

{

    JSValue *imp = exec->dynamicInterpreter()->globalObject();

    ASSERT(imp);

    return static_cast<Window*>(imp);

}

JSValue *Window::retrieve(Frame *p)

{

    ASSERT(p);

    if (KJSProxy *proxy = p->scriptProxy())

        return proxy->interpreter()->globalObject(); // the Global object is the "window"

    return jsUndefined(); // This can happen with JS disabled on the domain of that window

}

Location *Window::location() const

{

  if (!d->loc)

    d->loc = new Location(impl()->frame());

  return d->loc;

}

ConsoleObject *Window::console(ExecState *exec) const

{

  return new ConsoleObject(exec, impl()->frame()->page()->chrome());

}

// reference our special objects during garbage collection

void Window::mark()

{

  JSObject::mark();

  if (d->loc && !d->loc->marked())

    d->loc->mark();

}

static bool allowPopUp(ExecState *exec, Window *window)

{

    Frame* frame = window->impl()->frame();

    if (!frame)

        return false;

    if (static_cast<ScriptInterpreter*>(exec->dynamicInterpreter())->wasRunByUserGesture())

        return true;

    Settings* settings = frame->settings();

    return settings && settings->JavaScriptCanOpenWindowsAutomatically();

}

static HashMap<String, String> parseModalDialogFeatures(ExecState *exec, JSValue *featuresArg)

{

    HashMap<String, String> map;

    Vector<String> features = valueToStringWithUndefinedOrNullCheck(exec, featuresArg).split(';');

    Vector<String>::const_iterator end = features.end();

    for (Vector<String>::const_iterator it = features.begin(); it != end; ++it) {

        String s = *it;

        int pos = s.find('=');

        int colonPos = s.find(':');

        if (pos >= 0 && colonPos >= 0)

            continue; // ignore any strings that have both = and :

        if (pos < 0)

            pos = colonPos;

        if (pos < 0) {

            // null string for value means key without value

            map.set(s.stripWhiteSpace().lower(), String());

        } else {

            String key = s.left(pos).stripWhiteSpace().lower();

            String val = s.substring(pos + 1).stripWhiteSpace().lower();

            int spacePos = val.find(' ');

            if (spacePos != -1)

                val = val.left(spacePos);

            map.set(key, val);

        }

    }

    return map;

}

static bool boolFeature(const HashMap<String, String>& features, const char* key, bool defaultValue = false)

{

    HashMap<String, String>::const_iterator it = features.find(key);

    if (it == features.end())

        return defaultValue;

    const String& value = it->second;

    return value.isNull() || value == "1" || value == "yes" || value == "on";

}

static float floatFeature(const HashMap<String, String> &features, const char *key, float min, float max, float defaultValue)

{

    HashMap<String, String>::const_iterator it = features.find(key);

    if (it == features.end())

        return defaultValue;

    // FIXME: Can't distinguish "0q" from string with no digits in it -- both return d == 0 and ok == false.

    // Would be good to tell them apart somehow since string with no digits should be default value and

    // "0q" should be minimum value.

    bool ok;

    double d = it->second.toDouble(&ok);

    if ((d == 0 && !ok) || isnan(d))

        return defaultValue;

    if (d < min || max <= min)

        return min;

    if (d > max)

        return max;

    return static_cast<int>(d);

}

static Frame* createWindow(ExecState* exec, Frame* openerFrame, const String& url,

    const String& frameName, const WindowFeatures& windowFeatures)

{

    Frame* activeFrame = Window::retrieveActive(exec)->impl()->frame();

    ResourceRequest request;

    if (activeFrame)

        request.setHTTPReferrer(activeFrame->loader()->outgoingReferrer());

    FrameLoadRequest frameRequest(request, frameName);

    // FIXME: It's much better for client API if a new window starts with a URL, here where we

    // know what URL we are going to open. Unfortunately, this code passes the empty string

    // for the URL, but there's a reason for that. Before loading we have to set up the opener,

    // openedByDOM, and dialogArguments values. Also, to decide whether to use the URL we currently

    // do an isSafeScript call using the window we create, which can't be done before creating it.

    // We'd have to resolve all those issues to pass the URL instead of "".

    bool created;

    Frame* newFrame = openerFrame->loader()->createWindow(frameRequest, windowFeatures, created);

    if (!newFrame)

        return 0;

    newFrame->loader()->setOpener(openerFrame);

    newFrame->loader()->setOpenedByDOM();

    Window* newWindow = Window::retrieveWindow(newFrame);

    if (!url.startsWith("javascript:", false) || newWindow->isSafeScript(exec)) {

        String completedURL = url.isEmpty() ? url : activeFrame->document()->completeURL(url);

        bool userGesture = static_cast<ScriptInterpreter *>(exec->dynamicInterpreter())->wasRunByUserGesture();

        if (created) {

            newFrame->loader()->changeLocation(KURL(completedURL.deprecatedString()), activeFrame->loader()->outgoingReferrer(), false, userGesture);

            if (Document* oldDoc = openerFrame->document()) {

                newFrame->document()->setDomainInternal(oldDoc->domain());

                newFrame->document()->setBaseURL(oldDoc->baseURL());

            }

        } else if (!url.isEmpty())

            newFrame->loader()->scheduleLocationChange(completedURL, activeFrame->loader()->outgoingReferrer(), false, userGesture);

    }

    return newFrame;

}

static bool canShowModalDialog(const Window *window)

{

    Frame* frame = window->impl()->frame();

    if (!frame)

        return false;

    return frame->page()->chrome()->canRunModal();

}

static bool canShowModalDialogNow(const Window *window)

{

    Frame* frame = window->impl()->frame();

    if (!frame)

        return false;

    return frame->page()->chrome()->canRunModalNow();

}

static JSValue* showModalDialog(ExecState* exec, Window* openerWindow, const List& args)

{

    if (!canShowModalDialogNow(openerWindow) || !allowPopUp(exec, openerWindow))

        return jsUndefined();

    const HashMap<String, String> features = parseModalDialogFeatures(exec, args[2]);

    bool trusted = false;

    WindowFeatures wargs;

    // The following features from Microsoft's documentation are not implemented:

    // - default font settings

    // - width, height, left, and top specified in units other than "px"

    // - edge (sunken or raised, default is raised)

    // - dialogHide: trusted && boolFeature(features, "dialoghide"), makes dialog hide when you print

    // - help: boolFeature(features, "help", true), makes help icon appear in dialog (what does it do on Windows?)

    // - unadorned: trusted && boolFeature(features, "unadorned");

    Frame* frame = openerWindow->impl()->frame();

    if (!frame)

        return jsUndefined();

    FloatRect screenRect = screenAvailableRect(frame->view());

    wargs.width = floatFeature(features, "dialogwidth", 100, screenRect.width(), 620); // default here came from frame size of dialog in MacIE

    wargs.widthSet = true;

    wargs.height = floatFeature(features, "dialogheight", 100, screenRect.height(), 450); // default here came from frame size of dialog in MacIE

    wargs.heightSet = true;

    wargs.x = floatFeature(features, "dialogleft", screenRect.x(), screenRect.right() - wargs.width, -1);

    wargs.xSet = wargs.x > 0;

    wargs.y = floatFeature(features, "dialogtop", screenRect.y(), screenRect.bottom() - wargs.height, -1);

    wargs.ySet = wargs.y > 0;

    if (boolFeature(features, "center", true)) {

        if (!wargs.xSet) {

            wargs.x = screenRect.x() + (screenRect.width() - wargs.width) / 2;

            wargs.xSet = true;

        }

        if (!wargs.ySet) {

            wargs.y = screenRect.y() + (screenRect.height() - wargs.height) / 2;

            wargs.ySet = true;

        }

    }

    wargs.dialog = true;

    wargs.resizable = boolFeature(features, "resizable");

    wargs.scrollbarsVisible = boolFeature(features, "scroll", true);

    wargs.statusBarVisible = boolFeature(features, "status", !trusted);

    wargs.menuBarVisible = false;

    wargs.toolBarVisible = false;

    wargs.locationBarVisible = false;

    wargs.fullscreen = false;

    Frame* dialogFrame = createWindow(exec, frame, valueToStringWithUndefinedOrNullCheck(exec, args[0]), "", wargs);

    if (!dialogFrame)

        return jsUndefined();

    Window* dialogWindow = Window::retrieveWindow(dialogFrame);

    dialogWindow->putDirect("dialogArguments", args[1]);

    // Get the return value either just before clearing the dialog window's

    // properties (in Window::clear), or when on return from runModal.

    JSValue* returnValue = 0;

    dialogWindow->setDialogArgumentsAndReturnValueSlot(args[1], &returnValue);

    dialogFrame->page()->chrome()->runModal();

    dialogWindow->setDialogArgumentsAndReturnValueSlot(0, 0);

    // If we don't have a return value, get it now.

    // Either Window::clear was not called yet, or there was no return value,

    // and in that case, there's no harm in trying again (no benefit either).

    if (!returnValue)

        returnValue = dialogWindow->getDirect("returnValue");

    return returnValue ? returnValue : jsUndefined();

}

JSValue *Window::getValueProperty(ExecState *exec, int token) const

{

   ASSERT(impl()->frame());

   switch (token) {

   case Console_:

      return console(exec);

   case Crypto:

      if (!isSafeScript(exec))

        return jsUndefined();

      return jsUndefined(); // FIXME: implement this

   case DOMException: