/*!

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

*

*/

#include <QtGui>

#include <QDebug>

#include <hbaction.h>

#include <hbtoolbar.h>

#include <bubblemanager2.h>

#include <hbmenu.h>

#include <hbmainwindow.h>

#include "bubbletestview.h"

#include "bubbletester.h"

BubbleTestView::BubbleTestView(HbMainWindow& window, QGraphicsItem *parent) :

    HbView (parent), mMainWindow(window), mMuted(0), mConfBubbleId(-1),

    mProvideJoin(false)

{

    setFlags (QGraphicsItem::ItemIsFocusable);

    setFocusPolicy (Qt::StrongFocus);

    setTitle("BubbleTest2");

    // the widget under the test

    mBubbleManager = new BubbleManager (this);

    setWidget(mBubbleManager);

    // init toolbar

    createToolBarActions();

    //toolBar()->setOrientation(mMainWindow.orientation());

    connect( &mMainWindow,SIGNAL(orientationChanged(Qt::Orientation)),

             this,SLOT(handleOrientationChange(Qt::Orientation)));

    // init menu

    createMenuActions();

    // create actions for push buttons

    createBubbleActions();

    // tester

    mBubbleTester = new BubbleTester();

    connect(mBubbleTester,SIGNAL(dataChanged()),this,SLOT(handleTesterDataChanged()));

    mBubbleTester->connectToServer();

    // create state map

    mStateMap.insert("Idle", BubbleManagerIF::None );

    mStateMap.insert("Incoming", BubbleManagerIF::Incoming );

    mStateMap.insert("Active", BubbleManagerIF::Active );

    mStateMap.insert("Disconnected", BubbleManagerIF::Disconnected );

    mStateMap.insert("Outgoing", BubbleManagerIF::Outgoing );

    mStateMap.insert("Waiting", BubbleManagerIF::Waiting );

    mStateMap.insert("OnHold", BubbleManagerIF::OnHold );

    // create label map

    mLabelMap.insert("Idle", "" );

    mLabelMap.insert("Incoming", "calling" );

    mLabelMap.insert("Active", "" );

    mLabelMap.insert("Disconnected", "disconnected" );

    mLabelMap.insert("Outgoing", "Calling" );

    mLabelMap.insert("Waiting", "waiting" );

    mLabelMap.insert("OnHold", "on hold" );

}

BubbleTestView::~BubbleTestView()

{

    delete mBubbleTester;

}

void BubbleTestView::keyPressEvent(QKeyEvent *event)

