/*

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

#include <qservicemanager.h>

#include <qurl.h>

#include <email_services_api.h>

#include <xqrequestinfo.h>

QTM_USE_NAMESPACE

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

    connect(mUiLoader, SIGNAL(dbChanged), this, SLOT(slotdbChanged()));

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

        }

    constructHandlers();

    if (mView && mMainWindow)

        {

        mMainWindow->addView(mView);

        mMainWindow->setCurrentView(mView);

        }

    mDatabasecount = 0;

    mLinkindex = 0;

    mResultcount = 0;

    mResultparser = 0;

    loadSettings = true;

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

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

    mValidateHandlerCreation = false;

    // to retrive the search documents form where it ends when search server crashes

    mContinuationSearch = false;

    }

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

// SearchProgressiveState::~SearchProgressiveState

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

SearchProgressiveState::~SearchProgressiveState()

    {

    if(mRequest)

        {

        delete mRequest;

        }

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

    {

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

        {

        disconnect(mSearchHandlerList.at(i),

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

                SLOT(slotonAsyncSearchComplete(int,int)));

        disconnect(mSearchHandlerList.at(i),

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

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

        disconnect(mSearchHandlerList.at(i),

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

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

        delete mSearchHandlerList.at(i);

        }

    mSearchHandlerList.clear();

    for (int i = 0; i < mUiLoader->ContentInfoList().count(); i++)

        {

        InDeviceHandler* handler = NULL;

        handler = new InDeviceHandler();

        handler->setCategory(mUiLoader->ContentInfoList().at(i)->getBaseApp());

        mSearchHandlerList.append(handler);

        if(mUiLoader->ContentInfoList().at(i)->getTranslationPath().length())

            {

            loadTranslator(mUiLoader->ContentInfoList().at(i)->getTranslationPath());

            }

        }

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

        {

        connect(mSearchHandlerList.at(i),

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

                SLOT(slotonAsyncSearchComplete(int,int)));

        connect(mSearchHandlerList.at(i),

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

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

        connect(mSearchHandlerList.at(i),

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

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

        }

    }

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

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

        }

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

    {

    if (mListView)

        {

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

                SLOT(slotopenResultitem(HbListWidgetItem *)));

        }

    if (mSearchPanel)

        {

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

                SLOT(slotstartNewSearch(QString)));

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

                SLOT(slotsetSettings()));

        }

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

    }

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

// SearchProgressiveState::deActivateSignals

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

void SearchProgressiveState::deActivateSignals()

    {

    if (mListView)

        {

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

                SLOT(slotopenResultitem(HbListWidgetItem *)));

        }

    if (mSearchPanel)

        {

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

                SLOT(slotstartNewSearch(QString)));

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

                SLOT(slotsetSettings()));

        }

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

    }

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

// SearchProgressiveState::slotonAsyncSearchComplete

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

void SearchProgressiveState::slotonAsyncSearchComplete(int aError,

        int aResultCount)

    {

    PERF_CAT_API_ENDLOG

    PERF_CAT_HITS_ENDLOG

    if (aError != 0)

        {

        if (aError == KErrServerTerminated) // server terminated refresh the handlers

            {

            constructHandlers();

            mDatabasecount = 0;

            mLinkindex = 0;

            }

        searchOnCategory(mSearchString);

        return;

        }

    if (aResultCount == 0)

        {

        searchOnCategory(mSearchString);

        }

    else if (aResultCount > 0)

        {

        mResultcount = aResultCount;

        if (mContinuationSearch)

            {

            mContinuationSearch = false;

            }

        else

            {

            mResultparser = 0;

            }

        PERF_CAT_GETDOC_TIME_RESTART

        PERF_CAT_GETDOC_ACCUMULATOR_RESET

        if (mListView->count() >= intial_iteration)

            {

            mSearchHandler->getBatchDocumentAsyncAtIndex(mResultparser,

                    batch_iteration);

            }

        else

            {

            mSearchHandler->getDocumentAsyncAtIndex(mResultparser);

            }

        }

    }

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

// SearchProgressiveState::slotonGetDocumentComplete

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

void SearchProgressiveState::slotonGetDocumentComplete(int aError,

        CpixDocument* aDoc)

    {

    if (aError == KErrServerTerminated) // server terminated refresh the handlers

        {

        constructHandlers();

        mDatabasecount = 0;

        mLinkindex = 0;

        searchOnCategory(mSearchString);

        mContinuationSearch = true;

        return;

        }

    if (aError)

        return;

    parseDocument(aDoc);

    mResultparser++;

    if (mResultparser < mResultcount)

        {

        PERF_CAT_GETDOC_TIME_RESTART

        if (mListView->count() < intial_iteration)

            {

            mSearchHandler->getDocumentAsyncAtIndex(mResultparser);

            }

        else

            {

            mSearchHandler->getBatchDocumentAsyncAtIndex(mResultparser,

                    batch_iteration);

            }

        }

    else

        {

        PERF_CAT_GETDOC_ACCUMULATOR_ENDLOG

        searchOnCategory(mSearchString);

        }

    }

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

// SearchProgressiveState::slotonGetDocumentComplete

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

void SearchProgressiveState::slotonGetBatchDocumentComplete(int aError,

        int aCount, CpixDocument** aDoc)

    {

    if (aError == KErrServerTerminated) // server terminated refresh the handlers

        {

        constructHandlers();

        mDatabasecount = 0;

        mLinkindex = 0;

        searchOnCategory(mSearchString);

        mContinuationSearch = true;

        return;

        }

    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::slotopenResultitem

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

void SearchProgressiveState::slotopenResultitem(HbListWidgetItem * item)

    {

    if (item == NULL)

        return;

    PERF_RESULT_ITEM_LAUNCH_TIME_RESTART

    QList<QVariant> args;

    bool t;

    if(mRequest)

       delete mRequest;    

    mRequest = NULL;

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

        {

        PERF_RESULT_ITEM_FOR_LAUNCHING(CONTACTCATEGORY)

        mRequest = mAiwMgr->create(XQI_CONTACTS_VIEW,XQOP_CONTACTS_VIEW_CONTACT_CARD, true);

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

        args << uid;

        }

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

        {

        PERF_RESULT_ITEM_FOR_LAUNCHING(BOOKMARKCATEGORY)

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

        PERF_RESULT_ITEM_LAUNCH_TIME_ENDLOG ("")

        }

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

        {

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

        calAgandaViewerPluginInstance->viewEvent(

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

                EventViewerPluginInterface::ActionEditDelete, NULL);

        }

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

        {

        PERF_RESULT_ITEM_FOR_LAUNCHING(APPLICATIONCATEGORY)

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

        PERF_RESULT_ITEM_LAUNCH_TIME_ENDLOG("")

        }

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

        {

        PERF_RESULT_ITEM_FOR_LAUNCHING(FILECATEGORY)

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

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

        {

        PERF_RESULT_ITEM_FOR_LAUNCHING(AUDIOCATEGORY)

        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, false);

        args << file.fileName();