/*

 * 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: Menu collection state.

 *

 */

#include <qstatemachine.h>

#include <hbview.h>

#include <hbaction.h>

#include <hbabstractviewitem.h>

#include <hsmenueventfactory.h>

#include <hbmenu.h>

#include <hbinstance.h>

#include <hbsearchpanel.h>

#include "hsmenuevent.h"

#include "hsmenuservice.h"

#include "hsmenuitemmodel.h"

#include "hsmenuview.h"

#include "cadefs.h"

#include "caentry.h"

#include "hscollectionstate.h"

#include "hsaddappstocollectionstate.h"

#include "hsapp_defs.h"

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

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

//

HsCollectionState::HsCollectionState(HsMenuView &menuView, QState *parent) :

    QState(parent),

    mSortAttribute(LatestOnTopHsSortAttribute),

    mCollectionsSortAttribute(CustomHsSortAttribute),

    mCollectionId(-1), mMenuView(menuView),

    mCollectionModel(0), mOptions(0)

{

    construct();

}

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

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

//

void HsCollectionState::construct()

{

    HSMENUTEST_FUNC_ENTRY("HsCollectionState::construct");

    setObjectName(this->parent()->objectName() + "/collectionstate");

    //new action for backstepping

    mSecondarySoftkeyAction = new HbAction(Hb::BackAction, this);

    connect(this, SIGNAL(entered()),SLOT(stateEntered()));

    connect(this, SIGNAL(exited()),SLOT(stateExited()));

    HSMENUTEST_FUNC_EXIT("HsCollectionState::construct");

}

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

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

//

HsCollectionState::~HsCollectionState()

{

    delete mCollectionModel;

}

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

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

//

void HsCollectionState::onEntry(QEvent *event)

{

    qDebug("HsCollectionState::onEntry()");

    HSMENUTEST_FUNC_ENTRY("HsCollectionState::onEntry");

    QState::onEntry(event);

    if (event->type() == HsMenuEvent::eventType()) {

        HsMenuEvent *menuEvent = static_cast<HsMenuEvent *>(event);

        QVariantMap data = menuEvent->data();

        mCollectionId = data.value(itemIdKey()).toInt();

        mCollectionType = data.value(entryTypeNameKey()).toString();

    }

    HSMENUTEST_FUNC_EXIT("HsCollectionState::onEntry");

}

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

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

//

void HsCollectionState::stateEntered()

{

    HSMENUTEST_FUNC_ENTRY("HsCollectionState::stateEntered");

    if (!mCollectionModel) {

        mCollectionModel = HsMenuService::getCollectionModel(mCollectionId,

                           mSortAttribute, mCollectionType);

    } else {

        if (mCollectionType == collectionDownloadedTypeName()) {

            mCollectionModel->setFlagsOn(RemovableEntryFlag | VisibleEntryFlag);

        } else {

            mCollectionModel->setFlagsOn(VisibleEntryFlag);

        }

        mCollectionModel->setParentId(mCollectionId);

        mCollectionModel->setSort(

            LatestOnTopHsSortAttribute);

    }

    mMenuView.setModel(mCollectionModel);

    mMenuView.scrollTo(mCollectionModel->index(0),

                       HbAbstractItemView::PositionAtTop);

    mMenuView.setLabelVisible(true);

    mMenuView.setLabel(

        mCollectionModel->root().data(Qt::DisplayRole).toString());

    if (!mOptions) {

        mOptions = new HbMenu();

        EntryFlags flags =

            mCollectionModel->root().data(CaItemModel::FlagsRole).value<

            EntryFlags> ();

        if (flags & RemovableEntryFlag) {

            mOptions->addAction(hbTrId("txt_applib_opt_add_content"), this,

                                SLOT(addAppsAction()));

        }

        mOptions->addAction(hbTrId("txt_applib_opt_add_to_home_screen"),

                            this, SLOT(addCollectionShortcutToHomeScreenAction()));

        if (flags & RemovableEntryFlag) {

            mOptions->addAction(

                hbTrId("txt_common_opt_rename_item"),

                this,

                SLOT(renameAction()));

            mOptions->addAction(

                hbTrId("txt_common_opt_delete"),

                this,

                SLOT(deleteAction()));

        }

        if (mCollectionType == collectionDownloadedTypeName()) {

            HbMenu *sortMenu = mOptions->addMenu(

                                   hbTrId("txt_applib_opt_sort_by"));

            //Grouped options are exclusive by default.

            QActionGroup *sortGroup = new QActionGroup(mOptions);

            sortGroup->addAction(

                sortMenu->addAction(

                    hbTrId("txt_applib_opt_sort_by_sub_latest_on_top"),

                    this,

                    SLOT(latestOnTopMenuAction())));

            sortGroup->addAction(

                sortMenu->addAction(

                    hbTrId("txt_applib_opt_sort_by_sub_oldest_on_top"),

                    this,

                    SLOT(oldestOnTopMenuAction())));

            foreach(QAction *action, sortMenu->actions()) {

                action->setCheckable(true);

            }

            static const int defaultSortingPosition = 0;

            sortGroup->actions().at(defaultSortingPosition)->setChecked(true);

        }

        mOptions->setParent(this);

        mMenuView.view()->setMenu(mOptions);

    }

    makeConnect();

    HSMENUTEST_FUNC_EXIT("HsCollectionState::stateEntered");

}

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

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

