/*

* 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 "cvimpstprocessarray.h"

#include "mvimpstprocessArrayobserver.h"

#include "cvimpststoragemanagerfactory.h"

#include "mvimpststorageserviceview.h"

#include "tvimpstenums.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 <MVPbkFieldType.h>

#include <MVPbkContactFieldUriData.h>

#include <MVPbkContactFieldTextData.h>

//rsg file for resource id

#include <vimpstuires.rsg>

#include "vimpstutils.h"

#include <MVPbkContactLink.h>

#include <VPbkEng.rsg>

#include "mvimpstengineimsubservice.h"

#include "mvimpstenginepresencesubservice.h"

#include <apgtask.h> 

#include "imcvuiparams.h"

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

// CVIMPSTProcessArray::CIMArrayProcess

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

//

CVIMPSTProcessArray::CVIMPSTProcessArray( MVIMPSTEngine& aEngine)

:iOwnDataIndex(KOwnDataIndex),

iContactListIndex(KOwnDataIndex),

iEngine(aEngine)

        {

        iServiceId = iEngine.ServiceId();

        }

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

// CVIMPSTProcessArray::~CVIMPSTProcessArray

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

//

CVIMPSTProcessArray::~CVIMPSTProcessArray()

    {

    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);

        } 

    }

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

// CVIMPSTProcessArray::NewL

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

//

CVIMPSTProcessArray* CVIMPSTProcessArray::NewL(

        MVIMPSTEngine& aEngine)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CVIMPSTProcessArray::ConstructL

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

//

void CVIMPSTProcessArray::ConstructL()

    {

    iContactInterface = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId);

    if(iContactInterface)

        {        

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

        HBufC* unnamed = VIMPSTUtils::LoadResourceL( R_SERVTAB_UNNAMED );

        if( unnamed )

            {

            CleanupStack::PushL( unnamed );

            iContactInterface->SetUnnamedTextL(unnamed); // takes ownership

            CleanupStack::Pop( unnamed );	

            }

        }

    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();

    }

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

// CVIMPSTProcessArray::HandleStorageChangeL

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

//

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

			         							MVIMPSTStorageContactList* /*aList*/, 

				        						MVIMPSTStorageContact* aContact,

				        						TInt aContactIndex )

    {

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

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

    switch( aEventType )

        {

        case TVIMPSTEnums::EStorageContactReadComplete:

            if(iProcessObservers)

                {

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

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

            break;

            }

        case TVIMPSTEnums::EStorageContactFetchComplete:

            if(iProcessObservers)

                {

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

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

                }

            ResetArray();

            iFetchCompleted = ETrue;

            GetAndCreateOpenChatListL();

            break; 	

            }

        case TVIMPSTEnums::EStorageContactReading:

        case TVIMPSTEnums::EStorageContactFetching:

        case TVIMPSTEnums::EStorageContactSynchronizing:

            {

            /*

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

             */

            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. 

             */

            if (aContactIndex >= iItemArray.Count() )

                iItemArray.Append(contactItem);

                }

            else

                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() );

                }

            break;

            }

        case TVIMPSTEnums::EStorageEventContactAddition:

            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();

                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. 

             */

            if (aContactIndex >= iItemArray.Count() )

                iItemArray.Append(contactItem);

                }                

            else

                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 );

                }   

            break;

            }

        case TVIMPSTEnums::EStorageEventContactDelete:

            {

            if( aContactIndex < iItemArray.Count() )

                {

                iItemArray.Remove (aContactIndex);

                delete deletedItem;

                iItemArray.Compress();

                }

            if(iProcessObservers)

                {

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

            break;

            }

        case TVIMPSTEnums::EStorageAvatarChange:

            if(iProcessObservers  && aContact )

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

            break;            

            }

        case TVIMPSTEnums::EStorageOwnPresenceChange:

            {

            if(iProcessObservers)

                {

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

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

            break;

            }

        case TVIMPSTEnums::EStorageMultiplePresenceChange:

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

	        ResetArray();

            if(iProcessObservers )

                {

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

	        break;	

	        }

        case TVIMPSTEnums::EStoragePresenceChange:

            /* 

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

             */

            if( aContactIndex < iItemArray.Count() )

                {                

                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;

                        }

                   }

                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())

                    iItemArray.Append (newItem);

                    }

                else

                    iItemArray.Insert (newItem, newIndex);

                    }   

                }

            if(iProcessObservers )

                {

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

                }

            break;

            }

        case TVIMPSTEnums::EStorageEventOwnUserChanged:

            {

            ResetArray();

            if(iProcessObservers )

                {

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

                if( aContact )

                    {

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

                    }

                }

            break;

            }

        case TVIMPSTEnums::EStorageAllContactRemoved:

            ResetArray();

            if(iProcessObservers )

                {

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

                }

            break;

            }

        case TVIMPSTEnums::EStorageEventContactChange: 

	        {

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

            if( aContactIndex < iItemArray.Count() )

                {

                if ( aContact )

                     {

                    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.

                    // set the conversation open flag from old contact, as only the display name would have changed.

                    newItem->SetConversationOpen(oldItem->IsConversationOpen());

                    newItem->SetMsgPending( oldItem->IsMsgPending() );

                    iItemArray.Remove(aContactIndex );

                    delete oldItem;

                    iItemArray.Compress();