/*

* 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 <assert.h>

#include "actionjsobject.h"

#include "webpagedata.h"

#include "wrtbrowsercontainer.h"

#include "wrtbrowsercontainer_p.h"

#include "webpagecontroller_p.h"

#include "webpagecontroller.h"

#include "UiUtil.h"

#include "bedrockprovisioning.h"

#include "secureuicontroller.h"

#include "LoadController.h"

#include "ContentAgent.h"

#include "lowmemoryhandler.h"

#include <QWebFrame>

#include <QWebHistory>

#include <QGraphicsWebView>

#include <QFile>

#include <QDir>

#include <QtGui>

#include <QCoreApplication>

#include <QWebSecurityOrigin>

#include <QWebDatabase>

#include <QWebSettings>

#include <QtCore/QSettings>

using namespace WRT;

#if defined(Q_OS_SYMBIAN) // for shareToMail

#include <miutset.h>                

#include <sendui.h>      

#include <cmessagedata.h> 

#include <txtrich.h>   

#include <SendUiConsts.h>

const TUid KShareOnline = { 0x200009D5 }; 

const TUid KShareOnOvi = { 0x2001AA43 }; 

#endif 

#define MAX_NUM_WINDOWS_TO_RESTORE 5

#define MAX_NUM_WINDOWS 5

static const char KHISTORYEXTENSION[]       = ".history";

WebPageControllerPrivate::WebPageControllerPrivate(WebPageController* qq) :

    q(qq),

    m_widgetParent(0),

    m_currentPage(-1),

    m_secContext(0),

    m_actionsParent(0),

    donotsaveFlag(false)

{

    m_widgetParent = static_cast<QObject*>(qq); //new QWidget();

    // create the manager's actions

    m_actionReload = new QAction("Reload",m_widgetParent);

    m_actionReload->setObjectName("reload");

    m_actionStop = new QAction("Stop",m_widgetParent);

    m_actionStop->setObjectName("stop");

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

    m_actionBack->setObjectName("back");

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

    m_actionForward->setObjectName("forward");

    m_actionReload->setEnabled(false);

    m_actionStop->setEnabled(false);

    m_actionBack->setEnabled(false);

    m_actionForward->setEnabled(false);

}

WebPageControllerPrivate::~WebPageControllerPrivate()

{

    // save history in the persistent storage, delete history files first

    bool enabled = (bool) BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->valueAsInt("SaveSession");

    if (enabled)

    {

      q->deleteHistory();

      if(donotsaveFlag == false)

      {	

        int windowsSaved = 0;

        int activeWindowId = 0;

    	  q->saveHistory(&windowsSaved, &activeWindowId);

    	  q->saveNumberOfWindows(windowsSaved);    

        q->saveActiveWindowId(activeWindowId);

  	  }

  	  donotsaveFlag = true;

    }

    else

    {

    	q->deleteDataFiles();

    }

    // clean up all pages

    while ( !m_allPages.isEmpty() )

    Q_ASSERT ( m_allPages.isEmpty() );

//    delete(m_widgetParent);

}

/*!

 * \class WebPageController

 *

 * \brief Manages WrtPages

 *

 * This class is responsible for managing multiple WrtPages.

 * All page management operations go through this class, such as opening a page,

 * managing multiple pages, choosing what the current page among several is,

 * closing a page, etc.

 *

 * Multiple views may well have access to a WebPageManager

 *

 * For most cases, we expect there to be a single instance of WebPageController for a given

 * application, but it is up to the application to specify the instance used.

 *

 * This class is supposed to abstract page events, control into a simple interface

 * so that higher-level functions need not know or care about what the active page is, etc.

 */

WebPageController::WebPageController ( QObject* parent ) :

    QObject ( parent ),

    m_networkError (false),

    m_networkErrorMsg("No network error"),           

    m_networkErrorUrl("No Url"),

    m_bErrorUrlMatches(false),

    m_promptMsg("No message"),           

    m_promptReserved(""),

    m_memoryHandler(new LowMemoryHandler(this)),

    d(new WebPageControllerPrivate(this)),

    m_settingsLoaded(0)

