/*

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

*

*/

//USER

#include "logsbaseview.h"

#include "logscomponentrepository.h"

#include "logsabstractviewmanager.h"

#include "logsdefs.h"

#include "logslogger.h"

#include "logscall.h"

#include "logsmessage.h"

#include "logscontact.h"

#include "logsabstractmodel.h"

#include "logsdetailsmodel.h"

//SYSTEM

#include <hbaction.h>

#include <hbmainwindow.h>

#include <hbmessagebox.h>

#include <hbtoolbar.h>

#include <hbmenu.h>

#include <dialpad.h>

#include <hblineedit.h>

#include <hbeffect.h>

#include <hbabstractviewitem.h>

#include <QSignalMapper>

#include <xqservicerequest.h>

#include <hblabel.h>

#include <hblistview.h>

#include <QGraphicsLinearLayout>

#include <hbpushbutton.h>

Q_DECLARE_METATYPE(LogsCall*)

Q_DECLARE_METATYPE(LogsMessage*)

Q_DECLARE_METATYPE(LogsContact*)

Q_DECLARE_METATYPE(LogsDetailsModel*)

const int contextMenuTimeout = 5000000; //5 secs

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

// 

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

//

LogsBaseView::LogsBaseView( 

    LogsAppViewId viewId, 

    LogsComponentRepository& repository, 

    LogsAbstractViewManager& viewManager )

    : HbView(0),

      mViewId( viewId ),

      mRepository( repository ),

      mViewManager( viewManager ),

      mShowFilterMenu(0),

      mEmptyListLabel(0),

      mInitialized(false),

      mCall(0),

      mMessage(0),

      mContact(0),

      mDetailsModel(0),

      mCallTypeMapper(0)

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::LogsBaseView()" );

    mSoftKeyBackAction = new HbAction(Hb::BackNaviAction, this);

    connect(mSoftKeyBackAction, SIGNAL(triggered()), this, 

            SLOT(handleBackSoftkey()));

    mDialpad =  mRepository.dialpad();

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::LogsBaseView()" );

}

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

//

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

//

LogsBaseView::~LogsBaseView()

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::~LogsBaseView()" );

    delete mCall;

    delete mMessage;

    delete mContact;

    delete mDetailsModel;    

    delete mCallTypeMapper;

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::~LogsBaseView()" );

}

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

//

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

//

LogsAppViewId LogsBaseView::viewId() const

{

    return mViewId;

}

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

//

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

//

bool LogsBaseView::isExitAllowed()

{

    return true;

}

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

//

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

//

void LogsBaseView::resetView()

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::resetView()" );

    mDialpad->editor().setText(QString());

    if ( mDialpad->isOpen() ){

        mDialpad->closeDialpad();

    }

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::resetView()" );

}

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

//

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

//

void LogsBaseView::activated(bool showDialer, QVariant args)

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::activated()" );

    Q_UNUSED(args);

    //we have to set object tree of the repository to the current view

    mRepository.setObjectTreeToView( mViewId );

    if (!mInitialized) {

        initView();

    }

    connect( mDialpad, SIGNAL( aboutToClose() ), this, 

            SLOT( dialpadClosed() ), Qt::QueuedConnection );

    connect( mDialpad, SIGNAL( aboutToOpen() ), this, 

            SLOT( dialpadOpened() ), Qt::QueuedConnection );

    connect( &mDialpad->editor(), SIGNAL( contentsChanged() ), this,

            SLOT( dialpadEditorTextChanged() ) );

    if ( navigationAction() != mSoftKeyBackAction ) {

        setNavigationAction(mSoftKeyBackAction);

    }

    if (showDialer && !mDialpad->isOpen()) {

        openDialpad();

    }

    updateWidgetsSizeAndLayout();

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::activated()" );

}

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

//

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

//

void LogsBaseView::deactivated()

{

    LOGS_QDEBUG( "logs [UI] <-> LogsBaseView::deactivated()" );

    disconnect( mDialpad, SIGNAL( aboutToClose() ), this, 

            SLOT( dialpadClosed() ) );

    disconnect( mDialpad, SIGNAL( aboutToOpen() ), this, 

            SLOT( dialpadOpened() ) );

    disconnect( &mDialpad->editor(), SIGNAL( contentsChanged() ), this,

            SLOT( dialpadEditorTextChanged() ) );

}

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

//

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

//

void LogsBaseView::notSupported()

{

    HbMessageBox* messageBox = new HbMessageBox(QString("Not supported"));

    messageBox->setAttribute(Qt::WA_DeleteOnClose);

    messageBox->setTimeout( HbMessageBox::StandardTimeout );

    messageBox->show();

}

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

//

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

//

