/*

* Copyright (c) 2006 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:  Main view array interface to get  the array items to be displayed

				 via the listbox for the Single View

*

*/

//platform includes

#include <aknview.h>

#include <eiklbo.h>

#include <badesca.h>

#include <bldvariant.hrh>

#include <e32cmn.h>

#include <e32def.h>

#include <aknenv.h>

#include <StringLoader.h>

#include <barsread.h>

#include <chatNG.rsg>

#include <collate.h>

#include "ImpsCSPAllErrors.h"

#include "chatdefinitions.h"

#include "ChatDebugPrint.h"

#include "CCAArrayItemPC.h"

#include "MCAStoredContacts.h"

#include "MCAContactLists.h"

#include "MCAContactList.h"

#include "ChatDebugAssert.h"

#include "MCAStoredContactsObserver.h"

#include "CCAStorageManagerFactory.h"

#include "MCASettingsObserver.h"

#include "CAPresenceManager.h"

#include "MCAChatInterface.h"

#include "IMUtils.h"

#include "CCAMainViewArrayPC.h"

#include "MCAMessageContainerInfo.h"

#include <cimpspresenceconnectionuing.h>

#include <CIMPSSAPSettingsStore.h>

#include <CIMPSSAPSettings.h>

#include <CPEngNWSessionSlotID2.h>

#include "CCAPCUtils.h"

#include "PublicEngineDefinitions.h"

#include "CCAEngine.h"

#include "MCAInvite.h"

#include "MCAInvitation.h"

#include "ChatDebugPrint.h"

#include "CCAServerContactsArrayPC.h"

#include "MCAStoredContact.h"

#include "MCAStoredGroups.h"

#include "MCAStoredGroup.h"

#include "MCASingleListViewCB.h"

#include "CAUtils.h"

#include "MCAMessage.h"

#include "CCAGroupListArrayPC.h"

// The Settings have been moved to Cenrep (also retained in the Resource file),

// so the enums for keys and central repository header is added here

#include 	"VariantKeys.h"

#include "MCABlocking.h"

const TInt KGranularity = 2;    //array granularity

_LIT( KContactOnlineIconA,      "12\t" );

_LIT( KEmptyIconB,              "11\t" );

_LIT( KContactWatcherIcon,      "\t2" );

#ifdef RD_MESSAGE_INDICATION_NEW

_LIT( KContactMsgPendingIcon,   "3\t" );

#else

_LIT( KContactMsgPendingIcon,   "\t3" );

#endif

// ============================ MEMBER FUNCTIONS ===============================

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

// CCAMainViewArrayPC::CCAMainViewArrayPC

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

CCAMainViewArrayPC::CCAMainViewArrayPC( CCAEngine& aEngine, MCAContactListModel& aContactListModel,

                                        MCAChatInterface& aChatInterface )

        : iEngine( aEngine ),

        iContactListModel( aContactListModel ),

        iChatInterface( aChatInterface ),

        iInviteInterface( *iEngine.GetInvitationInterface() ),

        iOwnDataIndex( KOwnDataIndex ),	//	starting index of Owndata, it's 0 as per ui spec

        iOpenChatsIndex( KOpenChatsIndex ),//	starting index of OpenChats, it's 1 as per ui spec

        iContactListIndex( KOwnDataIndex ),	//	starting index of all the contactlists......

        iOpenChatListItemExpanded( EFalse ),// initially the convesation in collapsed state..

        iSelectionMode( /*EFalse*/TEnumsPC::ESingleListViewSelect ),

        iExpandAll( EFalse ),

        iSettings( aEngine.GetInternalSettingsInterface() )

// inializing the settings

    {

    iGroupCountDown = EFalse;

    iOnlySavedGroups = 0;

    iForceExpandDone = ETrue; // set this to false initially

    iPToPChatCount = 0;

    iItemDetails.aItemID.Copy( KNullDesC );

    iItemDetails.aItemID.Copy( KNullDesC );

    iItemDetails.aItem = TEnumsPC::EInvalid;

    }

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

// CCAMainViewArrayPC::NewL

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