//

void HsCollectionState::stateExited()

{

    HSMENUTEST_FUNC_ENTRY("HsCollectionState::stateExited");

    makeDisconnect();

    mOptions = NULL;

    mMenuView.view()->setMenu(NULL);

    mMenuView.setLabelVisible(false);

    HSMENUTEST_FUNC_EXIT("HsCollectionState::stateExited");

    qDebug("CollectionState::stateExited()");

}

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

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

//

void HsCollectionState::makeConnect()

{

    connect(mSecondarySoftkeyAction, SIGNAL(triggered()),

            SLOT(backSteppingAction()));

    connect(&mMenuView, SIGNAL(activated(QModelIndex)),

            SLOT(listItemActivated(QModelIndex)));

    connect(&mMenuView, SIGNAL(longPressed(HbAbstractViewItem *, QPointF)),

            SLOT(listItemLongPressed(HbAbstractViewItem *, QPointF)));

    connect(mCollectionModel, SIGNAL(modelReset()),SLOT(updateLabel()));

}

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

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

//

void HsCollectionState::makeDisconnect()

{

    disconnect(mSecondarySoftkeyAction, SIGNAL(triggered()),

               this, SLOT(backSteppingAction()));

    disconnect(mCollectionModel, SIGNAL(modelReset()),

               this, SLOT(updateLabel()));

    disconnect(&mMenuView, SIGNAL(activated(QModelIndex)),

               this, SLOT(listItemActivated(QModelIndex)));

    disconnect(&mMenuView, SIGNAL(longPressed(HbAbstractViewItem *, QPointF)),

               this, SLOT(listItemLongPressed(HbAbstractViewItem *, QPointF)));

}

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

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

//

void HsCollectionState::listItemActivated(const QModelIndex &index)

{

    HSMENUTEST_FUNC_ENTRY("HsCollectionState::listItemActivated");

    const CaEntry *entry = mCollectionModel->entry(index);

    if (entry->entryTypeName() == widgetTypeName()) {

        machine()->postEvent(

            HsMenuEventFactory::createPreviewHSWidgetEvent(

                entry->id(), entry->entryTypeName(), entry->attribute(

                    widgetUriAttributeName()), entry->attribute(

                    widgetLibraryAttributeName())));

        const int itemId = index.data(CaItemModel::IdRole).toInt();

        HsMenuService::touch(itemId);

    } else {

        QVariant data = mCollectionModel->data(index, CaItemModel::IdRole);

        HsMenuService::executeAction(data.toInt());

    }

    mMenuView.setSearchPanelVisible(false);

    HSMENUTEST_FUNC_EXIT("HsCollectionState::listItemActivated");

}

/*!

 Handles long-item-pressed event in all apps view by showing context menu

 \param item the event pertains to

 \param position at which context menu is shown

 \retval void

 */

void HsCollectionState::listItemLongPressed(HbAbstractViewItem *item,

        const QPointF &coords)

