/*

* Copyright (c) 2008 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:  implementation for command process array

*

*/

// INCLUDE FILES

#include <coemain.h>

#include    "vimpstdebugprint.h" 

#include "cvimpstprocessarray.h"

#include "cvimpststoragemanagerfactory.h"

#include "mvimpststorageserviceview.h"

#include "cvimpstprocessarrayitem.h"

#include "mvimpststorageitemmodel.h"

#include "tvimpstconsts.h"

#include "mvimpststoragecontactlist.h"

#include "mvimpststoragevpbkstorehandler.h"

#include "mvimpstengine.h"

#include "cvimpstprocessfriendrequestitem.h"

#include "mvimpstenginesubservice.h"

#include <MVPbkContactFieldTextData.h>

//rsg file for resource id

#include <vimpstuires.rsg>

#include "vimpstutils.h"

#include "mvimpstengineimsubservice.h"

#include "mvimpstenginepresencesubservice.h"

#include "vimpstdebugtrace.h"

#include "imcvuiparams.h"

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

// CVIMPSTProcessArray::CIMArrayProcess

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

//

CVIMPSTProcessArray::CVIMPSTProcessArray( MVIMPSTEngine& aEngine)

:iOwnDataIndex(KOwnDataIndex),

iContactListIndex(KOwnDataIndex),

iEngine(aEngine)

        {

        iServiceId = iEngine.ServiceId();

        }

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

// CVIMPSTProcessArray::~CVIMPSTProcessArray

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

//

CVIMPSTProcessArray::~CVIMPSTProcessArray()

    {

    TRACE( T_LIT("CVIMPSTProcessArray::~CVIMPSTProcessArray Start") );

    if(iContactInterface)

        {

        iContactInterface->RemoveObserver( this );	

        }

    iItemArray.ResetAndDestroy();

    //iItemArray.Close();

    iUnKnownContactArray.Close();

    iAddRequestArray.Close();

    if(iData)

        {

        delete iData;

        iData = NULL;

        }

    //Get IM SubService     

    MVIMPSTEngineSubService* subService1 =    	   

    (iEngine.SubService(TVIMPSTEnums::EIM));

    if(subService1)

        {

        MVIMPSTEngineIMSubService& imSubService = 

        MVIMPSTEngineIMSubService::Cast (*subService1);

        imSubService.UnRegisterChatObserver(this);

        }

    //subscribe for ownpresencechangeevent    			

    MVIMPSTEngineSubService* subService =    	   

    (iEngine.SubService(TVIMPSTEnums::EPresence));

    if(subService)

        {

        MVIMPSTEnginePresenceSubService& presence = 

        MVIMPSTEnginePresenceSubService::Cast (*subService);

        presence.UnRegisterPresenceEventObserver(this);

        } 

    TRACE( T_LIT("CVIMPSTProcessArray::~CVIMPSTProcessArray End") );

    }

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

// CVIMPSTProcessArray::NewL

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

//

CVIMPSTProcessArray* CVIMPSTProcessArray::NewL(

        MVIMPSTEngine& aEngine)

    {

    TRACE( T_LIT("CVIMPSTProcessArray::NewL Start") );

    CVIMPSTProcessArray* self = new(ELeave) CVIMPSTProcessArray(aEngine);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    TRACE( T_LIT("CVIMPSTProcessArray::NewL End") );

    return self;

    }

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

// CVIMPSTProcessArray::ConstructL

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

//

void CVIMPSTProcessArray::ConstructL()

    {

    TRACE( T_LIT("CVIMPSTProcessArray::ConstructL Start") );

    iContactInterface = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId);

    if(iContactInterface)

        {        

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

        }

    iContactListModel = CVIMPSTStorageManagerFactory::ItemModelInterfaceL(iServiceId);

    iLoginState = iEngine.ServiceState();

    iIMSupported = EFalse;

    iPresenceSupported = EFalse;

    //Get IM SubService     

    MVIMPSTEngineSubService* subService1 =(iEngine.SubService(TVIMPSTEnums::EIM));

    if(subService1)

        {

        MVIMPSTEngineIMSubService& imSubService = 

        MVIMPSTEngineIMSubService::Cast (*subService1);

        imSubService.RegisterChatObserver(this);

        iIMSupported = ETrue;

        }

    iData = HBufC::NewL(512);

    iAddRequestArray.Reset();

    iUnKnownContactArray.Reset();

    //subscribe for ownpresencechangeevent

    MVIMPSTEngineSubService* subService =    	   

    (iEngine.SubService(TVIMPSTEnums::EPresence));

    if(subService)

        {        

        MVIMPSTEnginePresenceSubService& presence = 

        MVIMPSTEnginePresenceSubService::Cast (*subService);

        presence.RegisterPresenceEventObserverL(this);     

        iPresenceSupported = ETrue;

        }

	ResetArray();

	TRACE( T_LIT("CVIMPSTProcessArray::ConstructL end") );

    }

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

