/*!

* 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:  Conference call bubble handler.

*

*/

#include <QTimer>

#include <hbaction.h>

#include <hbtextitem.h>

#include <hblabel.h>

#include <hblistview.h>

#include "bubblemanager2.h"

#include "bubbleconferencehandler.h"

#include "bubbleconferenceheader.h"

#include "bubbleutils.h"

#include "bubbleparticipantlistitem.h"

#include "bubbleparticipantlistmodel.h"

#include "bubblebutton.h"

#include "bubbleheadingwidget.h"

static const int BUBBLE_SELECTION_TIMEOUT = 3000;

BubbleConferenceHandler::BubbleConferenceHandler(

    BubbleWidgetManager& widgetManager,

    BubbleWidgetManager::View view,

    BubbleWidgetManager::Container container,

    QObject* parent )

    : BubbleHandler(widgetManager,view,container,parent)

{

    mHeading =

        qobject_cast<BubbleHeadingWidget*>(widget(BubbleWidgetManager::Heading));

    Q_ASSERT(mHeading);

    mButtonCenter =

        qobject_cast<BubbleButton*>(widget(BubbleWidgetManager::CenterButton));

    Q_ASSERT(mButtonCenter);

    mButtonLeft =

        qobject_cast<BubbleButton*>(widget(BubbleWidgetManager::LeftButton));

    Q_ASSERT(mButtonLeft);

    mButtonRight =

        qobject_cast<BubbleButton*>(widget(BubbleWidgetManager::RightButton));

    Q_ASSERT(mButtonRight);

    mList =

        qobject_cast<HbListView*>(widget(BubbleWidgetManager::ParticipantList));

    Q_ASSERT(mList);

    mModel = new BubbleParticipantListModel();

    mList->setModel(mModel);

    HbAbstractItemView::ItemAnimations noCreationAndRemovalAnimations = HbAbstractItemView::All;

    noCreationAndRemovalAnimations ^= HbAbstractItemView::Appear;

    noCreationAndRemovalAnimations ^= HbAbstractItemView::Disappear;

    mList->setEnabledAnimations(noCreationAndRemovalAnimations);

    mPrototype =

        qobject_cast<BubbleParticipantListItem*>(

            widgetManager.createParticipantListItem());

    Q_ASSERT(mPrototype);

    mList->setItemPrototype(mPrototype);

    connect(mList->selectionModel(),

            SIGNAL(currentChanged(QModelIndex,QModelIndex)),

            this,

            SLOT(handleItemSelected(QModelIndex,QModelIndex)));

    mSelectionTimer = new QTimer(this);

    connect(mSelectionTimer,SIGNAL(timeout()),SLOT(clearSelection()));

    mSelectionTimer->setSingleShot(true);

    reset();

}

BubbleConferenceHandler::~BubbleConferenceHandler()

{

}

void BubbleConferenceHandler::reset()

{  

    mHeader = 0;

    mSelectionTimer->stop();

    mPrototype->clearActions();

    mHeading->reset();

    mButtonCenter->hide();

    mButtonCenter->setDown(false);

    mButtonCenter->disconnect();

    mButtonLeft->hide();

    mButtonLeft->setDown(false);

    mButtonLeft->disconnect();

    mButtonRight->hide();

    mButtonRight->setDown(false);

    mButtonRight->disconnect();

}

void BubbleConferenceHandler::readBubbleHeader( const BubbleHeader& header )

{

    Q_ASSERT(header.isConference());

    mHeader = static_cast<const BubbleConferenceHeader*>(&header);

    // set actions to item prototype

    QList<HbAbstractViewItem*> prototypes = mList->itemPrototypes();

    QList<HbAction*> actions = mHeader->participantListActions();

    foreach (HbAction* action, actions ) {

        mPrototype->addAction(action);

    }

    // populate participant list model

    QList<BubbleHeader*> participants = mHeader->headers();

    foreach(BubbleHeader* participant, participants) {

         mModel->addParticipant(

            participant->bubbleId(),

            participant->cli(),

            (int)participant->callState(),

            !(mHeader->callFlags()&BubbleManagerIF::NoCiphering));

    }

    mHeading->readBubbleHeader(header);

    setButtons(mHeader->actions());

    clearSelection();

}

void BubbleConferenceHandler::setButtons(const QList<HbAction*>& actions)

{

    if ( actions.count()==1 && mButtonCenter ) {

        HbAction* action = actions.at(0);

        mButtonCenter->setIcon( action->icon() );

        BubbleUtils::setButtonStyleForAction(*mButtonCenter,*action);

        connect(mButtonCenter, SIGNAL( clicked() ),

                action, SLOT( trigger() ) );

        connect(mButtonCenter, SIGNAL( longPress(QPointF)),

                action, SLOT( trigger() ) );

        mButtonCenter->show();

    } else  if (actions.count()==2 && mButtonLeft && mButtonRight ) {

        // Left button

        HbAction* action1 = actions.at(0);

        mButtonLeft->setIcon( action1->icon() );

        BubbleUtils::setButtonStyleForAction(*mButtonLeft,*action1);

        connect( mButtonLeft, SIGNAL( clicked() ),

                 action1, SLOT( trigger() ) );

        connect(mButtonLeft, SIGNAL( longPress(QPointF)),

                action1, SLOT( trigger() ) );

        mButtonLeft->show();

        // Right button

        HbAction* action2 = actions.at(1);

        mButtonRight->setIcon( action2->icon() );

        BubbleUtils::setButtonStyleForAction(*mButtonRight,*action2);

        connect( mButtonRight, SIGNAL( clicked() ),

                 action2, SLOT( trigger() ) );

        connect(mButtonRight, SIGNAL( longPress(QPointF)),

                action2, SLOT( trigger() ) );

        mButtonRight->show();

    }

}

QGraphicsWidget* BubbleConferenceHandler::graphicsWidgetForAction(

    HbAction* action ) const

{

    if ( mButtonLeft->text() == action->text() ) {

        return mButtonLeft;

    } else if ( mButtonRight->text() == action->text() ) {

        return mButtonRight;

    } else if ( mButtonCenter->text() == action->text() ) {

        return mButtonCenter;

    } else {

        return 0;

    }

}

void BubbleConferenceHandler::updateTimerDisplayNow()

{

    mHeading->updateTimerDisplayNow();

}

void BubbleConferenceHandler::handleItemSelected(

    const QModelIndex & current,

    const QModelIndex & previous )

{

    Q_UNUSED(previous);

    if (current.isValid()) {

        Q_ASSERT( mHeader != 0 );

        // need to cast constness away

        BubbleConferenceHeader& mutableHeader =

            const_cast<BubbleConferenceHeader&>(*mHeader);

        mutableHeader.setSelectedHeader(mModel->bubbleId(current.row()));

        mSelectionTimer->stop();

        mSelectionTimer->start(BUBBLE_SELECTION_TIMEOUT);

    }

}

void BubbleConferenceHandler::clearSelection()

{

    mList->selectionModel()->clear();

}

void BubbleConferenceHandler::conferenceMemberRemoved(int bubbleId)

{

    mModel->removeParticipant(bubbleId);

}

void BubbleConferenceHandler::conferenceRemoved()

{

    mModel->reset();

    mList->reset();

}