/*

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

* All rights reserved.

*

*

*

*

*/

#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 <QFile>

#include <QDir>

#include <QtGui>

#include <QCoreApplication>

#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)

      {	

  	  }

  	  donotsaveFlag = true;

    }

/*    #if defined(Q_OS_SYMBIAN)

    // clean up all pages

    while ( !m_allPages.isEmpty() )

        q->closePage(m_allPages.at(0));

    Q_ASSERT ( m_allPages.isEmpty() );

    #endif*/

//    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 ),

{

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

    qRegisterMetaTypeStreamOperators<WebPageData> ("WebPageData");

    // 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() ) );

    updateJSActions();

    m_bRestoreSession = false;

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

    if (enabled) m_bRestoreSession = true;

}

WebPageController::~WebPageController()

{

    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"));

        /* 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 );

        // 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();

        	startupRestoreHistory(NULL, index+1, page);

    }

    return page;

}

{

	WRT::WrtBrowserContainer* page = NULL;

	page = openPage(this, 0);

	page->setPageFactory(this);

	return page;

}

{

    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;

        if(closeIndex == 0 ) {

            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;

            emit pageChanged(page, NULL);

        }

    }

    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*)));

    }

    // 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, SIGNAL( loadProgress(int) ), SIGNAL( loadProgress(int) ) );

    connect( page->mainFrame(), SIGNAL( iconChanged() ), SIGNAL( pageIconChanged() ) );

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

    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(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 );

}

/*!

 * Retrieve a pointer to the current WRT::WrtBrowserContainer

 * @return    Returns current page handle

 * @see WRT::WrtBrowserContainer

 */

WRT::WrtBrowserContainer* WebPageController::currentPage() const

{

    if ( d->m_currentPage >= 0 && d->m_currentPage < d->m_allPages.count() )

        return d->m_allPages.at ( d->m_currentPage );

    else

        return NULL;

}

/*!

 * Retrieve a list of all of the pages managed by WebPageController

 * @return   List of all the pages opened by WebPageController

 * @see WRT::WrtBrowserContainer

 */

QList<WRT::WrtBrowserContainer*>* WebPageController::allPages()

{

    return &d->m_allPages;

}

/*! 

 * Retrieve the number of pages managed by WebPageController

 */