/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/

#include <QPainter>
#include <QGraphicsLinearLayout>
#include <HbInstance>

#include "hspage.h"
#include "hsscene.h"
#include "hsdatabase.h"
#include "hswidgethost.h"
#include "hswidgetdata.h"
#include "hswidgetpresentationdata.h"
#include "hspagedata.h"
#include "hswallpaper.h"
#include "hswidgetpositioningonwidgetadd.h"


/*!
    \class HsPage
    \ingroup group_hsutils
    \brief Represents a page in the framework.
    HsPage is a parent for a group of widgets. HsPage can have a wallpaper.
*/

/*!
    Constructor.

    \a parent Owner.
    \a aFlags Window flags.
*/
HsPage::HsPage(QGraphicsItem* parent)
    : HbWidget(parent),
      mDatabaseId(-1),
      mRemovable(true)
{
    setFlag(QGraphicsItem::ItemHasNoContents);
    setSizePolicy(QSizePolicy(QSizePolicy::Ignored, 
                              QSizePolicy::Ignored));
}

/*!
    Destructor.
*/
HsPage::~HsPage()
{
}

/*!
    Returns the database id.
*/
int HsPage::databaseId() const
{
    return mDatabaseId;
}
 
/*!
    Sets the database id to \a id.
*/
void HsPage::setDatabaseId(int id)
{
    mDatabaseId = id;
}

/*!
    Loads widgets.
*/
bool HsPage::load()
{
    HsDatabase *db = HsDatabase::instance();
    Q_ASSERT(db);

    HsPageData pageData;
    if (!db->page(mDatabaseId, pageData, true)) {
        return false;
    }

    QList<HsWidgetData> widgetDatas = pageData.widgets();
    foreach (HsWidgetData widgetData, widgetDatas) {
        HsWidgetHost *widget = new HsWidgetHost(widgetData.id());
        connectWidget(widget);
        widget->load();

		if (!widget->isValid()) {
			qDebug() << "HsPage: Widget loading failed.";
			continue;
		}

        widget->setPage(this);
        mWidgets << widget;
    }

    foreach (HsWidgetHost *widget, mWidgets) {
        widget->initializeWidget();
        widget->showWidget();
        widget->setParentItem(this);
    }
    
    return true;    
}

bool HsPage::addExistingWidget(HsWidgetHost *widgetHost)
{
    if (!widgetHost) {
        return false;
    }
    
    if (mWidgets.contains(widgetHost)) {
        return true;
    }

    if (!widgetHost->setPage(this)) {
        return false;
    }

    connectWidget(widgetHost);
    mWidgets << widgetHost;
    widgetHost->setParentItem(this);
    
    return true;
 }

bool HsPage::removeWidget(HsWidgetHost *widgetHost)
{
    if (!widgetHost || !widgetHost->setPage(0)) {
        return false;
    }

    disconnectWidget(widgetHost);
    mWidgets.removeOne(widgetHost);
    widgetHost->setParentItem(0);

    return true;
}

QList<HsWidgetHost *> HsPage::newWidgets()
{
    return mNewWidgets;
}

/*!
    Adds new widget into a page. Returns true if successfull. 
*/
bool HsPage::addNewWidget(HsWidgetHost* widgetHost)
{
    if (!widgetHost || mWidgets.contains(widgetHost)) {
        return false;
    }

    if (mNewWidgets.contains(widgetHost)) {
        return true;
    }
    
    // Set presentation.
    QString key = HsScene::orientation() == Qt::Horizontal ? 
        "landscape" : "portrait";

    HsWidgetPresentationData presentation;
    if (!widgetHost->widgetPresentationData(key, presentation)) {
        presentation.setKey(key);
        presentation.setPosition(QPointF());
        presentation.setSize(widgetHost->preferredSize());
        presentation.setZValue(0);       
        widgetHost->setWidgetPresentationData(presentation);
    }

    widgetHost->hide();
    widgetHost->setGeometry(QRectF(presentation.position(), 
                                   presentation.size()));
    widgetHost->setZValue(presentation.zValue());   
    
    connectWidget(widgetHost);
    mNewWidgets << widgetHost;

    return true;
}