{

    Q_UNUSED(item);

    HSMENUTEST_FUNC_ENTRY("HsCollectionState::listItemLongPressed");

    mMenuView.setSearchPanelVisible(false);

    int itemId = item->modelIndex().data(CaItemModel::IdRole).toInt();

    // create context menu

    HbMenu *menu = new HbMenu();

    HbAction *addShortcutAction = menu->addAction(hbTrId(

                                      "txt_applib_menu_add_to_home_screen"));

    HbAction *addToCollection = menu->addAction(hbTrId(

                                    "txt_applib_menu_add_to_collection"));

    HbAction *removeAction(NULL);

    HbAction *uninstallAction(NULL);

    // we do not add remove option in collection download menu

    // check conditions and hide irrelevant menu items

    if (mCollectionType != collectionDownloadedTypeName()) {

        removeAction = menu->addAction(

                           hbTrId("txt_applib_menu_remove_from_collection"));

    }

    EntryFlags flags = item->modelIndex().data(CaItemModel::FlagsRole).value<

                       EntryFlags> ();

    if ((flags & RemovableEntryFlag)) {

        uninstallAction = menu->addAction(hbTrId("txt_common_menu_delete"));

    }

    // choose proper action

    if (HbAction *selectedAction = menu->exec(coords)) {

        if (selectedAction == addShortcutAction) {

            addElementToHomeScreen(item->modelIndex());

        } else if (selectedAction == addToCollection) {

            machine()->postEvent(

                HsMenuEventFactory::createAddAppsFromCallectionViewEvent(

                    mCollectionId, itemId, mCollectionsSortAttribute));

        } else if (selectedAction == uninstallAction) {

            HsMenuService::executeAction(itemId, removeActionIdentifier());

        } else if (selectedAction == removeAction) {

            machine()->postEvent(

                HsMenuEventFactory::createRemoveAppFromCollectionEvent(

                    itemId, mCollectionId));

        }

    }

    delete menu;

    HSMENUTEST_FUNC_EXIT("HsCollectionState::listItemLongPressed");

}

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

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

//

void HsCollectionState::addAppsAction()

{

    // Add applications

    machine()->postEvent(

        HsMenuEventFactory::createAddAppsFromCallectionViewEvent(

            mCollectionId));

}

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

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

//

void HsCollectionState::addCollectionShortcutToHomeScreenAction()

{

    machine()->postEvent(HsMenuEventFactory::createAddToHomeScreenEvent(

                             mCollectionId));

}

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

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

//

void HsCollectionState::renameAction()

{

    machine()->postEvent(HsMenuEventFactory::createRenameCollectionEvent(

                             mCollectionId));

}

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

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

//

void HsCollectionState::deleteAction()

{

    machine()->postEvent(HsMenuEventFactory::createDeleteCollectionEvent(

                             mCollectionId));

}

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

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

//

void HsCollectionState::backSteppingAction()

{

    machine()->postEvent(HsMenuEventFactory::createOpenAppLibraryEvent());

}

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

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

//

void HsCollectionState::updateLabel()

{

    HSMENUTEST_FUNC_ENTRY("HsCollectionState::updateLabel");

    if (mCollectionModel) {

        mMenuView.setLabel(

            mCollectionModel->root().data(Qt::DisplayRole).toString());

    }

    HSMENUTEST_FUNC_EXIT("HsCollectionState::updateLabel");

}

/*!

  Triggers event so that a state adding to Home Screen is reached

  \param index of an item to be added to homescreen

  \retval void

 */

void HsCollectionState::addElementToHomeScreen(const QModelIndex &index)

{

    const CaEntry *entry = mCollectionModel->entry(index);

        HsMenuEventFactory::createAddToHomeScreenEvent(

            entry->id(),

            entry->entryTypeName(),

            entry->attribute(widgetUriAttributeName()),

}

/*!

  A Slot called when an action for sorting (latest

  on top) is invoked for Downloaded collection.

 */

void HsCollectionState::latestOnTopMenuAction()

{

    mSortAttribute = LatestOnTopHsSortAttribute;

    mCollectionModel->setSort(mSortAttribute);

    emit sortOrderChanged(mSortAttribute);

}

/*!

  A Slot called when an action for sorting (oldest

  on top) is invoked for Downloaded collection.

 */

void HsCollectionState::oldestOnTopMenuAction()

{

    mSortAttribute = OldestOnTopHsSortAttribute;

    mCollectionModel->setSort(mSortAttribute);

    emit sortOrderChanged(mSortAttribute);

}

/*!

  Slot for setting all collections sort order

  \param sortOrder all collections sort order

 */

void HsCollectionState::collectionsSortOrder(

    HsSortAttribute sortOrder)

{

    mCollectionsSortAttribute = sortOrder;

}

/*!

  \fn void HsCollectionState::sortOrderChanged(SHsSortAttribute sortOrder);

  This signal is emitted when sort order is changed to \a sortOrder.

 */