/*

 * 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:  Implementation of the progressive search state.

 *

 */

#include "searchprogressivestate.h"

#include "indevicehandler.h"

#include "searchuiloader.h"

#include <cpixdocument.h>

#include <cpixdocumentfield.h>

#include <hbmainwindow.h>

#include <hbview.h>

#include <hblabel.h>

#include <hbicon.h>

#include <hbmenu.h>

#include <hbinstance.h>

#include <hbsearchpanel.h>

#include <hbaction.h>

#include <hbapplication.h>

#include <qsortfilterproxymodel.h>

#include <AknsUtils.h>

#include <bitdev.h> 

#include <bitstd.h>

#include <qbitmap.h>

#include <fbs.h>

#include <AknInternalIconUtils.h>

#include <AknIconUtils.h> 

#include <apaidpartner.h>

#include <qpluginloader.h>

#include <eventviewerplugininterface.h>

#include <noteseditorinterface.h>

#include <w32std.h>

#include <apgtask.h>

#include <apgcli.h>

#include <AknTaskList.h>

#include <apacmdln.h>

#include <xqconversions.h>

#include <apparc.h>

#include <qdesktopservices.h>

#include <hblistwidget.h>

#include <hblistwidgetitem.h>

#include <hbabstractviewitem.h>

#include <hblistviewitem.h>

#include <hbactivitymanager.h>

#include <xqaiwdecl.h>

#include <qservicemanager.h>

#include <qurl.h>

QTM_USE_NAMESPACE

#define hbApp qobject_cast<HbApplication*>(qApp)

const int totalcategories_normalreason = 10;

const int totalcategories_activityreasonreason = 13;

const int intial_iteration = 3;

const int batch_iteration = 20;

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

// SearchProgressiveState::SearchProgressiveState

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

SearchProgressiveState::SearchProgressiveState(QState *parent) :

    QState(parent), mMainWindow(NULL), mView(NULL), mListView(NULL),

            mSearchHandler(NULL), mNotesEditor(0), mAiwMgr(0), mRequest(0)

    {

    mUiLoader = SearchUiLoader::instance();

    mMainWindow = hbInstance->allMainWindows().at(0);

    mAiwMgr = new XQApplicationManager;

    mView = mUiLoader->View();

    mListView = mUiLoader->ListWidget();

    mSearchPanel = mUiLoader->SearchPanel();

    HbStyle style;

    qreal x;

    style.parameter("hb-param-graphic-size-primary-large", x);

    QSizeF size(x, x);

    mListViewIconSize = size.toSize();

    if (mSearchPanel)

        {

        mSearchPanel->setPlaceholderText(hbTrId(

                "txt_search_dialog_search_device"));

        mSearchPanel->setFocus();

        }

    constructHandlers();

    if (mView && mMainWindow)

        {

        mMainWindow->addView(mView);

        mMainWindow->setCurrentView(mView);

        }

    mDatabasecount = 0;

    mLinkindex = 0;

    mResultcount = 0;

    mResultparser = 0;

    loadSettings = true;

    if (hbApp)

        {

        connect(hbApp->activityManager(), SIGNAL(activityRequested(QString)),

                this, SLOT(activityRequested(QString)));

        }

#ifdef OST_TRACE_COMPILER_IN_USE 

    //start() the timers to avoid worrying abt having to start()/restart() later

    m_categorySearchApiTime.start();

    m_categorySearchUiTime.start();

    m_totalSearchUiTime.start();

    m_categoryGetDocumentApiTime.start();

    m_getDocumentCatergoryTimeAccumulator = 0;

#endif

    //Notes Editor Interface loading 

    QDir dir(NOTES_EDITOR_PLUGIN_PATH);

    QString pluginName = dir.absoluteFilePath(NOTES_EDITOR_PLUGIN_NAME);

    // Create plugin loader.

    mNotespluginLoader = new QPluginLoader(pluginName);

    if (mNotespluginLoader)

        {

        // Load the plugin.

        mNotespluginLoader->load();

        QObject *plugin = qobject_cast<QObject*> (

                mNotespluginLoader->instance());

        mNotesEditor = qobject_cast<NotesEditorInterface*> (plugin);

        }

    mOnlineQueryAvailable = false;

    //Prepare the icons,listen of theme change    

    connect(hbInstance->theme(), SIGNAL(changeFinished()), this,

            SLOT(slotPrepareResultIcons()));

    slotPrepareResultIcons();

    // creating the handler if it is not prepared, useful when user try to create before 

    mValidateHandlerCreation = false;

    }

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

