/*!

* 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:  BubbleManager widget.

*

*/

#include <QtGui>

#include <QtAlgorithms>

#include <hblabel.h>

#include <hbstyle.h>

#include <hbiconitem.h>

#include <hbaction.h>

#include <hbstackedlayout.h>

#include <hbmainwindow.h>

#include <hbstyleloader.h>

#include "bubblemanager2.h"

#include "bubbleheader.h"

#include "bubbleconferenceheader.h"

#include "bubbleutils.h"

#include "bubblewidgetmanager.h"

#include "bubbleimagemanager.h"

#include "bubblehandler.h"

#include "bubbleeffecthandler.h"

BubbleManager::BubbleManager( QGraphicsItem *parent ) :

    HbWidget( parent ),

    mIsReadyToDraw(0),

    mMuted(0),

    mMutedIcon(0),

    mSortHeaders(false),

    mInitialized(false),

    mBubbleSelectionDisabled(0)

{

    // allocate headers

    BubbleHeader* header;

    for ( int i = 0 ; i < BUBBLE_MAX_CALL_COUNT ; i++ ) {

        header = new BubbleHeader;

        header->setBubbleId( i );

        mCallHeaders.append( header );

    }

    mConferenceHeader = new BubbleConferenceHeader();

    mConferenceHeader->setBubbleId(BUBBLE_CONF_CALL_ID);

    mBubbleImageManager = new BubbleImageManager(this);

    mEffectHandler = new BubbleEffectHandler(this);

    mWidgetManager = new BubbleWidgetManager(

        *mBubbleImageManager, this);

    mMainLayout = new HbStackedLayout(this);

    mMainLayout->setContentsMargins(0.0,0.0,0.0,0.0);

    setLayout(mMainLayout);

    // preload views on boot

    mWidgetManager->view(BubbleWidgetManager::SingleCallView);

}

BubbleManager::~BubbleManager()

{

    qDeleteAll(mCallHeaders);

    mCallHeaders.clear();

    delete mConferenceHeader;

}

/**

* Before making any changes to bubble headers, call this function so

* manager can prapare for them properly.

*/

void BubbleManager::startChanges()

{

    mIsReadyToDraw++;

    if ( mIsReadyToDraw > 1 ) {

        return;

    }

    if (parentItem()) {

        // reset/hide on outlooks may result clearFocus() call,

        // which means that there is no focused item. move focus

        // to parent item, before reset/hide calls.

        parentItem()->setFocus();

    }

    // invalidate current widgets

    for (int i=0; i<mMainLayout->count(); i++) {

        mMainLayout->itemAt(i)->graphicsItem()->hide();

    }

    // reset active handlers

    foreach (BubbleHandler* handler, mActiveHandlers) {

        handler->reset();

    }

    mActiveHandlers.clear();

}

/**

* After the changes to bubble headers call this function so manager

* can prepare bubbles to right places and check the drawing order.

* Memory for arrays has been allocated beforehand.

*/

void BubbleManager::endChanges()

{

    Q_ASSERT( mIsReadyToDraw > 0 );

    mIsReadyToDraw--;

    if ( mIsReadyToDraw != 0 ) {

        return;

    }

    if (!mInitialized) {

        if (mainWindow()) {

            mWidgetManager->handleOrientationChange(mainWindow()->orientation());

            mInitialized=true;

        }

    }

    // sort active headers

    if ( mActiveHeaders.count() && mSortHeaders) {

        qStableSort(mActiveHeaders.begin(),

                    mActiveHeaders.end(),

                    BubbleUtils::compareHeaders );

        mSortHeaders = false;

    }

    // select view

    QGraphicsWidget* view = selectView();

    if (view) {

        setViewData(view);

        view->show();

    }

    if (!mActiveHeaders.count()) {

        // all calls ended

        mBubbleImageManager->releasePixmaps();

        releaseNonCachedViews();

    }

    // restore mute state

    setPhoneMuted(mMuted);

    update();

}

QGraphicsWidget* BubbleManager::selectView()

{

    QGraphicsWidget* view=0;

    int bubbleCount = shownHeaderCount();

    if (bubbleCount && isConferenceExpanded()) {

        view = mWidgetManager->view(BubbleWidgetManager::ConferenceView);

    } else {

        switch(bubbleCount) {

        case 1:

            view = mWidgetManager->view(BubbleWidgetManager::SingleCallView);

            break;

        case 2:

            view = mWidgetManager->view(BubbleWidgetManager::TwoCallsView);

            break;

        case 3:

            view = mWidgetManager->view(BubbleWidgetManager::ThreeCallsView);

            break;

        default:

            break;

        }

    }

    if (view) {

        if (addToLayout(view)) {

            // connect signals

            connectSignals(view);

        }

    }

    return view;

}