{

    switch( event->key() )

    {

    case '1': // create incoming call

    {

        if ( mEmergencyCall->isChecked() ) {

            return; // not supported

        }

        if ( mCalls.count() == 0 ) {

            bubbleManager().startChanges();

            int bubbleId = bubbleManager().createCallHeader();

            setBubbleData(bubbleId, BubbleManager::Incoming);

            setBubbleActions(bubbleId, BubbleManager::Incoming);

            bubbleManager().endChanges();

            // store this call

            TestCall call;

            call.bubbleId = bubbleId;

            call.callState = BubbleManager::Incoming;

            mCalls.append( call );

            updateToolBarActions();

        } else if ( !initializingCallExists() ) {

            // waiting call

            bubbleManager().startChanges();

            int bubbleId = bubbleManager().createCallHeader();

            setBubbleData(bubbleId, BubbleManager::Waiting);

            setBubbleActions( bubbleId, BubbleManager::Waiting );

            bubbleManager().setExpandedConferenceCallHeader(false);

            bubbleManager().endChanges();

            // store this call

            TestCall call;

            call.bubbleId = bubbleId;

            call.callState = BubbleManager::Waiting;

            mCalls.append( call );

            setExpandActions();

            updateToolBarActions();

        }

        break;

    }

    case '2': // create outgoing call

    {

        if ( !initializingCallExists() && (callCount()<3) ) {

            bubbleManager().startChanges();

            int bubbleId = bubbleManager().createCallHeader();

            setBubbleData(bubbleId, BubbleManager::Outgoing);

            setBubbleActions( bubbleId, BubbleManager::Outgoing );

            bubbleManager().endChanges();

            // store this call

            TestCall call;

            call.bubbleId = bubbleId;

            call.callState = BubbleManager::Outgoing;

            mCalls.append( call );

            bubbleManager().setBubbleSelectionDisabled(false);

            updateToolBarActions();

       }

       break;

    }

    case '3': // connect

    {

        int i,j;

        if (callIndexByState(BubbleManagerIF::Outgoing, i)) {

            // outgoing to alerting

            bubbleManager().startChanges();

            setBubbleData(mCalls[i].bubbleId, BubbleManager::Alerting);

            bubbleManager().endChanges();

            mCalls[i].callState = BubbleManager::Alerting;

            return;

        }

        if (callCount()==3) {

            // replace active call

            bubbleManager().startChanges();

            Q_ASSERT(callIndexByState(BubbleManagerIF::Active, j));

            bubbleManager().removeCallHeader(mCalls[j].bubbleId);

            mCalls.removeAt(j);

            Q_ASSERT(callIndexByState(BubbleManagerIF::Waiting, i));

            setBubbleData(mCalls[i].bubbleId, BubbleManager::Active);

            setBubbleActions(mCalls[i].bubbleId, BubbleManager::Active);

            bubbleManager().endChanges();

            mCalls[i].callState = BubbleManager::Active;

            setExpandActions();

            updateToolBarActions();

            bubbleManager().setBubbleSelectionDisabled(false);

        } else if (callIndexByState(BubbleManagerIF::Incoming, i)||

                   callIndexByState(BubbleManagerIF::Alerting, i)||

                   callIndexByState(BubbleManagerIF::Waiting, i)) {

            bubbleManager().startChanges();

            setBubbleData(mCalls[i].bubbleId, BubbleManager::Active);

            mProvideJoin = true; // bit hackish

            setBubbleActions(mCalls[i].bubbleId, BubbleManager::Active);

            mProvideJoin = false;

            if (callIndexByState(BubbleManagerIF::Active, j)) {

                setBubbleData(mCalls[j].bubbleId, BubbleManager::OnHold);

                setBubbleActions(mCalls[j].bubbleId, BubbleManager::OnHold);

                mCalls[j].callState = BubbleManager::OnHold;

            }

            bubbleManager().endChanges();

            mCalls[i].callState = BubbleManager::Active;

            setExpandActions();

            updateToolBarActions();

            bubbleManager().setBubbleSelectionDisabled(false);

        }

        break;

    }

    case '4': // hold

    {

        int i,j;

        if (bubbleManager().isConferenceExpanded()) {

            toggleHoldConference();

        } else if (callCount()==1) {

            // toggle hold

            bubbleManager().startChanges();

            if (callIndexByState(BubbleManagerIF::Active, i)||

                callIndexByState(BubbleManagerIF::OnHold, i)) {

                BubbleManagerIF::PhoneCallState state =

                    mCalls[i].callState == BubbleManagerIF::Active ?

                    BubbleManagerIF::OnHold : BubbleManagerIF::Active;

                setBubbleData(mCalls[i].bubbleId, state);

                setBubbleActions(mCalls[i].bubbleId, state );

                mCalls[i].callState=state;

            }

            bubbleManager().endChanges();

            updateToolBarActions();

        } else if (callIndexByState(BubbleManagerIF::Active, i)) {

            // swap calls

            bubbleManager().startChanges();

            if (callIndexByState(BubbleManagerIF::OnHold, j)) {

                setBubbleData(mCalls[j].bubbleId, BubbleManager::Active);

                setBubbleActions(mCalls[j].bubbleId, BubbleManager::Active );

                mCalls[j].callState=BubbleManager::Active;

            }

            setBubbleData(mCalls[i].bubbleId, BubbleManager::OnHold);

            setBubbleActions(mCalls[i].bubbleId, BubbleManager::OnHold );

            mCalls[i].callState=BubbleManager::OnHold;

            if (conferenceCallExists()) {

                bubbleManager().setExpandedConferenceCallHeader(

                    bubbleIdByState(BubbleManager::Active)==mConfBubbleId);

            }

            bubbleManager().endChanges();

            setExpandActions();

            updateToolBarActions();

        } else if (callIndexByState(BubbleManagerIF::Waiting, i)) {

            // activate held call

            bubbleManager().startChanges();

            if (callIndexByState(BubbleManagerIF::OnHold, j)) {

                setBubbleData(mCalls[j].bubbleId, BubbleManager::Active);

                setBubbleActions(mCalls[j].bubbleId, BubbleManager::Active );

                mCalls[j].callState=BubbleManager::Active;

            }

            bubbleManager().endChanges();

            setExpandActions();

            updateToolBarActions();

        }

        break;

    }

    case '5': // disconnect

    {

        int i,j;

        if (callIndexByState(BubbleManagerIF::Disconnected, i)) {

            bubbleManager().startChanges();

            bubbleManager().removeCallHeader(mCalls[i].bubbleId);

            // remove call

            mCalls.removeAt(i);

            if (mMuted) {

                setMuted(); // unmute

            }

            bool expand = true;

            QListIterator<TestCall> calls(mCalls);

            while(calls.hasNext()) {

                TestCall call = calls.next();

                  if (!call.isConf && !call.isInConf) {

                      expand = false;

                  }

            }

            bubbleManager().setExpandedConferenceCallHeader(expand);

            bubbleManager().endChanges();

            updateToolBarActions();

            return;

        }

        if (callCount()) {

            int expanded = bubbleManager().expandedBubble();

            callIndexByBubbleId(expanded,i);

            bubbleManager().startChanges();

            if (mCalls.at(i).isConf) {

                bubbleManager().removeConference();

                mConfBubbleId = -1;

                mCalls.removeAt(i);

                QMutableListIterator<TestCall> calls(mCalls);

                j=0;

                while(calls.hasNext()) {                  

                    if (mCalls[j].isInConf) {

                        bubbleManager().removeCallHeader(mCalls[j].bubbleId);

                        mCalls.removeAt(j);

                    } else {

                        j++;

                    }

                    calls.next();

                }

            } else {

                setBubbleData(mCalls[i].bubbleId, BubbleManager::Disconnected);

                setBubbleActions(mCalls[i].bubbleId, BubbleManager::Disconnected);

                mCalls[i].callState=BubbleManager::Disconnected;

            }

            bubbleManager().endChanges();

            updateToolBarActions();

        }

        break;

    }

    case '7': // create/join conference

    {

        int activeCallId = bubbleIdByState(BubbleManagerIF::Active);

        int heldCallId = bubbleIdByState(BubbleManagerIF::OnHold);

        int i;

        if (conferenceCallExists()&&(activeCallId!=-1)) {

            int j;

            callIndexByBubbleId(mConfBubbleId,j);

            callIndexByBubbleId(activeCallId,i);

            mCalls[i].isInConf = true;

            mCalls[i].callState = BubbleManagerIF::Active;

            mCalls[j].callState = BubbleManagerIF::Active;

            bubbleManager().startChanges();

            bubbleManager().addRowToConference(activeCallId);

            bubbleManager().setExpandedConferenceCallHeader(true);

            bubbleManager().setState(mConfBubbleId,BubbleManagerIF::Active);

            setBubbleActions(mConfBubbleId,BubbleManagerIF::Active);

            bubbleManager().endChanges();            

        } else if (activeCallId!=-1 && heldCallId!=-1) {

            bubbleManager().startChanges();

            mConfBubbleId = bubbleManager().createConference(heldCallId, activeCallId);

            bubbleManager().setExpandedConferenceCallHeader(true);

            bubbleManager().setState(mConfBubbleId,BubbleManagerIF::Active);

            bubbleManager().setCli(mConfBubbleId,"Conference call",Qt::ElideRight);

            if (mCallTimer->isChecked()) {

                bubbleManager().setCallTime( mConfBubbleId, "0:00" );

            }

            bubbleManager().addAction(mConfBubbleId, mHold);

            bubbleManager().addAction(mConfBubbleId, mEndConference);

            bubbleManager().clearParticipantListActions();

            bubbleManager().addParticipantListAction(mPrivate);

            bubbleManager().addParticipantListAction(mDrop);

            bubbleManager().setState(heldCallId,BubbleManagerIF::Active);

            bubbleManager().setCallFlag(mConfBubbleId, BubbleManager::NoCiphering,

                                        mCipheringOff->isChecked());

            bubbleManager().endChanges();

            callIndexByBubbleId(activeCallId,i);

            mCalls[i].isInConf = true;

            mCalls[i].callState = BubbleManagerIF::Active;

            callIndexByBubbleId(heldCallId,i);

            mCalls[i].isInConf = true;

            mCalls[i].callState = BubbleManagerIF::Active;

            // store the call

            TestCall call;

            call.bubbleId = mConfBubbleId;

            call.callState = BubbleManagerIF::Active;

            call.isConf = true;

            call.isInConf = false;

            mCalls.append(call);

        }

        break;

    }

    case '9': // conference shortcut

    {

        conferenceWizard();

        break;

    }

    case '0': // updates

    case Qt::Key_Space: // updates

    {

        if (mCallTimer->isChecked()) {

            foreach (TestCall call, mCalls) {

                if ( call.callState == BubbleManager::Active ||

                     call.callState == BubbleManager::OnHold ) {

                    bubbleManager().updateCallTime(call.bubbleId,"0:01");

                }

            }

        }

    }

    default:

    break;

    }

}