// SearchProgressiveState::~SearchProgressiveState

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

SearchProgressiveState::~SearchProgressiveState()

    {

    if (mAiwMgr)

        {

        delete mAiwMgr;

        }

    for (int i = 0; i < mSearchHandlerList.count(); i++)

        {

        delete mSearchHandlerList.at(i);

        }

    if (mNotespluginLoader)

        {

        mNotespluginLoader->unload();

        delete mNotespluginLoader;

        }

    SearchUiLoader::deleteinstance();

    }

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

// SearchProgressiveState::constructHandlers

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

void SearchProgressiveState::constructHandlers()

    {

    int categories = totalcategories_normalreason;

    if (hbApp && hbApp->activateReason() == Hb::ActivationReasonActivity)

        {

        categories = totalcategories_activityreasonreason;

        }

    for (int i = 0; i < categories; i++)

        {

        mSearchHandlerList.append(constructHandlers(i));

        }

    }

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

// SearchProgressiveState::onEntry

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

void SearchProgressiveState::onEntry(QEvent *event)

    QState::onEntry(event);

    mStateStatus = true;// used for conditional execution for the slots that are connected as transitions

    if (mSearchPanel)

        {

        mSearchPanel->setPlaceholderText(hbTrId(

                "txt_search_dialog_search_device"));

        mSearchPanel->setProgressive(true);

        }

    if (mListView)

        {

        mListView->setVisible(true);

        }

    activateSignals();

    // If this is not the current view, we're getting back from plugin view  

    if (mMainWindow)

        {

        if (mMainWindow->currentView() != mView)

            {

            mMainWindow->setCurrentView(mView, true);

            }

        mMainWindow->show();

        }

    if (loadSettings)

        {

        // to get the intial settings form delimeter  

        emit switchProToSettingsState();

        loadSettings = false;

        }

    setSelectedCategories();

    if (mOnlineQueryAvailable)

        {

        mSearchPanel->setCriteria(mOriginalString);

        mOnlineQueryAvailable = false;

        }

    }

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

// SearchProgressiveState::onExit

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

void SearchProgressiveState::onExit(QEvent *event)

    {

    QState::onExit(event);

    mStateStatus = false;

    deActivateSignals();

    }

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

// SearchProgressiveState::activateSignals

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

void SearchProgressiveState::activateSignals()

    {

    for (int i = 0; i < mSearchHandlerList.count(); i++)

        {

        connect(mSearchHandlerList.at(i),

                SIGNAL(handleAsyncSearchResult(int,int)), this,

                SLOT(onAsyncSearchComplete(int,int)));

        connect(mSearchHandlerList.at(i),

                SIGNAL(handleDocument(int,CpixDocument*)), this,

                SLOT(onGetDocumentComplete(int,CpixDocument*)));

        connect(mSearchHandlerList.at(i),

                SIGNAL(handleBatchDocument(int,int,CpixDocument**)), this,

                SLOT(onGetBatchDocumentComplete(int,int,CpixDocument**)));

        }

    if (mListView)

        {

        connect(mListView, SIGNAL(activated(HbListWidgetItem *)), this,

                SLOT(openResultitem(HbListWidgetItem *)));

        }

    if (mSearchPanel)

        {

        connect(mSearchPanel, SIGNAL(criteriaChanged(QString)), this,

                SLOT(startNewSearch(QString)));

        connect(mSearchPanel, SIGNAL(searchOptionsClicked()), this,

                SLOT(setSettings()));

        }

    connect(mMainWindow, SIGNAL(viewReady()), this, SLOT(viewReady()));

    }

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

// SearchProgressiveState::deActivateSignals

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