bool BubbleManager::addToLayout(QGraphicsWidget* widget)

{

    Q_ASSERT(widget);

    bool added=false;

    int index = mMainLayout->indexOf(widget);

    if (index == -1) {

        mMainLayout->addItem(widget);

        added=true;

    }

    return added;

}

void BubbleManager::removeFromLayout(QGraphicsWidget* widget)

{

    mMainLayout->removeItem(widget);

}

void BubbleManager::connectSignals(QGraphicsWidget* widget)

{

    QList<BubbleHandler*>* handlers = mWidgetManager->handlers(widget);

    if (handlers) {

        foreach (BubbleHandler* handler, *handlers) {

            connect(handler,SIGNAL(headerSelected(int)),

                    SLOT(showExpanded(int)));

        }

    }

}

void BubbleManager::setViewData(QGraphicsWidget* view)

{

    Q_ASSERT(view);

    QList<BubbleHandler*>* handlers =

            mWidgetManager->handlers(view);

    if (handlers) {

        if (isConferenceExpanded()) {

            // only conference call is displayed

            Q_ASSERT(handlers->count()==1);

            BubbleHandler* handler = handlers->at(0);

            handler->readBubbleHeader(*mConferenceHeader);

            mActiveHandlers.append(handler);

        } else {

            int i=0;

            foreach (BubbleHandler* handler, *handlers) {

                findNextDrawableHeader(i);

                handler->readBubbleHeader(*mActiveHeaders.at(i));

                mActiveHandlers.append(handler);

                i++;

                if (i==mActiveHeaders.count()) {

                    break;

                }

            }

        }

    }

}

/**

* Takes a new call header in use.

* Returns bubble idenfication number.

*/

int BubbleManager::createCallHeader()

{

    Q_ASSERT( mIsReadyToDraw > 0 );

    quint8 index = 0;

    while ( mCallHeaders[index]->isUsed( ) ) {

        index++;

        Q_ASSERT( index < mCallHeaders.size() );

    }

    BubbleHeader* header = mCallHeaders[index];

    header->setIsUsed( true );

    mActiveHeaders.insert( 0, header ); // in priority order

    return header->bubbleId();

}

/**

* Removes call header from use

*/

void BubbleManager::removeCallHeader( int bubbleId )

{

    Q_ASSERT( mIsReadyToDraw > 0 );

    for ( int i=0; i < mActiveHeaders.size(); i++ ) {

        if ( mActiveHeaders[i]->bubbleId() == bubbleId ) {

            QString image = mActiveHeaders[i]->callImage();

            mActiveHeaders[i]->reset();

            mActiveHeaders.remove( i );

            releaseImageIfNotUsed(image);

            break;

        }

    }

}

/**

* Finds header by bubble id.

*/

bool BubbleManager::findActiveHeader( int bubbleId, BubbleHeader*& header )

{

    header = 0;

    for ( int i=0; i < mActiveHeaders.size(); i++ ) {

        if ( mActiveHeaders[i]->bubbleId() == bubbleId ) {

            header = mActiveHeaders[i];

            break;

        }

    }

    return header ? true : false;

}

void BubbleManager::findNextDrawableHeader(int& index) const

{

    while (mActiveHeaders.at(index)->isInConference()) {

        index++;

    }

}

/**

* Sets call state to header.

*/

void BubbleManager::setState(

    int bubbleId,

    PhoneCallState state )

{

    Q_ASSERT( mIsReadyToDraw > 0 );

    BubbleHeader* header = 0;

    findActiveHeader( bubbleId, header );     

    Q_ASSERT( header );

    BubbleManager::PhoneCallState oldState =

        header->callState();

    if ( shownHeaderCount()<3 &&

         !header->isInConference() &&

         (expandedBubble() != bubbleId) &&

         (oldState==OnHold && state==Active) ) {

        // send key swap -> make active call expanded

        int i = mActiveHeaders.indexOf(header);

        mActiveHeaders.remove(i);

        mActiveHeaders.insert(0, header);

    }

    header->setCallState( state );

}

/**

* Sets text label to header. For conf also.

* Text to be seen in bubble ( e.g. 'on hold' )

*/