{

    // Register a new MetaType WebPageData. It is needed to serialize history (starage)

    qRegisterMetaTypeStreamOperators<WebPageData> ("WebPageData");

    d->m_historyDir = BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->valueAsString("DataBaseDirectory");

    // auto-connect actions

    connect( d->m_actionReload, SIGNAL( triggered() ), this, SLOT( currentReload() ) );

    connect( d->m_actionStop, SIGNAL( triggered() ), this, SLOT( currentStop() ) );

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

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

    connect( m_memoryHandler, SIGNAL( lowMemory() ), this, SIGNAL( lowMemory() ) );

    connect( m_memoryHandler, SIGNAL( lowMemory() ), this, SLOT( handleLowMemory() ) );

    connect( m_memoryHandler, SIGNAL( outOfMemory() ), this, SIGNAL( outOfMemory() ) );

    connect( m_memoryHandler, SIGNAL( outOfMemory() ), this, SLOT( handleOutOfMemory() ) );

    m_memoryHandler->start();

    updateJSActions();

    m_bRestoreSession = false;

    bool enabled = (bool) BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->valueAsInt("SaveSession");

    if (enabled) m_bRestoreSession = true;

}

WebPageController::~WebPageController()

{

    m_memoryHandler->stop();

    delete d;

}

/*!

 * Open an empty WRT::WrtBrowserContainer

 * @param parent  Widget Parent

 * @return        WRT::WrtBrowserContainer Handle

 * @see WRT::WrtBrowserContainer                      

 */

WRT::WrtBrowserContainer* WebPageController::openPage(QObject* parent, WRT::WrtBrowserContainer* pg)

{

    WRT::WrtBrowserContainer* page =  currentPage();

    if (  d->m_allPages.count() < MAX_NUM_WINDOWS ) {

        // create without parent

        page = WRT::WrtBrowserContainer::createPageWithWidgetParent(parent, pg);

        // emit signal for creating network connection.

        Q_ASSERT( page );

        page->settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, (bool) BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->valueAsInt("DeveloperExtras"));

        connect( page, SIGNAL( loadFinished(bool) ), SLOT( onLoadFinishedForBackgroundWindow(bool) ) );

        // emit signal indicating that new page is being created

        emit creatingPage( page );

        /* Add the new page after the current page */

        WRT::WrtBrowserContainer * theCurrentPage = currentPage();

        int index = d->m_allPages.indexOf(theCurrentPage);

        d->m_allPages.insert (index+1, page );

  // set the max number of pages to hold in the memory page cache to pages

  // The Page Cache allows for a nicer user experience when navigating forth or back to pages in 

  // the forward/back history, by pausing and resuming up to pages per page group

		int maxPagesInCache = BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->valueAsInt("MaxPagesInCache");

        page->settings()->setMaximumPagesInCache(maxPagesInCache);

        // emit signal

        emit pageCreated( page );

        // AUTO-activate this page ONLY if there are no other pages

        if(d->m_allPages.size() == 1) {

            setCurrentPage(page);

        }

        int count = historyWindowCount();

        int activeWinId = activeWindowId();

        if (m_bRestoreSession)

        	startupRestoreHistory(NULL, index+1, page);

    }

    return page;

}

WRT::WrtBrowserContainer* WebPageController::openPage()

{

	WRT::WrtBrowserContainer* page = NULL;

	page = openPage(this, 0);

	page->setPageFactory(this);

	return page;

}

WRT::WrtBrowserContainer* WebPageController::openPageFromHistory(int index)

{

    QDir dir(d->m_historyDir);

    QFileInfoList fileList(dir.entryInfoList(QDir::Files));

    QString indexStr;

    indexStr.setNum(index);

    QString historyFile = d->m_historyDir + QLatin1String("/history") + indexStr + QLatin1String(".history");

    QFile file(historyFile);    

    if(file.open(QIODevice::ReadOnly)) 

    {

    	  if(file.size() <= 12) // empty file

    	  {	

        	file.remove();

        	file.close();

        	return NULL;

        }

        else

        	return openPage();

    }    

    else // can not open file

    	return NULL;   

}

/*!

 * Given a WRT::WrtBrowserContainer instance, close it

 * @param page   WRT::WrtBrowserContainer instance to be closed 

 * @see  WRT::WrtBrowserContainer

 */

void WebPageController::closePage ( WRT::WrtBrowserContainer *page )

