/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program 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, version 2.1 of the License.

* 

* This program 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 program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

#include "webpagecontroller.h"

#include "FlowInterface.h"

#include "HistoryView_p.h"

#include "HistoryView.h"

#include "HistoryViewEventContext.h"

#include <QWebHistory>

#include <QWebFrame>

#include "wrtbrowsercontainer.h"

#include "webpagedata.h"

#include "scriptobjects.h"

#include <QDebug>

namespace WRT {

HistoryViewPrivate::HistoryViewPrivate(WebPageController * pageMgr,

                                       QWidget* parent) :

    m_flowInterface(0),

    m_widgetParent(parent),

    m_graphicsWidgetParent(0),

    m_pageManager(pageMgr),

    m_activePage(0),

    m_historyIndex(0),

    m_isActive(false)

{

    Q_ASSERT(m_pageManager);

    init();

}

HistoryViewPrivate::HistoryViewPrivate(WebPageController * pageMgr,

                                       QGraphicsWidget* parent) :

    m_flowInterface(0),

    m_widgetParent(0),

    m_graphicsWidgetParent(parent),

    m_pageManager(pageMgr),

    m_activePage(0),

    m_historyIndex(0),

    m_isActive(false)

{

    Q_ASSERT(m_pageManager);

    init();

}

HistoryViewPrivate::~HistoryViewPrivate()

{

    delete m_actionForward;

    delete m_actionBack;

    delete m_actionOK;

    delete m_actionCancel;

}

void HistoryViewPrivate::init()

{

    // create the view's actions

    m_actionForward = new QAction("Forward",m_widgetParent);

    m_actionForward->setObjectName("Forward");

    m_actionBack = new QAction("Back",m_widgetParent);

    m_actionBack->setObjectName("Back");

    m_actionOK = new QAction("OK",m_widgetParent);

    m_actionOK->setObjectName("OK");

    m_actionCancel = new QAction("Cancel",m_widgetParent);

    m_actionCancel->setObjectName("Cancel");

}

/*!

 * \class HistoryView

 *

 * \brief The base class for the HistoryViews

 *

 * This class provides the basic routines to enable history navigation.

 * Derived classes (such as HistoryFlowView, and HistoryLiteView) supply

 * the exact "FlowInterface" to be used, and rely on much of the base-class functionality

 * for signal/slots, extracting history items from the current page, etc.

 */

/*!

  Basic HistoryView constructor requires a PageManager to manage the pages

  and a parent QWidget

*/

HistoryView::HistoryView(WebPageController * pageMgr,

                         QWidget* parent) :

    d(new HistoryViewPrivate(pageMgr, parent))

{

}

/*!

  Basic HistoryView constructor requires a PageManager to manage the pages

  and a parent QGraphicsWidget

*/

HistoryView::HistoryView(WebPageController * pageMgr,

                         QGraphicsWidget* parent) :