bool BubbleTestView::initializingCallExists() const

{

    bool result = false;

    foreach(TestCall call, mCalls) {

        if (call.callState>=BubbleManagerIF::Incoming) {

            result = true;

            break;

        }

    }

    return result;

}

bool BubbleTestView::conferenceCallExists() const

{

    bool result = false;

    QListIterator<TestCall> i(mCalls);

    while (i.hasNext()) {

        if (i.next().isConf) {

            result = true;

            break;

        }

    }

    return result;

}

int BubbleTestView::callCount() const

{

    int count = 0;

    foreach(TestCall call, mCalls) {

        if (!call.isInConf) {

            count++;

        }

    }

    return count;

}

bool BubbleTestView::callIndexByState(

    BubbleManagerIF::PhoneCallState state, int& index)

{

    bool result = false;

    int i = 0;

    foreach(TestCall call, mCalls) {

        if (call.callState==state && !call.isInConf) {

            result = true;

            index = i;

            break;

        }

        i++;

    }

    return result;

}

bool BubbleTestView::callIndexByBubbleId(int bubbleId, int& index)

{

    bool result = false;

    int i = 0;

    foreach(TestCall call, mCalls) {

        if (call.bubbleId==bubbleId) {

            result = true;

            index = i;

            break;

        }

        i++;

    }

    return result;

}