{

        WRT::WrtBrowserContainer * theCurrentPage = currentPage();

        bool updateCurrentPageIndex = false;

        // get index of page we want to remove

        int closeIndex = d->m_allPages.indexOf(page);

        if(closeIndex < 0)

            return;

        // was this page the "current page?"

        // if so, we need to select the page to become the new one

        // select the previous page unless at the beginning, then select next

        if(page == theCurrentPage) {

            int newCurrIndex = closeIndex - 1;

                newCurrIndex = closeIndex + 1;

            }

            // change the current page

            if(newCurrIndex >= 0) {

                theCurrentPage = d->m_allPages.at(newCurrIndex);

                setCurrentPage(theCurrentPage);

                updateCurrentPageIndex = true;

            }

            else {

                d->m_currentPage = -1;

            }

        }

        else {

             /* Adjust m_currentPage if the index of the page deleted is less than 

             * current page 

             */

           if (closeIndex < d->m_currentPage ) 

               updateCurrentPageIndex = true;

        }

        // actually delete the page from the list

        d->m_allPages.removeAt(closeIndex);

        // update the current page index if necessary

        // (this will just update the index now that we've removed the page from the list)

        if(updateCurrentPageIndex) {

            int index = d->m_allPages.indexOf(theCurrentPage);

            if(index >= 0)

                d->m_currentPage = index;

        }

        // and emit sig that it was done

        emit pageDeleted(page);

        delete page;

}

/*!

 *  Activate the given page as the current page

 *  @param page   page handle for setting current page

 *  @see  WRT::WrtBrowserContainer

 */

void WebPageController::setCurrentPage(WRT::WrtBrowserContainer* page)

{

    // verify page

    Q_ASSERT(page);

    int index = d->m_allPages.indexOf(page);

    if(index < 0)

        return;

    // fetch current page (if any)

    WRT::WrtBrowserContainer * oldPage = currentPage();

    // update the index of the current page

    // (even if the page hasn't changed, it's index might have)

    d->m_currentPage = index;

    // do not proceed any further if setting to the same page

    if(page == oldPage)

       return;

    // disconnect any existing aggregate signalling for pgMgr

    if(oldPage) {

        disconnect(oldPage, 0, this, 0);

        disconnect(oldPage->mainFrame(), 0, this, 0);

        disconnect(oldPage->networkAccessManager(), 0, this, 0);

        disconnect(oldPage->loadController(), 0, this, 0);

        connect(oldPage, SIGNAL(createNewWindow(WrtBrowserContainer*)), this, SLOT(createWindow(WrtBrowserContainer*)));

        connect(oldPage, SIGNAL(loadFinished(bool)), SLOT(onLoadFinishedForBackgroundWindow(bool)));

    }

    // aggregate "current page" signalling from this page to PageMgr clients

    connect(page, SIGNAL(secureStateChange(int)), this, SLOT(secureStateChange(int)));

    connect( page->mainFrame(), SIGNAL ( titleChanged ( const QString& ) ), SIGNAL ( titleChanged ( const QString& ) ) );

    connect( page, SIGNAL( loadStarted() ), SIGNAL( loadStarted() ) );

    connect( page->mainFrame(), SIGNAL(initialLayoutCompleted() ), SIGNAL( initialLayoutCompleted() ) );

    connect( page, SIGNAL( loadProgress(int) ), SIGNAL( loadProgress(int) ) );

    connect( page, SIGNAL( loadFinished(bool) ), SLOT( onLoadFinished(bool) ) );

    connect( page, SIGNAL( databaseQuotaExceeded (QWebFrame *,QString) ), SLOT( onDatabaseQuotaExceeded (QWebFrame *,QString)) );  

    connect( page->loadController(), SIGNAL( pageLoadStarted() ), SIGNAL( pageLoadStarted() ) );

    connect( page->loadController(), SIGNAL( pageLoadFailed() ), SIGNAL( pageLoadFailed() ) );

    connect( page->loadController(), SIGNAL( pageLoadProgress(int) ), SIGNAL( pageLoadProgress(int) ) );

    connect( page->loadController(), SIGNAL( pageLoadFinished(bool) ), SIGNAL( pageLoadFinished(bool) ) );

    connect( page->loadController(), SIGNAL( pageUrlChanged(QString) ), SIGNAL( pageUrlChanged(QString) ) );

    connect( page, SIGNAL(createNewWindow(WrtBrowserContainer*)), this, SLOT(createWindow(WrtBrowserContainer*)));

    // Connect the unsuportedContent signal to start a new download

    connect( page, SIGNAL(unsupportedContent(QNetworkReply *)), this, SLOT(unsupportedContentArrived(QNetworkReply *)));

    connect( page, SIGNAL( loadStarted() ), SLOT( updateStatePageLoading() ) );

    connect( page->mainFrame(), SIGNAL( iconChanged() ), this, SIGNAL( currentPageIconChanged() ) );

    connect( page->mainFrame(), SIGNAL( urlChanged( const QUrl &)), this, SIGNAL( currentPageUrlChanged( const QUrl &) ));

    connect( page->mainFrame(), SIGNAL( urlChanged( const QUrl &)), this, SLOT( urlChanged( const QUrl &) ));

    connect( page->networkAccessManager(), SIGNAL(sslErrors(QNetworkReply *, const QList<QSslError> &)), this, SIGNAL( sslErrors(QNetworkReply *, const QList<QSslError> &)));

    connect( page->networkAccessManager(), SIGNAL(showMessageBox(WRT::MessageBoxProxy*)), this, SIGNAL(showMessageBox(WRT::MessageBoxProxy*)));

	// Connect network reply errors 

    connect( page->networkAccessManager(), SIGNAL( networkErrorHappened(const QString &) ), this, SIGNAL( networkErrorHappened(const QString &) ) );

    connect( page->networkAccessManager(), SIGNAL( networkErrorHappened(const QString &) ), this, SLOT( processNetworkErrorHappened(const QString &) ) );

    connect( page->networkAccessManager(), SIGNAL( networkErrorUrl(const QUrl &) ), this, SLOT( processNetworkErrorUrl(const QUrl &) ) );

    connect(currentPage(), SIGNAL(pageScrollPositionZero()), this, SIGNAL(pageScrollPositionZero()) );

    connect(page, SIGNAL(scrollRequested(int, int, const QRect & )), this, SIGNAL(pageScrollRequested(int, int, const QRect & )) );

    Q_ASSERT ( d->m_currentPage >= 0 );

    updateActions(false);

    emit pageChanged( oldPage, page );

}