/*!
    Layouts all the new widgets
*/
void HsPage::layoutNewWidgets()
{
    QList<QRectF> oldWidgetGeometries;

    foreach(HsWidgetHost *widget, mNewWidgets) {
        oldWidgetGeometries << widget->rect();
    }

    QList<QRectF> newWidgetGeometries = 
        HsWidgetPositioningOnWidgetAdd::instance()->convert(
        rect().adjusted(10, 10, -10, -10),
        oldWidgetGeometries);

    updateZValues();

    HsWidgetHost *widget = NULL;
    for(int i = 0; i < mNewWidgets.count(); ++i) {  
        widget = mNewWidgets[i];
        widget->setGeometry(newWidgetGeometries[i]);
        widget->setWidgetPresentation();
        widget->setPage(this);
        widget->setParentItem(this);
        widget->show();
        mWidgets << widget;
    }
}

/*!
    Resets the new widgets list
*/
void HsPage::resetNewWidgets()
{
    mNewWidgets.clear();
}

bool HsPage::deleteFromDatabase()
{
    HsDatabase *db = HsDatabase::instance();
    Q_ASSERT(db);

    db->transaction();

    foreach (HsWidgetHost *widget, mWidgets) {
        if (!widget->deleteFromDatabase()) {
            db->rollback();
            return false;
        }
    }

    if (!db->deletePage(mDatabaseId))  {
        db->rollback();
        return false;
    }

    db->commit();
    return true;
}

QList<HsWidgetHost *> HsPage::widgets() const
{
    return mWidgets;
}

/*!
    Returns true if the page can be removed. Otherwise,
    returns false.
*/
bool HsPage::isRemovable() const
{
    return mRemovable; 
}

/*!
    Sets removable flag to \a removable.
*/
void HsPage::setRemovable(bool removable)
{
    mRemovable = removable; 
}

bool HsPage::updateZValues()
{
    if (mWidgets.isEmpty()) {
        return true;
    }
    
    QMultiMap<qreal, HsWidgetHost *> map;
    foreach (HsWidgetHost *widget, mWidgets) {
        map.insert(widget->zValue(), widget);
    }
    
    QList<HsWidgetHost *> sortedWidgets = map.values();
            
    HsWidgetHost *activeWidget = HsScene::instance()->activeWidget();    
    if (sortedWidgets.contains(activeWidget)) {
        sortedWidgets.removeOne(activeWidget);
        sortedWidgets.append(activeWidget);        
    }

    int z = 0;
    foreach (HsWidgetHost *widget, sortedWidgets) {
        widget->setZValue(z++);
        widget->setWidgetPresentation();
    }

    foreach (HsWidgetHost *widget, mNewWidgets) {
        widget->setZValue(z++);
        widget->setWidgetPresentation();
    }

    return true;
}
/*!
    Propogate online state to widgets.

*/
void HsPage::setOnline(bool online)
{
    foreach (HsWidgetHost *widget, mNewWidgets) {
        widget->setOnline(online);
    }
    foreach (HsWidgetHost *widget, mWidgets) {
        widget->setOnline(online);
    }
}

HsPage *HsPage::createInstance(const HsPageData &pageData)
{
    HsDatabase *db = HsDatabase::instance();
    Q_ASSERT(db);
    
    HsPageData data(pageData);    
    if (!db->insertPage(data)) {
        return 0;
    }

    HsPage *page = new HsPage;
    page->setDatabaseId(data.id());
    return page;
}

void HsPage::connectWidget(HsWidgetHost *widget)
{
    connect(widget, SIGNAL(widgetFinished(HsWidgetHost*)),
            SLOT(onWidgetFinished(HsWidgetHost*)));
}
 
void HsPage::disconnectWidget(HsWidgetHost *widget)
{
    widget->disconnect(this);
}

void HsPage::onWidgetFinished(HsWidgetHost *widget)
{
    if (mNewWidgets.contains(widget)) {
        mNewWidgets.removeOne(widget);
    } else if (mWidgets.contains(widget)) {
        mWidgets.removeOne(widget);        
    } else {
        return;
    }

    disconnectWidget(widget);
    widget->uninitializeWidget();
    widget->deleteFromDatabase();
    widget->deleteLater();
}