    d(new HistoryViewPrivate(pageMgr, parent))

{

}

HistoryView::~HistoryView()

{

    delete d;

}

/*!

  Retrieve the WebPageController assigned to this view

*/

WebPageController* HistoryView::webPageController()

{

    return d->m_pageManager;

}

/*!

  Return the view's Forward QAction

  For scrolling the history view forwards

*/

QAction * HistoryView::getActionForward()

{

    return d->m_actionForward;

}

/*!

  Return the view's Back QAction

  For scrolling the history view backwards

*/

QAction * HistoryView::getActionBack()

{

    return d->m_actionBack;

}

/*!

  Return the view's OK QAction

  For invoking the view's OK

*/

QAction * HistoryView::getActionOK()

{

    return d->m_actionOK;

}

/*!

  Return the view's Cancel QAction

  For invoking the view's Cancel

*/

QAction * HistoryView::getActionCancel()

{

    return d->m_actionCancel;

}

/*!

  Return the widget handle of this view

*/

QGraphicsWidget* HistoryView::widget() const

{

    return d->m_flowInterface;

}

/*!

  Return the title of this view for display

*/

QString HistoryView::title() const

{

    return QString("History");

}

/*!

  Return whether this view is active or not

*/

bool HistoryView::isActive()

{

    return d->m_isActive;

}

/*!

  Return the list of public QActions most relevant to the view's current context

  (most approptiate for contextual menus, etc.

*/

QList<QAction*> HistoryView::getContext()

{

    // for now, all actions valid at all times

    // but there may be some logic here to determine context

    QList<QAction*> contextList;

    contextList <<

        d->m_actionForward <<

        d->m_actionBack <<

        d->m_actionOK <<

        d->m_actionCancel;

    return contextList;

}

/*!

  activate the view's resources. Could be connected by client to view visibility

*/

void HistoryView::activate()

{

    Q_ASSERT(!d->m_isActive);

    if(!d->m_flowInterface)

        return;

    d->m_flowInterface->init();

    updateHistory(true);

    // now forward visual flow lite's signals

    connect(d->m_flowInterface, SIGNAL(centerIndexChanged(int)), SIGNAL(centerIndexChanged(int)));

    connect(d->m_flowInterface, SIGNAL(ok(int)), this, SIGNAL(ok(int)));

    connect(d->m_flowInterface, SIGNAL(cancel()), this, SIGNAL(cancel()));

    // internally process the index change signal as well, and page load complete

    connect(d->m_flowInterface, SIGNAL(centerIndexChanged(int)), this, SLOT(updateActions(int)));

    connect(d->m_pageManager,SIGNAL(loadFinished(bool)),this,SLOT(updateHistory(bool)));

    // auto-link relevant actions to slots

    connect(d->m_actionForward, SIGNAL(triggered()), this, SLOT(forward()));

    connect(d->m_actionBack, SIGNAL(triggered()), this, SLOT(back()));

    widget()->installEventFilter(this);

    connect(this, SIGNAL(contextEvent(QObject *)), jsObject(), SLOT(onContextEvent(QObject *)));

    // show and set index

    d->m_flowInterface->show();

    d->m_historyIndex = 0;

    d->m_isActive = true;

    emit activated();

}

/*!

  deactivate the view's resources. Could be connected by client to view visibility

*/

void HistoryView::deactivate()

{

    Q_ASSERT(d->m_isActive);

    if(!d->m_flowInterface)

        return;

    // disconnect signals

    disconnect(d->m_flowInterface, SIGNAL(centerIndexChanged(int)), this, SIGNAL(centerIndexChanged(int)));

    disconnect(d->m_flowInterface, SIGNAL(ok(int)), this, SIGNAL(ok(int)));

    disconnect(d->m_flowInterface, SIGNAL(cancel()), this, SIGNAL(cancel()));

    // internally process the index change signal as well

    disconnect(d->m_flowInterface, SIGNAL(centerIndexChanged(int)), this, SLOT(updateActions(int)));

    disconnect(d->m_pageManager,SIGNAL(loadFinished(bool)),this,SLOT(updateHistory(bool)));

    // auto-link relevant actions to slots

    disconnect(d->m_actionForward, SIGNAL(triggered()), this, SLOT(forward()));

    disconnect(d->m_actionBack, SIGNAL(triggered()), this, SLOT(back()));

    widget()->removeEventFilter(this);

    disconnect(this, SIGNAL(contextEvent(QObject *)), jsObject(), SLOT(onContextEvent(QObject *)));

    // cleanup

    d->m_flowInterface->deleteLater();

    d->m_flowInterface = NULL;

    d->m_isActive = false;

    emit deactivated();

}

void HistoryView::updateHistory(bool status)

{

    if (!status) {

        return;

    }

    if (!d->m_flowInterface) {

        return;

    }

    // clear PictureFlow

    d->m_flowInterface->clear();

    d->m_activePage = d->m_pageManager->currentPage();

    if (d->m_activePage->history()->count() < 0) {

        return;

    }

    QWebHistoryItem item = d->m_activePage->history()->currentItem();

    d->m_activePage->savePageDataToHistoryItem(d->m_activePage->mainFrame(), &item);

    QList<QWebHistoryItem> items = d->m_activePage->history()->items();

    for (int i = 0; i < d->m_activePage->history()->count(); i++) {

        QWebHistoryItem item = items.at(i);

        WebPageData data = item.userData().value<WebPageData>();

    }

    int currentItemIndex(d->m_activePage->history()->currentItemIndex());

    d->m_flowInterface->setCenterIndex(currentItemIndex);

    updateActions(currentItemIndex);

}

int HistoryView::currentIndex() {

    return (d->m_activePage->history()->currentItemIndex());

}

/*!

  set the history view's center index

*/

void HistoryView::setCenterIndex(int index)

{

    // first emit center index change

    emit centerIndexChanged(index);

    d->m_historyIndex = index - d->m_activePage->history()->currentItemIndex();

    emit titleChanged(itemTitle(d->m_historyIndex));

    //if(d->m_flowInterface)

    //{

    //   qDebug() << "Setting center index " << index;

        //d->m_flowInterface->setCurentIndex(index);

    //}

}

/*!

  scroll forward in the history view

*/

void HistoryView::forward()

{

    if(!d->m_flowInterface)

        return;

    d->m_flowInterface->showNext();

}

/*!

  scroll back in the history view

*/

void HistoryView::back()

{

    if(!d->m_flowInterface)

        return;

    d->m_flowInterface->showPrevious();

}

void HistoryView::updateActions(int centerIndex)

{

    d->m_actionBack->setEnabled(centerIndex != 0);

    d->m_actionForward->setEnabled(centerIndex < (d->m_activePage->history()->count() - 1));

}

QRect HistoryView::centralRect()

{

    if(!d->m_flowInterface)

        return QRect();

    return d->m_flowInterface->centralRect();

}

bool HistoryView::eventFilter(QObject *obj, QEvent *event)

{

    if (event->type() == QEvent::ContextMenu && obj == widget()) {

        return handleWidgetContextMenuEvent(static_cast<QContextMenuEvent *>(event));

    }

    // standard event processing

    return ControllableViewBase::eventFilter(obj, event);

}

bool HistoryView::handleWidgetContextMenuEvent(QContextMenuEvent *event)

{

//        WRT::HistoryViewEventContext *context = 

//            new WRT::HistoryViewEventContext(type(), 

//                                             cmEvent->pos(), 

//                                             d->m_flowInterface->centerIndex(), 

//                                             itemTitle(d->m_flowInterface->centerIndex()));

    // Create a javascript-accessible object with properties containing the required info.

    QObject *context = new QObject();

    context->setObjectName("historyContextEvent");

    context->setProperty("viewType", type());

    context->setProperty("itemIndex", d->m_flowInterface->centerIndex());

    context->setProperty("itemTitle", itemTitle(d->m_flowInterface->centerIndex()));

    // Create an object representing the position of the event.  Make it a child of the context object

    // so it can be accessed from javascript.

    new ScriptPoint(context, event->pos(), "pos");

    // Pass ownership to the javascript engine.

    QWebFrame *chrome = chromeFrame();

    if(chrome) {

        chrome->addToJavaScriptWindowObject(context->objectName(), context, QScriptEngine::ScriptOwnership);

    }

    emit contextEvent(context);

    return true;

}

QString HistoryView::itemTitle(int index) const

{

    QWebHistoryItem item = d->m_activePage->history()->itemAt(d->m_flowInterface->centerIndex());

    QString title;

    if (item.isValid()) {

        title = item.title();

        if (title.isNull() || title.isEmpty()) {

            title = item.url().toString();

        }

    }

    return title;

}

// -------------------------------------------

HistoryViewJSObject::HistoryViewJSObject(HistoryView* view, QWebFrame* webFrame, const QString& objectName)