CCAMainViewArrayPC* CCAMainViewArrayPC::NewL( CCAEngine& aEngine,

                                              MCAContactListModel& aContactListModel,

                                              MCAChatInterface& aChatInterface )

    {

    CCAMainViewArrayPC* self = new ( ELeave ) CCAMainViewArrayPC( aEngine,

                                                                  aContactListModel,

                                                                  aChatInterface );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCAMainViewArrayPC::ConstructL

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

void CCAMainViewArrayPC::ConstructL()

    {

    iMaxLengthOfIcons =

        KEmptyIconB().Length() + // longest B-column icon

        KContactOnlineIconA().Length() + // longest A-Column icon

        KContactWatcherIcon().Length() +

        KContactMsgPendingIcon().Length();

    iData = HBufC::NewL( KFriendsListMaxIdentificationLength );

    iContactInterface = CCAStorageManagerFactory::ContactListInterfaceL();

    iContactInterface->AddObserverL( this );// listen these events..

    CAPresenceManager::InstanceL()->SetWatcherObserver( this );

    iOwnDataAdded = false;

    iEngine.GetInvitationInterface()->AddInviteObserver( this );

    iSettings->AddObserverL( this );  //register with engine

    // Register this as chat observer

    iChatInterface.RegisterChatObserver( this );

    // This callback is required when ever the server is added or deleted

    // we get a callback and update the singlelist

    iSAPSettingsStore = CIMPSSAPSettingsStore::NewL();

    iSAPSettingsStore->AddObserverL( this, EIMPSIMAccessGroup );

    iGroupArray =  CCAGroupListArrayPC::NewL();

    //register for stored groups observer event

    iChatGroups = CCAStorageManagerFactory::GroupListInterfaceL();

    iChatGroups->AddObserverL( this );

    iLastloggedinUserId = NULL;

    iConnectionUI = CIMPSPresenceConnectionUi::NewL( EIMPSConnClientIM );

    }

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

// CCAMainViewArrayPC::SetSkipStorageEvents

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

void CCAMainViewArrayPC::SetSkipStorageEvents( TBool aSkip )

    {

    iSkipStorageEvents = aSkip;

    }

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

// CCAMainViewArrayPC::GetSkipStorageEvents

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

TBool CCAMainViewArrayPC::GetSkipStorageEvents()

    {

    return iSkipStorageEvents;

    }

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

// CCAMainViewArrayPC::~CCAMainViewArrayPC

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

CCAMainViewArrayPC::~CCAMainViewArrayPC()

    {

    delete iData;

    //ignore codescanner warning

    // because dest is getting called

    MCAPresence* presenceManager = NULL;

    TRAP_IGNORE( presenceManager = CAPresenceManager::InstanceL() );

    if ( presenceManager )

        {

        presenceManager->SetWatcherObserver( NULL );

        }

    iChatInterface.UnregisterChatObserver( this );

    iMainViewListItemArray.ResetAndDestroy();

    iMainViewListItemArray.Close();

    iOpenChatsArray.ResetAndDestroy();

    iOpenChatsArray.Close();

    iMainViewObservers.ResetAndDestroy();

    iMainViewObservers.Close();

    iInvitationsArray.Reset();

    iInvitationsArray.Close();

    if ( iContactInterface )

        {

        iContactInterface->RemoveObserver( this );

        }

    if ( iEngine.GetInvitationInterface() )

        {

        iEngine.GetInvitationInterface()->RemoveInviteObserver( this );

        }

    // Note : remove the observer before the set value since after setting the

    // value we get callback which we are not intrested as the application is exited

    // no point in calling the reset array and trying to fill the data

    if ( iSettings )

        {

        iSettings->RemoveObserver( this ); // remove from engine

        }

    //unregister for stored groups observer event

    if ( iChatGroups )

        {

        iChatGroups->RemoveObserver( this );

        }

    iSAPSettingsStore->RemoveObserver( this );

    delete iSAPSettingsStore;

    delete iGroupArray;

    delete iLastloggedinUserId;

    delete iConnectionUI;

    iRefreshConvArray.ResetAndDestroy();

    }

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

// CCAMainViewArrayPC::IsForceExpanded

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

TBool CCAMainViewArrayPC::IsForceExpanded() const

    {

    return iContactListModel.IsForceExpanded();

    }

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

// CCAMainViewArrayPC::SetMsgPending

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

void CCAMainViewArrayPC::SetMsgPending( TInt aPendingMsgs, TInt aIndex )

    {

    TInt index = aIndex - iContactListIndex <= 0 ? 0 : aIndex - iContactListIndex ;

    if ( GetType( aIndex ) == TEnumsPC::EContactItem  )

        {

        MCAContactListModel::SItem item = iContactListModel.Item( index );

        MCAStoredContact* Contact = item.iContact;

        if ( Contact )

            {

            Contact->SetPendingMessages( aPendingMsgs );

            }

        }

    }

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

// CCAMainViewArrayPC::GetItemNameTextL

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

TPtrC CCAMainViewArrayPC::GetItemNameText( TInt aIndex )

    {

    TEnumsPC::TItem itemtype = GetType( aIndex );

    /* Codescanner warning is ignored, since Bound check is done

     * inside the GetType()

     * method*/

    /*aIndex >= iOpenChatsIndex*/

    switch ( itemtype )

        {

        case TEnumsPC::EOwnStatusItem:

            {

            MCAArrayItemPC *arrayItemPC = ( MCAArrayItemPC * )iMainViewListItemArray[aIndex];

            return arrayItemPC->GetItemNameText();

            }

        case TEnumsPC::EOpenChatsListItem:

        case TEnumsPC::EGroupItem:

        case TEnumsPC::EConversationItem:

        case TEnumsPC::EInviteItem:

            {

            if ( aIndex <= iContactListIndex )

                {

                MCAArrayItemPC *arrayItemPC = ( MCAArrayItemPC * )iOpenChatsArray[aIndex - iOpenChatsIndex];

                return arrayItemPC->GetItemNameText();

                }

            break;

            }

        case TEnumsPC::EContactListItem:

        case TEnumsPC::EContactItem:

            {

            TPtrC itemNameText( KNullDesC );

            TRAP_IGNORE( itemNameText.Set( GetFormattedItemNameTextL( aIndex ) ) );

            return itemNameText;

            }

        case TEnumsPC::EInvalid:

        default:

            {

            return KNullDesC();

            }

        }

    return KNullDesC();

    }

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

// CCAMainViewArrayPC::GetFormattedItemNameTextL

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

TPtr CCAMainViewArrayPC::GetFormattedItemNameTextL( TInt aIndex )

    {

    TEnumsPC::TItem itemType = GetType( aIndex );

    TInt index = GetItemEngineIndex( aIndex ) ;

    MCAContactListModel::SItem item = iContactListModel.Item( index );

    MCAContactList* list = item.iContactList;

    TPtr buffer( iData->Des() );

    buffer.Zero();

    switch ( itemType )

        {

        case TEnumsPC::EContactListItem:

            {

            if ( list )

                {

                // C-column

                // append "number of online contacts / total number

                // of contacts" after identification

                CArrayFix<TInt>* intArray = new ( ELeave ) CArrayFixFlat<TInt>( KGranularity );

                CleanupStack::PushL( intArray );

                // Append number of online contacts

                TStorageManagerGlobals::TFilterType filterType

                = GetFilterConverterUITOEngine( GetSingleListArrayFilter() );

                intArray->AppendL( list->FilteredCount( filterType ) );

                // Append total number of contacts, depends on how blocked contacts are handled

                if ( IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_BLOCKING ) != 2 )

                    {

                    // Blocked contacts are hidden or removed, do not include to total count.

                    // Removed is also handled here because user may log in with different clients

                    // that handle blocked contacts differently.

                    intArray->AppendL( list->FilteredCount(

                                           TStorageManagerGlobals::EFilterNonBlocked ) );

                    }

                else

                    {

                    // Blocked contacs are shown, Count() returns correct value

                    intArray->AppendL( list->Count() );

                    }

                CDesCArray* array = new( ELeave ) CDesCArrayFlat( 1 ); // one items

                CleanupStack::PushL( array );

                array->AppendL( KNullDesC );

                HBufC* textNumbers = StringLoader::LoadLC( R_QTN_CHAT_CONTACTLIST_CONTACTLIST,

                                                           *array, *intArray );

                array->Reset();

                TPtr textNumbersPtr( textNumbers->Des() );

                TPtrC identification ( list->DisplayName() );

                array->AppendL( identification.Left( buffer.MaxLength() -

                                                     iMaxLengthOfIcons - textNumbersPtr.Length() ) );

                HBufC* listString = StringLoader::LoadLC( R_QTN_CHAT_CONTACTLIST_CONTACTLIST,

                                                          *array, *intArray );

                TPtr listStringPtr( listString->Des() );

                buffer.Append( listStringPtr );

                //Code scanner warning ignored

                CleanupStack::PopAndDestroy( 4, intArray ); //array,textNumbers,listString,intArray

                }

            break;

            }

        case TEnumsPC::EOwnStatusItem:

        case TEnumsPC::EContactItem:

            {

            buffer.Append( iContactListModel.MdcaPoint( index ) );

            break;

            }

        default:

            {

            break;

            }

        }

    return buffer;

    }

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