void SearchProgressiveState::deActivateSignals()

    {

    for (int i = 0; i < mSearchHandlerList.count(); i++)

        {

        disconnect(mSearchHandlerList.at(i),

                SIGNAL(handleAsyncSearchResult(int,int)), this,

                SLOT(onAsyncSearchComplete(int,int)));

        disconnect(mSearchHandlerList.at(i),

                SIGNAL(handleDocument(int,CpixDocument*)), this,

                SLOT(onGetDocumentComplete(int,CpixDocument*)));

        disconnect(mSearchHandlerList.at(i),

                SIGNAL(handleBatchDocument(int,int,CpixDocument**)), this,

                SLOT(onGetBatchDocumentComplete(int,int,CpixDocument**)));

        }

    if (mListView)

        {

        disconnect(mListView, SIGNAL(activated(HbListWidgetItem *)), this,

                SLOT(openResultitem(HbListWidgetItem *)));

        }

    if (mSearchPanel)

        {

        disconnect(mSearchPanel, SIGNAL(criteriaChanged(QString)), this,

                SLOT(startNewSearch(QString)));

        disconnect(mSearchPanel, SIGNAL(searchOptionsClicked()), this,

                SLOT(setSettings()));

        }

    disconnect(mMainWindow, SIGNAL(viewReady()), this, SLOT(viewReady()));

    }

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

// SearchProgressiveState::onAsyncSearchComplete

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

void SearchProgressiveState::onAsyncSearchComplete(int aError,

        int aResultCount)

    {

    PERF_CAT_API_ENDLOG

    PERF_CAT_HITS_ENDLOG

    if (aError != 0)

        {

        //some error print logs

        searchOnCategory(mSearchString);

        return;

        }

    if (aResultCount == 0)

        {

        searchOnCategory(mSearchString);

        }

    else if (aResultCount > 0)

        {

        mResultcount = aResultCount;

        mResultparser = 0;

        PERF_CAT_GETDOC_TIME_RESTART

        PERF_CAT_GETDOC_ACCUMULATOR_RESET

        mSearchHandler->getDocumentAsyncAtIndex(mResultparser);

        }

    }

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

// SearchProgressiveState::onGetDocumentComplete

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

void SearchProgressiveState::onGetDocumentComplete(int aError,

        CpixDocument* aDoc)

    {

    if (aError)

        return;

    parseDocument(aDoc);

    mResultparser++;

    if (mResultparser < mResultcount)

        {

        PERF_CAT_GETDOC_TIME_RESTART

        if (mResultparser < intial_iteration)

            {

            mSearchHandler->getDocumentAsyncAtIndex(mResultparser);

            }

        else

            {

            mSearchHandler->getBatchDocumentAsyncAtIndex(mResultparser,

                    batch_iteration);

            }

        }

    else

        {

        PERF_CAT_GETDOC_ACCUMULATOR_ENDLOG

        searchOnCategory(mSearchString);

        }

    }

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

// SearchProgressiveState::onGetDocumentComplete

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

void SearchProgressiveState::onGetBatchDocumentComplete(int aError,

        int aCount, CpixDocument** aDoc)

    {

    if (aError)

        return;

    for (int i = 0; i < aCount; i++)

        {

        parseDocument(aDoc[i]);

        }

    delete aDoc;

    mResultparser += aCount;

    if (mResultparser < mResultcount)

        {

        PERF_CAT_GETDOC_TIME_RESTART

        mSearchHandler->getBatchDocumentAsyncAtIndex(mResultparser,

                batch_iteration);

        }

    else

        {

        PERF_CAT_GETDOC_ACCUMULATOR_ENDLOG

        searchOnCategory(mSearchString);

        }

    }

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

// SearchProgressiveState::getSettingCategory

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

void SearchProgressiveState::getSettingCategory(int item, bool avalue)

    {

    mSelectedCategory.insert(item, avalue);

    }

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

// SearchProgressiveState::openResultitem

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