void LogsBaseView::handleBackSoftkey()

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::handleBackSoftkey()" );

    mViewManager.activateView( LogsRecentViewId, false, QVariant() );

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::handleBackSoftkey()" );

}

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

//

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

//

void LogsBaseView::initFilterMenu()

{

    mShowFilterMenu = 

        qobject_cast<HbMenu*>( mRepository.findWidget( logsShowFilterMenuId ) );

}

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

//

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

//

void LogsBaseView::addActionNamesToMap()

{

    mActionMap.clear();

    mActionMap.insert(LogsServices::ViewReceived, logsShowFilterReceivedMenuActionId);

    mActionMap.insert(LogsServices::ViewCalled, logsShowFilterDialledMenuActionId);

    mActionMap.insert(LogsServices::ViewMissed, logsShowFilterMissedMenuActionId);

    mActionMap.insert(LogsServices::ViewAll, logsShowFilterRecentMenuActionId);  

}

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

//

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

//

void LogsBaseView::initView()

{   

    Q_ASSERT_X( !mInitialized, "logs [UI] ", "view is already initialized!!" );

    mInitialized = true;

    initFilterMenu();

    addActionNamesToMap();

    connect(menu(), SIGNAL(aboutToShow()), this, 

            SLOT(closeEmptyMenu()), Qt::QueuedConnection);

}

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

//

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

//

QAbstractItemModel* LogsBaseView::model() const

{

    LOGS_QDEBUG( "logs [UI] <-> LogsBaseView::model()" );

    return 0;

}

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

//

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

//

void LogsBaseView::handleExit()

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::handleExit()" );   

    mViewManager.exitApplication();

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::handleExit()" );

}

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

//

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

//

void LogsBaseView::showFilterMenu()

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::showFilterMenu()" );

    if ( mShowFilterMenu ) {

        QRectF toolbarGeometry = toolBar()->geometry();

        QSizeF menuSize = mShowFilterMenu->size();

        LOGS_QDEBUG_2("logs [UI]    menusize:", menuSize)

        QPointF pos( toolbarGeometry.bottomRight().x(),

                     toolbarGeometry.topRight().y() ); 

        pos.setX(toolbarGeometry.bottomRight().x());

        pos.setY(toolbarGeometry.topRight().y());

        mShowFilterMenu->setPreferredPos(pos,HbPopup::BottomRightCorner);

        LOGS_QDEBUG_2("logs [UI]    menupos:", pos)

        mShowFilterMenu->exec();

    }

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::showFilterMenu()" );

}

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

// LogsBaseView::closeEmptyMenu()

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

//

void LogsBaseView::closeEmptyMenu()

{

    bool visibleActionsExist = false;

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

        if  (action->isVisible()) {

            visibleActionsExist = true ;

        }

    }

    if (!visibleActionsExist) {

        menu()->close();

    }

}

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

//

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

//

void LogsBaseView::openDialpad()

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::openDialpad()" );

    updateCallButton();

    setDialpadPosition();

    mDialpad->openDialpad();

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::openDialpad()" );

}

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

//

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

//

void LogsBaseView::openContactsApp()

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::openContactsApp()" );

    // Need to do request in async manner, otherwise new phonebook ui process

    // will be started due bug(?) in highway.

    XQServiceRequest snd("com.nokia.services.phonebookappservices.Launch","launch()", false);

    int retValue;

    snd.send(retValue);

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::openContactsApp()" );

}

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

//

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

//

void LogsBaseView::setDialpadPosition()

{

    HbMainWindow& window = mViewManager.mainWindow(); 

    // layoutrect broken, fix will be in MCL wk14, use workaround meanwhile

    //QRectF screenRect = window.layoutRect();

    QRectF screenRect = (window.orientation() == Qt::Horizontal) ? 

        QRectF(0,0,640,360) : QRectF(0,0,360,640);

    LOGS_QDEBUG_2( "logs [UI] -> LogsBaseView::setDialpadPosition(), screenRect:", 

            screenRect );

    if (window.orientation() == Qt::Horizontal) {

        // dialpad takes half of the screen width    

        mDialpad->setPos(QPointF(screenRect.width()/2,

                                 this->scenePos().y()));

        mDialpad->setPreferredSize(screenRect.width()/2,

                                   (screenRect.height()-scenePos().y()));                                  

    } else {

        // dialpad takes 65% of the screen height

        qreal screenHeight = screenRect.height();

        mDialpad->setPos(QPointF(0, screenHeight/2.25));

        mDialpad->setPreferredSize(screenRect.width(),

                                   screenHeight-screenHeight/2.25);        

    }

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::setDialpadPosition()" );

}

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

//

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

//

void LogsBaseView::dialpadOpened()

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::dialpadOpened()" );

    updateWidgetsSizeAndLayout();

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::dialpadOpened()" );

}

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

//

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

//