// CVIMPSTProcessArray::HandleStorageChangeL

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

//

void CVIMPSTProcessArray::HandleStorageChangeL( TVIMPSTEnums::TVIMPSTStorgaeEventType aEventType,

			         							MVIMPSTStorageContactList* /*aList*/, 

				        						MVIMPSTStorageContact* aContact,

				        						TInt aContactIndex )

    {

    TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL Function Start") );

    // 0th index OwnItem + unknow contacts + add request

    aContactIndex = aContactIndex + 1 + iUnKnownContactArray.Count() + iAddRequestArray.Count();

    switch( aEventType )

        {

        case TVIMPSTEnums::EStorageContactReadComplete:

            {

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageContactReadComplete Start") );

            if(iProcessObservers)

                {

                /* passing 0 so that the focus is on owndata item */

                iProcessObservers->HandleAdditionL(TVIMPSTEnums::EOwnStatusItem, 0 ); // focus own item

                }

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageContactReadComplete End") );

            break;

            }

        case TVIMPSTEnums::EStorageContactFetchComplete:

            {

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageContactFetchComplete Start") );

            TRACE( T_LIT("HandleStorageChangeL EStorageContactFetchComplete iItemArray Count: %d"), iItemArray.Count() );

            if(iProcessObservers)

                {

                /* passing 0 so that the focus is on owndata item */

                iProcessObservers->HandleAdditionL(TVIMPSTEnums::EOwnStatusItem, 0 ); // focus own item

                }

            ResetArray();

            iFetchCompleted = ETrue;

            GetAndCreateOpenChatListL();

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageContactFetchComplete End") );

            break; 	

            }

        case TVIMPSTEnums::EStorageContactReading:

        case TVIMPSTEnums::EStorageContactFetching:

        case TVIMPSTEnums::EStorageContactSynchronizing:

            {

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageContactFetching/EStorageContactFetching Start") );

            /*

             *	This event occurs whenever we have contacts added to contactlist. This happens in the following scenarios

             *	1. At the time of login, when we fetch contacts, contact-by-contact is added to the storage. so we get this event.

             * 	2. When we add a contact manually (either from phonebook, or manu adding etc.. ) we get this callback.

             */

            TRACE( T_LIT("contactindex = %d"),aContactIndex );

            CVIMPSTProcessContactItem* contactItem = CVIMPSTProcessContactItem::NewL (*this, const_cast<TDesC&>(aContact->Name() ),

                    const_cast<TDesC&>(aContact->UserId() ),

                    aContact->ContactLink(),

                    const_cast<TDesC&>(aContact->StatusText()),

                    aContact->OnlineStatus());

            contactItem->SetAvatarIndex(aContact->AvatarIndex());

            /* All the time the index should be less than the item array's count, but during the fetch of contacts from cdb file to the view, 

             * if we havent got a contactviewready, and during that if I get contactaddition, before getting contactFetchComplete, we should keep 

             * appending the items to the array for display, once we get the entire list, its sorted anyway while insertion, and when presence occurs

             * the contacts are re-sorted. 

             */

            TRACE( T_LIT("itemarraycount = %d"),iItemArray.Count() );

            if (aContactIndex >= iItemArray.Count() )

                {

                TRACE( T_LIT("append contact item %d"), contactItem);

                iItemArray.Append(contactItem);

                }

            else

                {

                TRACE( T_LIT("Insert at index = %d"), aContactIndex);

                iItemArray.Insert(contactItem, aContactIndex );

                }               

            if(iProcessObservers)

                {

                /* passing 0 so that the focus is on owndata item */

                iProcessObservers->HandleAdditionL(TVIMPSTEnums::EOwnStatusItem, 0);

                }

            if( aContact->AvatarContent().Length() && iProcessObservers )

                {

                iProcessObservers->HandleAvatarChangeL( aContact->UserId() );

                }

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageContactFetching/EStorageContactFetching End") );

            break;

            }

        case TVIMPSTEnums::EStorageEventContactAddition:

            {

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageEventContactAddition Start") );

            TBool removed = RemoveFromUnknonOrInvitationListL( aContact->UserId(), EFalse );

            if( removed )

                {

                aContactIndex = aContactIndex - 1; // one contact is removed from iUnknownContactArray 

                }

            /*

             *	This event occurs whenever we have contacts added to contactlist. This happens in the following scenarios

             *	1. At the time of login, when we fetch contacts, contact-by-contact is added to the storage. so we get this event.

             * 	2. When we add a contact manually (either from phonebook, or manu adding etc.. ) we get this callback.

                 */

            TPtrC userId = aContact->UserId();

                TRACE( T_LIT("contactindex = %d"),aContactIndex );

                CVIMPSTProcessContactItem* contactItem = CVIMPSTProcessContactItem::NewL ( *this, aContact->Name() ,

                                                                                            userId,

                                                                                            aContact->ContactLink(),

                                                                                            const_cast<TDesC&>(aContact->StatusText()),

                                                                                            aContact->OnlineStatus() );

                contactItem->SetAvatarIndex(aContact->AvatarIndex());

            /* All the time the index should be less than the item array's count, but during the fetch of contacts from cdb file to the view, 

             * if we havent got a contactviewready, and during that if I get contactaddition, before getting contactFetchComplete, we should keep 

             * appending the items to the array for display, once we get the entire list, its sorted anyway while insertion, and when presence occurs

             * the contacts are re-sorted. 

             */

            TRACE( T_LIT("itemarraycount = %d"),iItemArray.Count() );

            if (aContactIndex >= iItemArray.Count() )

                {

                TRACE( T_LIT("append contact item = %d"), contactItem);

                iItemArray.Append(contactItem);

                }                

            else

                {

                TRACE( T_LIT("Insert at index = %d"), aContactIndex);

                iItemArray.Insert(contactItem, aContactIndex );

                }                

             // check if  pending message exist

            if( TVIMPSTEnums::ESVCERegistered == iLoginState && userId.Length() )

                {

                if( IsConversationExistL( userId ) )

                    {

                    contactItem->SetConversationOpen(ETrue);

                    }

                if( IsUnreadMessageExistsL( userId ) )

                    {

                    contactItem->SetMsgPending(ETrue);

                    }

                }

            if(iProcessObservers)

                {

                /* passing aContactIndex so that the focus is on owndata item */

                iProcessObservers->HandleAdditionL(TVIMPSTEnums::EContactItem, aContactIndex );

                }   

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageEventContactAddition End") );

            break;

            }

        case TVIMPSTEnums::EStorageEventContactDelete:

            {

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageEventContactDelete Start") );

            TRACE( T_LIT("contactindex = %d"),aContactIndex );

            TRACE( T_LIT("itemarraycount = %d"),iItemArray.Count() );

            if( aContactIndex < iItemArray.Count() )

                {

                MVIMPSTProcessArrayItem* deletedItem = iItemArray[ aContactIndex ]; 

                TRACE( T_LIT("contact removed in item array of index = %d"),aContactIndex );

                iItemArray.Remove (aContactIndex);

                delete deletedItem;

                iItemArray.Compress();

                TRACE( T_LIT("contactindex = %d"),aContactIndex );

                }

            if(iProcessObservers)

                {

                iProcessObservers->HandleDeletionL(TVIMPSTEnums::EContactItem, aContactIndex);

                }

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageEventContactDelete End") );

            break;

            }

        case TVIMPSTEnums::EStorageAvatarChange:

            {

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageAvatarChange Start") );

            if(iProcessObservers  && aContact )

                {

                TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageAvatarChange inside if") );

                TPtrC aUserId = aContact->UserId();

                TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageAvatarChange aUserId = %S"), &aUserId );

                iProcessObservers->HandleAvatarChangeL( aContact->UserId() );

                }

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageAvatarChange End") );

            break;            

            }

        case TVIMPSTEnums::EStorageOwnPresenceChange:

            {

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageAvatarChange Start") );

            if(iProcessObservers)

                {

                /* passing index as 0, so thta focus remains at the owndata item */

                iProcessObservers->HandleAdditionL(TVIMPSTEnums::EOwnStatusItem, KErrNotFound );

                }

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageAvatarChange End") );

            break;

            }

        case TVIMPSTEnums::EStorageMultiplePresenceChange:

	        {

	        TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageAvatarChange Start") );

	        // mostly this will get called after just login and fetch time

	        ResetArray();

            if(iProcessObservers )

                {

                iProcessObservers->HandleAdditionL(TVIMPSTEnums::EContactItem, KErrNotFound );

                }

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageAvatarChange End") );

	        break;	

	        }

        case TVIMPSTEnums::EStoragePresenceChange:

            {

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStoragePresenceChange Start") );

            /* 

             *	After Sort we get the new index... So first we need to remove the contact from the old position, 

             *	and then re-insert it at the correct obtained position (newIndex in this case)

             */

            TRACE( T_LIT("contactindex = %d"),aContactIndex );

            TRACE( T_LIT("itemarraycount = %d"),iItemArray.Count() );

            if( aContactIndex < iItemArray.Count() )

                {                

                TInt newIndex = iContactListModel->IndexOfContact( aContact );

                TRACE( T_LIT("new index = %d"),newIndex );

                CVIMPSTProcessContactItem* newItem = CVIMPSTProcessContactItem::NewL(*this, const_cast<TDesC&>(aContact->Name() ),

                        const_cast<TDesC&>(aContact->UserId() ),

                        aContact->ContactLink(),

                        const_cast<TDesC&>(aContact->StatusText()),

                        aContact->OnlineStatus() );

                MVIMPSTProcessArrayItem* oldItem = iItemArray[ aContactIndex ]; 

                newItem->SetAvatarIndex(aContact->AvatarIndex()); // copy the avatar index too.

                TBool isOldConversationExists(EFalse);

                TBool isOldMsgPending(EFalse);

                // checking if previously chat/msgs were existing

                if( TVIMPSTEnums::ESVCERegistered == iLoginState && aContact->UserId().Length() )

                    {

                    if( IsConversationExistL( aContact->UserId() ) )

                        {

                        isOldConversationExists = ETrue;

                        }

                    if( IsUnreadMessageExistsL( aContact->UserId() ) )

                        {

                        isOldMsgPending = ETrue;

                        }

                   }

                TRACE( T_LIT("contact removed in item array of index = %d"),aContactIndex );

                iItemArray.Remove(aContactIndex );

                delete oldItem;

                iItemArray.Compress();

                // restoring if previously chat/msgs were existing

                if( TVIMPSTEnums::ESVCERegistered == iLoginState && aContact->UserId().Length() )

                    {

                    if( isOldConversationExists )

                        {

                        newItem->SetConversationOpen(ETrue);

                        }

                    if( isOldMsgPending )

                        {

                        newItem->SetMsgPending(ETrue);

                        }

                    }

                // Add it in the new index

                newIndex = newIndex + 1 + iUnKnownContactArray.Count()+ iAddRequestArray.Count();

                if (newIndex >= iItemArray.Count())

                    {

                    TRACE( T_LIT("append contact item = %d"), newIndex);

                    iItemArray.Append (newItem);

                    }

                else

                    {

                    TRACE( T_LIT("Insert at index = %d"), newItem);

                    iItemArray.Insert (newItem, newIndex);

                    }   

                }

            if(iProcessObservers )

                {

                iProcessObservers->HandleAdditionL(TVIMPSTEnums::EContactItem, KErrNotFound );

                }

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStoragePresenceChange End") );

            break;

            }

        case TVIMPSTEnums::EStorageEventOwnUserChanged:

            {

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageEventOwnUserChanged Start") );

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL start Event = %d"),aEventType );

            ResetArray();

            if(iProcessObservers )

                {

                iProcessObservers->HandleDeletionL(TVIMPSTEnums::EOwnStatusItem, 0 ); // focus own item

                if( aContact )

                    {

                    iProcessObservers->HandleAvatarChangeL( aContact->UserId() );

                    }

                }

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageEventOwnUserChanged End") );

            break;

            }

        case TVIMPSTEnums::EStorageAllContactRemoved:

            {

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageAllContactRemoved Start") );

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageAllContactRemoved count = %d"), iItemArray.Count() );

            ResetArray();

            if(iProcessObservers )

                {

                iProcessObservers->HandleDeletionL(TVIMPSTEnums::EOwnStatusItem, 0 ); // focus own item

                }

            TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageAllContactRemoved End") );

            break;

            }

        case TVIMPSTEnums::EStorageEventContactChange: 

	        {

	        TRACE( T_LIT("CVIMPSTProcessArray::HandleStorageChangeL EStorageEventContactChange Start") );

	        // display name is changed ,might be contact is re-arranged

            TRACE( T_LIT("contactindex = %d"),aContactIndex );

            TRACE( T_LIT("itemarraycount = %d"),iItemArray.Count() );

            if( aContactIndex < iItemArray.Count() )

                {