void WebPageController::onLoadFinished(bool ok)

{

    updateStatePageLoadComplete(ok);

    if (ok) {

        QTimer::singleShot(300, this, SLOT(updateHistory()));

    }

    else {

        emit(loadFinished(false));

    }

}

void WebPageController::onDatabaseQuotaExceeded (QWebFrame *frame, QString database)  

{

  QDir dir(dbdir);

  if(!dir.exists()||(dir.count() <= 1)) // empty DB

  	return;

	if(frame)

	{

		QWebSecurityOrigin qwso = frame->securityOrigin();

		qint64 quota = qwso.databaseQuota() ;

		qint64 usage = qwso.databaseUsage() ;		

	}

	emit databaseQuotaExceeded (frame, database);

	return;

}

void WebPageController::onLoadFinishedForBackgroundWindow(bool ok)

{

    if (!ok)

        return;

    WRT::WrtBrowserContainer* page = qobject_cast<WRT::WrtBrowserContainer*> (sender());

    if (page){

        page->setUpdateThumbnail(true);

        // Current page is handled in onLoadFinished() so skip this case here

        if(page != currentPage()){

			emit (loadFinishedForBackgroundWindow(true,page));

        }

	}

}

void WebPageController::updateHistory()

{

    emit(loadFinished(true));

}

/*!

 * Handling of network error happens signal 

 * @return    Returns current page handle

 * @see WRT::WrtBrowserContainer

 */ 

void WebPageController::processNetworkErrorHappened(const QString & msg )

    {

    m_networkError = true;

    m_networkErrorMsg = msg; 

    }

/*!

 * Handling of network error associated url

 * @return    Returns current page handle

 * @see WRT::WrtBrowserContainer

 */

void WebPageController::processNetworkErrorUrl(const QUrl & url )

    {

    QString errorUrl = url.toString();