BubbleManagerIF& BubbleTestView::bubbleManager()

{

    return *mBubbleManager;

}

void BubbleTestView::setBubbleData(int bubble, BubbleManagerIF::PhoneCallState state)

{

    bubbleManager().setState(bubble, state);

    switch (state) {

    case BubbleManager::Incoming:

        {

        if ( mContactName->isChecked() ) {

            bubbleManager().setCli(bubble, "Gloria Andersson", Qt::ElideRight);

            bubbleManager().setSecondaryCli( bubble, "+35850123456789" );

            mPhoneNumber.clear();

        } else {

            mPhoneNumber.append("+35850123456789");

            bubbleManager().setCli(bubble, mPhoneNumber, Qt::ElideRight);

        }

        setCallObject(bubble, ":resources/contactpic.jpg");

        bubbleManager().setNumberType(bubble, BubbleManager::Mobile);

        bubbleManager().setCallFlag(bubble, BubbleManager::Diverted, mCallDivert->isChecked());

        bubbleManager().setCallFlag(bubble, BubbleManager::NoCiphering, mCipheringOff->isChecked());

        bubbleManager().setLabel(bubble, "calling", Qt::ElideRight);

        break;

        }

    case BubbleManager::Waiting:

        {

        if ( mContactName->isChecked() ) {

            if (callCount()==2) {

                bubbleManager().setCli(bubble, "Mary Poppins", Qt::ElideRight);

                bubbleManager().setSecondaryCli(bubble, "+35840987654321");

            } else {

                bubbleManager().setCli(bubble, "John Doe", Qt::ElideRight);

                bubbleManager().setSecondaryCli(bubble, "+35840987654321");

            }

            mPhoneNumber.clear();

        } else {

            if (callCount()==2) {

                mPhoneNumber.append("+35850232323232");

            } else {

                mPhoneNumber.append("+35840987654321");

            }

            bubbleManager().setCli(bubble, mPhoneNumber, Qt::ElideRight);

        }

        setCallObject(bubble, ":resources/contactpic3.png");

        bubbleManager().setNumberType(bubble, BubbleManager::Mobile);

        bubbleManager().setCallFlag(bubble, BubbleManager::Diverted, mCallDivert->isChecked());

        bubbleManager().setCallFlag(bubble, BubbleManager::NoCiphering, mCipheringOff->isChecked());

        bubbleManager().setLabel(bubble, "waiting", Qt::ElideRight);

        break;

        }

    case BubbleManager::Outgoing:

        {

        bubbleManager().setCallFlag(bubble, BubbleManager::NoCiphering, mCipheringOff->isChecked());

        if (mEmergencyCall->isChecked()) {

            bubbleManager().setCli( bubble, "emergency call", Qt::ElideRight );