void BubbleManager::setLabel(

    int bubbleId,

    const QString& text,

    Qt::TextElideMode clipDirection )

{

    Q_ASSERT( mIsReadyToDraw > 0 );

    BubbleHeader* header = 0;

    findActiveHeader( bubbleId, header );     

    Q_ASSERT( header );

    header->setText( text, clipDirection );

}

/**

* Sets caller's line identification ( name or number) to header.

* For conf also. Caller's CLI ( e.g. 'Mother' )

*/

void BubbleManager::setCli(

    int bubbleId,

    const QString& cliText,

    Qt::TextElideMode clipDirection )

{

    Q_ASSERT( mIsReadyToDraw > 0 );

    BubbleHeader* header = 0;

    findActiveHeader( bubbleId, header );     

    Q_ASSERT( header );

    header->setCli( cliText, clipDirection );

}

/**

* Updates caller's line identification ( name or number) to header.

* Caller's CLI ( e.g. 'Daddy' )-

*/

void BubbleManager::updateCLI(

    int bubbleId,

    const QString& cliText,

    Qt::TextElideMode clipDirection )

{

    BubbleHeader* header = 0;

    findActiveHeader( bubbleId, header );     

    Q_ASSERT( header );

    header->setCli( cliText, clipDirection );

    // ToDo: take care of redrawing

}

/**

* Number or voip adress, when phonebook name takes Cli.

*/

void BubbleManager::setSecondaryCli(

    int bubbleId,

    const QString& cliText,

    Qt::TextElideMode clipDirection )

{

    Q_ASSERT( mIsReadyToDraw > 0 );

    BubbleHeader* header = 0;

    findActiveHeader( bubbleId, header );     

    Q_ASSERT( header );

    header->setSecondaryCli( cliText, clipDirection );

}

/**

* Sets call time or cost text to header. For conf also.

*/

void BubbleManager::setCallTime(

    int bubbleId,

    const QString& callTime )

{

    Q_ASSERT( mIsReadyToDraw > 0 );

    BubbleHeader* header = 0;

    findActiveHeader( bubbleId, header );     

    Q_ASSERT( header );

    header->setTimerCost( callTime );

}

/**

* Updates call time or cost text to header.  For conf also.

* Timer or cost text ( e.g. '00:12:34' or '£01.23' ).

*/

void BubbleManager::updateCallTime(

    int bubbleId,

    const QString& callTime )

{

    BubbleHeader* header = 0;

    findActiveHeader( bubbleId, header );     

    Q_ASSERT( header );

    header->setTimerCost( callTime );

    foreach (BubbleHandler* handler,mActiveHandlers) {

        handler->updateTimerDisplayNow();

    }

}

/**

* Attach a call image to header.

*/

void BubbleManager::setCallObjectImage(

    int bubbleId,

    const QString& fileName )

{

    BubbleHeader* header = 0;

    findActiveHeader( bubbleId, header );     

    Q_ASSERT( header );

    header->setCallImage(fileName);

}

/**

* Attach the theme call image to header.

*/

void BubbleManager::setCallObjectFromTheme(

    int bubbleId )

{

    BubbleHeader* header = 0;

    findActiveHeader( bubbleId, header );     

    Q_ASSERT( header );

    header->setShowDefaultAvatar(true);

}

/**

* Sets call flags to header.

*/

void BubbleManager::setCallFlags(

    int bubbleId,

    int flags )

{

    Q_ASSERT( mIsReadyToDraw > 0 );

    BubbleHeader* header = 0;

    findActiveHeader( bubbleId, header );     

    Q_ASSERT( header );

    header->setCallFlags( flags );

}

/**

* Sets call flags to header.

*/

void BubbleManager::setCallFlag(

    int bubbleId,

    PhoneCallFlags flag,

    bool set )

{

    Q_ASSERT( mIsReadyToDraw > 0 );

    BubbleHeader* header = 0;

    findActiveHeader( bubbleId, header );     

    Q_ASSERT( header );

    if ( set ) {

        header->setCallFlag( flag );

    }

    else {

        header->removeCallFlag( flag );

    }

}

/**

* Sets number type.

*/

void BubbleManager::setNumberType(

    int bubbleId,

    PhoneNumberType type )

{

    Q_ASSERT( mIsReadyToDraw > 0 );

    BubbleHeader* header = 0;

    findActiveHeader( bubbleId, header );     

    Q_ASSERT( header );