void LogsBaseView::dialpadClosed()

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::dialpadClosed()" );

    mDialpad->editor().setText(QString());

    updateWidgetsSizeAndLayout();

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::dialpadClosed()" );

}

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

//

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

//

void LogsBaseView::dialpadEditorTextChanged()

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::dialpadEditorTextChanged()" );

    if ( mDialpad->editor().text().length() > 0 ) {

        mViewManager.activateView( LogsMatchesViewId, true, QVariant() );      

    } else {

        updateCallButton();

    }

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::dialpadEditorTextChanged()" );

}

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

// 

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

//

void LogsBaseView::changeFilter(HbAction* action)

{

    LOGS_QDEBUG( "logs [UI] -> LogsBaseView::changeFilter()" );

    LogsServices::LogsView view = mActionMap.key( action->objectName(),

            LogsServices::ViewAll );

    QVariant args(view);

    mViewManager.activateView( LogsRecentViewId, false, args );

    LOGS_QDEBUG( "logs [UI] <- LogsBaseView::changeFilter()" );

}

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

// 

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

//

void LogsBaseView::showListItemMenu(

        HbAbstractViewItem* item, const QPointF& coords )

{

    HbMenu itemContextMenu(0);    

    itemContextMenu.setDismissPolicy(HbMenu::TapAnywhere);

    itemContextMenu.setTimeout(contextMenuTimeout);

    updateListItemData(item->modelIndex());    

    populateListItemMenu(itemContextMenu);

    if (mDialpad->isOpen()) {

        mDialpad->closeDialpad();

    }    

    if (itemContextMenu.actions().count() > 0) {

        itemContextMenu.exec(coords);

    }

}

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

//

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

//

void LogsBaseView::populateListItemMenu(HbMenu& menu)

{

    delete mCallTypeMapper;

    mCallTypeMapper = 0;

    if (mCall) {

        mCallTypeMapper = new QSignalMapper();

        foreach(LogsCall::CallType callType, mCall->allowedCallTypes()){

            HbAction* callAction = new HbAction;

            if (callType == LogsCall::TypeLogsVoiceCall){

                callAction->setText(hbTrId("txt_common_menu_voice_call"));

            }

            else if (callType == LogsCall::TypeLogsVideoCall){

                callAction->setText(hbTrId("txt_common_menu_video_call"));

            }

            else if (callType == LogsCall::TypeLogsVoIPCall){

                callAction->setText(hbTrId("txt_common_menu_internet_call"));

            }

            connect(callAction, SIGNAL(triggered()),

                    mCallTypeMapper, SLOT( map()) );

            mCallTypeMapper->setMapping(callAction, callType);

            // Default call type must be the first item in context menu

            if (callType != mCall->defaultCallType() ||

                menu.actions().count() == 0){

                menu.addAction(callAction);

            } else {   

                menu.insertAction(menu.actions().at(0), callAction);

            }           

        }    

        connect(mCallTypeMapper, SIGNAL(mapped(int)),

                this, SLOT( initiateCall(int)) );

    }

    if (mMessage) {

        HbAction* messageAction = new HbAction;

        messageAction->setText(hbTrId("txt_common_menu_create_message"));

        menu.addAction(messageAction);

        QObject::connect( messageAction, SIGNAL(triggered()), 

                          this, SLOT( createMessage() ) );

    }

    if (mContact) {

        HbAction* contactAction = new HbAction;

        if (mContact->allowedRequestType() ==

                LogsContact::TypeLogsContactOpen) {

            contactAction->setText(hbTrId("txt_dialer_ui_menu_open_contact"));

            QObject::connect( contactAction, SIGNAL(triggered()), 

                              mContact, SLOT(open()) );

        }

        else {

            contactAction->setText(hbTrId("txt_common_menu_add_to_contacts"));

            QObject::connect( contactAction, SIGNAL(triggered()), 

                              this, SLOT(saveContact()) );

        }

        menu.addAction(contactAction);

    }    

    if (mDetailsModel) {

        HbAction* callDetailsAction = new HbAction;

        callDetailsAction->setText(hbTrId("txt_dialer_ui_menu_call_details"));

        menu.addAction(callDetailsAction);

        QObject::connect(callDetailsAction, SIGNAL(triggered()), 

                         this, SLOT(showCallDetails()));

        HbAction* deleteAction = new HbAction;

        deleteAction->setText(hbTrId("txt_common_menu_delete"));

        menu.addAction(deleteAction);

        QObject::connect(deleteAction, SIGNAL(triggered()), 

                         this, SLOT(deleteEvent()));

    }

}

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

//

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

//

void LogsBaseView::updateListItemData(const QModelIndex& listIndex)

{

    updateCall(listIndex);

    updateMessage(listIndex);

    updateContact(listIndex);

    updateDetailsModel(listIndex);

}