  : ControllableViewJSObject(view, webFrame, objectName)

{

    connect(view,SIGNAL(ok(int)),this,SLOT(ok(int)));

    connect(view,SIGNAL(cancel()),this,SLOT(cancel()));

    connect(view,SIGNAL(activated()),this,SIGNAL(activated()));

    connect(view,SIGNAL(deactivated()),this,SIGNAL(deactivated()));

}

HistoryViewJSObject::~HistoryViewJSObject()

{

    disconnect(static_cast<HistoryView*>(m_contentView),SIGNAL(ok(int)),this,SLOT(ok(int)));

    disconnect(static_cast<HistoryView*>(m_contentView),SIGNAL(cancel()),this,SLOT(cancel()));

    disconnect(static_cast<HistoryView*>(m_contentView),SIGNAL(activated()),this,SIGNAL(activated()));

    disconnect(static_cast<HistoryView*>(m_contentView),SIGNAL(deactivated()),this,SIGNAL(deactivated()));

}

void HistoryViewJSObject::ok(int item)

{

    emit done(item);

}

void HistoryViewJSObject::cancel()

{

    emit done(historyView()->currentIndex());

}

void HistoryViewJSObject::onContextEvent(QObject *context){

    emit contextEvent(context);

}

/*!

  \fn void HistoryView::centerIndexChanged(int index);

  emitted when the center index changed

*/

/*!

  \fn void HistoryView::ok(int item);

  emitted when the ok action has occured, contains history index at the time of close

*/

/*!

  \fn void HistoryView::cancel();

  emitted when the cancel action has occured

*/

} // namespace WRT