// CCAMainViewArrayPC::Filter

// (other items were commented in a header).

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

//

TEnumsPC::TFilterType CCAMainViewArrayPC::Filter()

    {

    return iFilter;

    }

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

// CCAMainViewArrayPC::GetDefaultFilter

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

TEnumsPC::TFilterType CCAMainViewArrayPC::GetDefaultFilter() const

    {

    return iDefaultFilter;

    }

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

// CCAMainViewArrayPC::SetDefaultFilter

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

void CCAMainViewArrayPC::SetDefaultFilter( TEnumsPC::TFilterType aFilter )

    {

    iDefaultFilter = aFilter;

    iContactListModel.SetDefaultFilter( GetFilterConverterUITOEngine( aFilter ) );

    }

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

// CCAMainViewArrayPC::SetDefaultFilter

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

void CCAMainViewArrayPC::SetFilter( TEnumsPC::TFilterType aFilter )

    {

    iFilter = aFilter;

    iContactListModel.SetFilter( GetFilterConverterUITOEngine( aFilter ) );

    }

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

// CCAMainViewArrayPC::GetFilterConverterUITOEngine

// (other items were commented in a header).

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

//

TStorageManagerGlobals::TFilterType

CCAMainViewArrayPC::GetFilterConverterUITOEngine( TEnumsPC::TFilterType aFilter )

    {

    TStorageManagerGlobals::TFilterType filter;

    switch ( aFilter )

        {

        case TEnumsPC::EFilterAll:

            {

            filter = TStorageManagerGlobals::EFilterAll;

            break;

            }

        case TEnumsPC::EFilterAndOperation:

            {

            filter = TStorageManagerGlobals::EFilterAndOperation;

            break;

            }

        case TEnumsPC::EFilterOnline:

            {

            filter = TStorageManagerGlobals::EFilterOnline;

            break;

            }

        case TEnumsPC::EFilterAway:

            {

            filter = TStorageManagerGlobals::EFilterAway;

            break;

            }

        case TEnumsPC::EFilterNonOffline:

            {

            filter = TStorageManagerGlobals::EFilterNonOffline;

            break;

            }

        case TEnumsPC::EFilterNonBlocked:

            {

            filter = TStorageManagerGlobals::EFilterNonBlocked;

            break;

            }

        case TEnumsPC::EFilterNonOfflineNonBlockedAndOperation:

            {

            filter = TStorageManagerGlobals::TFilterType

                     (

                         TStorageManagerGlobals::EFilterNonOffline |

                         TStorageManagerGlobals::EFilterNonBlocked +

                         TStorageManagerGlobals::EFilterAndOperation

                     );

            break;

            }

        case TEnumsPC::EFilterAllNonBlockedAndOperation:

            {

            filter = TStorageManagerGlobals::TFilterType

                     (

                         TStorageManagerGlobals::EFilterAll |

                         TStorageManagerGlobals::EFilterNonBlocked +

                         TStorageManagerGlobals::EFilterAndOperation

                     );

            break;

            }

        case TEnumsPC::EFilterNonOfflineNonBlockedNonOfflineOperation:

            {

            filter = TStorageManagerGlobals::TFilterType

                     (

                         ( TStorageManagerGlobals::EFilterNonOffline

                           | TStorageManagerGlobals::EFilterNonBlocked

                           + TStorageManagerGlobals::EFilterAndOperation

                         )

                         | TStorageManagerGlobals::EFilterNonOffline

                         + TStorageManagerGlobals::EFilterAndOperation

                     );

            break;

            }

        case TEnumsPC::EFilterAllNonBlockedNonOfflineOperation:

            {

            filter = TStorageManagerGlobals::TFilterType