void SearchProgressiveState::openResultitem(HbListWidgetItem * item)

    {

    if (item == NULL)

        return;

    PERF_RESULT_ITEM_LAUNCH_TIME_RESTART

    QList<QVariant> args;

    bool t;

    mRequest = NULL;

    if (item->data(Qt::UserRole + 1).toString().contains("contact"))

        {

        PERF_RESULT_ITEM_FOR_LAUNCHING("contact")

        int uid = (item->data(Qt::UserRole)).toInt(&t);

        args << uid;

        }

    else if (item->data(Qt::UserRole + 1).toString().contains("bookmark"))

        {

        PERF_RESULT_ITEM_FOR_LAUNCHING("bookmark")

        QDesktopServices::openUrl(item->data(Qt::UserRole + 2).toString());

        PERF_RESULT_ITEM_LAUNCH_TIME_ENDLOG ("")

        }

    else if (item->data(Qt::UserRole + 1).toString().contains("calendar"))

        {

        QDir pluginDir = QDir(CALENDAR_EVENTVIEWER_PLUGIN_PATH);

        QPluginLoader *calAgandaViewerPluginLoader = new QPluginLoader(

                pluginDir.absoluteFilePath(CALENDAR_EVENTVIEWER_PLUGIN_NAME));

        calAgandaViewerPluginInstance = qobject_cast<

                EventViewerPluginInterface *> (

                calAgandaViewerPluginLoader->instance());

        connect(calAgandaViewerPluginInstance, SIGNAL(viewingCompleted()),

                this, SLOT(_viewingCompleted()));

        calAgandaViewerPluginInstance->viewEvent(

                item->data(Qt::UserRole).toInt(),

                EventViewerPluginInterface::ActionEditDelete, NULL);

        }

    else if (item->data(Qt::UserRole + 1).toString().contains("applications"))

        {

        PERF_RESULT_ITEM_FOR_LAUNCHING("applications")

        TRAP_IGNORE(LaunchApplicationL((item->data(Qt::UserRole)).toString()));

        PERF_RESULT_ITEM_LAUNCH_TIME_ENDLOG("")

        }

    else if (item->data(Qt::UserRole + 1).toString().contains("file"))

        {

        PERF_RESULT_ITEM_FOR_LAUNCHING("file")

        QString uid = item->data(Qt::UserRole).toString();

        QFile file(uid);

        mRequest = mAiwMgr->create(file, true);

        args << file.fileName();

        }

    else if ((item->data(Qt::UserRole + 1).toString().contains("video"))

            || (item->data(Qt::UserRole + 1).toString().contains("audio"))

            || (item->data(Qt::UserRole + 1).toString().contains("image")))

        {

        PERF_RESULT_ITEM_FOR_LAUNCHING("media")

        QString uid = getDrivefromMediaId(

                item->data(Qt::UserRole + 2).toString());

        uid.append(':');

        uid.append(item->data(Qt::UserRole).toString());

        QFile file(uid);

        mRequest = mAiwMgr->create(file, true);

        args << file.fileName();

        }

    else if (item->data(Qt::UserRole + 1).toString().contains("notes"))

        {

        PERF_RESULT_ITEM_FOR_LAUNCHING("notes")

        if (mNotesEditor)

            {

            mNotesEditor->edit(item->data(Qt::UserRole).toInt());

            }

        PERF_RESULT_ITEM_LAUNCH_TIME_ENDLOG("")

        }

    else if (item->data(Qt::UserRole + 1).toString().contains("msg email"))

        {

        args << item->data(Qt::UserRole + 2).toULongLong(&t) << item->data(

                Qt::UserRole + 3).toULongLong(&t)

                << item->data(Qt::UserRole).toULongLong(&t);

        }

    else if (item->data(Qt::UserRole + 1).toString().contains("msg"))

        {

        PERF_RESULT_ITEM_FOR_LAUNCHING("msg")

        int uid = (item->data(Qt::UserRole)).toInt(&t);

        args << uid;

        }

    else if (item->data(Qt::UserRole + 1).toString().contains("links"))

        {

        emit launchLink((item->data(Qt::UserRole)).toInt(&t), mOriginalString);

        }

    if (mRequest)

        {

        connect(mRequest, SIGNAL(requestOk(const QVariant&)), this,

                SLOT(handleOk(const QVariant&)));

        connect(mRequest, SIGNAL(requestError(int,const QString&)), this,

                SLOT(handleError(int,const QString&)));// Connect error handling signal or apply lastError function instead.