/*

* Copyright (c) 2007-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:  Handler to manage groupcard property during import and export

 *

*/

#include "CVPbkGroupCardHandler.h"

#include <MVPbkContactStore.h>

#include <MVPbkContactGroup.h>

#include <MVPbkContactStore2.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactStoreProperties2.h>

#include <MVPbkContactOperationBase.h>

#include <CVPbkContactManager.h>

#include <CVPbkContactIdConverter.h>

#include <MVPbkStoreContact2.h>

_LIT8(KGroup,"X-CATEGORIES");

_LIT16(KSemiColon,";");    

_LIT16(KVersitTokencrlf,"\r\n");

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

// CVPbkGroupCardHandler::CVPbkGroupCardHandler

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

CVPbkGroupCardHandler::CVPbkGroupCardHandler(CVPbkVCardData& aData):iData(aData)

            {

            }

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

// CVPbkGroupCardHandler::NewL

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

CVPbkGroupCardHandler* CVPbkGroupCardHandler::NewL(CVPbkVCardData& aData)

    {

    CVPbkGroupCardHandler* self = new (ELeave) CVPbkGroupCardHandler(aData);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CVPbkGroupCardHandler::ConstructL

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

void CVPbkGroupCardHandler::ConstructL()

    {

    iWait = new( ELeave )CActiveSchedulerWait();

    iContactsGroupsMap = NULL;

    iTargetStore = NULL;

    iStore = NULL;

    }

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

// CVPbkGroupCardHandler::~CVPbkGroupCardHandler

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

CVPbkGroupCardHandler::~CVPbkGroupCardHandler()

    {

    // The code that started iWait must know if this instance has been deleted.

    if ( iDestroyed )

        {

        *iDestroyed = ETrue;

        }

    if ( iSelfPtr )

        {

        *iSelfPtr = NULL;

        }

    delete iRetrieveOp;

    if ( iWait )

        {

        if( iWait->IsStarted() )

            iWait->AsyncStop();

        delete iWait;

        iWait = NULL;

        }

    if(iStore)

        {

        delete iStore;

        iStore = NULL;

        }

    if (iContactsGroupsMap)

        {   

        iContactsGroupsMap->ResetAndDestroy();

        iContactsGroupsMap->Close();

        delete iContactsGroupsMap;

        }

    }

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

// CVPbkGroupCardHandler::CreateXSelfPropertyL

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

CParserProperty* CVPbkGroupCardHandler::CreateXGroupPropertyL(const MVPbkStoreContact* aStore)

    {

    TPtrC8 text( KGroup);

    CParserProperty* property = NULL;

    CVPbkVCardParserParamArray* params = NULL;

    if ( aStore == NULL)

        return property;

    MVPbkContactLinkArray* groupIdArray = aStore->GroupsJoinedLC(); //Get Groupid list of contact.

    if ( groupIdArray == NULL)

        return property;

    TInt totalGroupsInContact = 0;

    totalGroupsInContact = groupIdArray->Count();

    if (totalGroupsInContact == 0)

        {

        //if contact has no groups,Append X-CATEGORIES field with NULL field Value. 

        CParserPropertyValueHBufC* tempValue = CParserPropertyValueHBufC::NewL( KNullDesC() );

        CParserPropertyValue* value = static_cast<CParserPropertyValue*>(tempValue);

        property = CParserProperty::NewL( *value,text, params);

        CleanupStack::PopAndDestroy();  //For GoupIdArray

        return property;

        }

    CDesCArrayFlat* desArray=new (ELeave)CDesCArrayFlat(totalGroupsInContact);

    CleanupStack::PushL(desArray);

    //Append all the Group Names of contact to X-CATEGORIES field value.

    TBool thisDestroyed = EFalse;

    for ( TInt m = 0 ; m < totalGroupsInContact && !thisDestroyed ; m++ )

        {                  

        const  MVPbkContactLink& groupLink = (*groupIdArray)[m];

        thisDestroyed = RetrieveContactL( groupLink, *this );

        if (!thisDestroyed && iTargetStore)

            {

            MVPbkContactGroup* contactGrp = iTargetStore->Group();

            if(contactGrp)

                {

                CParserPropertyValueHBufC* tempValue = CParserPropertyValueHBufC::NewL( contactGrp->GroupLabel() );

                CleanupStack::PushL(tempValue);

                desArray->AppendL(tempValue->Value());

                CleanupStack::PopAndDestroy(tempValue);

                }

            delete iTargetStore;

            iTargetStore = NULL;

            }

        }

    CParserPropertyValue* value = new (ELeave) CParserPropertyValueCDesCArray(desArray);

    CleanupStack::PushL(value);

    property = CParserProperty::NewL( *value, text, params); //Create the Property with field and Value

    CleanupStack::Pop(value);

    CleanupStack::Pop(desArray);

    CleanupStack::PopAndDestroy();  //For GoupIdArray

    return property;

    }

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

// CVPbkGroupCardHandler::DeleteContactFromGroupsL

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

void CVPbkGroupCardHandler::DeleteContactFromGroupsL()

    {

    if(iStore == NULL)

        return;

    //Get Groupid list a contact belongs

    MVPbkContactLinkArray* groupIds = iStore->GroupsJoinedLC(); 

    if(groupIds == NULL)

        return; 

    TInt groupIdsCount = 0;

    groupIdsCount = groupIds->Count();    

    const MVPbkContactLink* contactLink = iStore->CreateLinkLC();

    //Remove the contact from all the Groups it belongs.

    TBool thisDestroyed = EFalse;

    for(TInt i = 0;i < groupIdsCount && !thisDestroyed;i++)

        {

        const MVPbkContactLink& groupLink = (*groupIds)[i];

        thisDestroyed = RetrieveContactL( groupLink, *this );

        if (!thisDestroyed && iTargetStore)

            { 

            MVPbkContactGroup* contactGrp = iTargetStore->Group();

            if(contactGrp)

                {   

                iTargetStore->LockL(*this); //Lock the contact before editing the contact.

                //wait for LockL operation to complete

                if( ! (iWait->IsStarted()) )

                    {

                    iWait->Start();

                    }

                contactGrp->RemoveContactL(*contactLink); //Removes a contact from a Group

                iTargetStore->CommitL(*this);  //save the Changes to VPBK.

                //wait for CommitL operation to complete

                if( ! (iWait->IsStarted()) )

                    {

                    iWait->Start();

                    }

                }  

            delete iTargetStore;

            iTargetStore = NULL;

            }

        }

    CleanupStack::PopAndDestroy();  // for contactLink

    CleanupStack::PopAndDestroy(); // for groupIds

    }

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

// CVPbkGroupCardHandler::CreateNewGroupFromContactL

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

void CVPbkGroupCardHandler::CreateNewGroupFromContactL(TPtr16& aGroupLabel)

    {

    if(iStore == NULL)

        return;

    //Creates New Group 

    MVPbkContactGroup* groupItem = iStore->ParentStore().CreateNewContactGroupLC(); 

    if(groupItem)

        {                    

        groupItem->SetGroupLabelL(aGroupLabel); // set the group name.

        //Retrieve group store

        const MVPbkContactLink* grpContactLink = groupItem->CreateLinkLC();

        TBool thisDestroyed = RetrieveContactL( *grpContactLink, *this );

        CleanupStack::PopAndDestroy();// to clean grpContactLink

        if (!thisDestroyed && iTargetStore)

            {

            const MVPbkContactLink* contactLink = iStore->CreateLinkLC();

            groupItem->AddContactL(*contactLink);

            CleanupStack::PopAndDestroy(); //For aContactLink

            groupItem->CommitL(*this); 

            if( ! (iWait->IsStarted()) )

                {

                iWait->Start();

                }//Commit to VPBK for new grp changes.

            //Add the New Group to Hash Table

            TPtrC16 contactGroupName;

            contactGroupName.Set( aGroupLabel );

            HBufC16* grpName = contactGroupName.AllocLC();

            if(iContactsGroupsMap == NULL)

                {

                iContactsGroupsMap = new(ELeave) RPtrHashMap<TDesC16, MVPbkStoreContact>();

                }

            // iContactsGroupsMap takes the ownership of iTargetStore

            TInt res = iContactsGroupsMap->Insert(grpName, iTargetStore);

            if ( res != KErrNone )

                {

                delete iTargetStore;

                }

            iTargetStore = NULL;

            CleanupStack::Pop(); // To pop up grpName

            }

        }   

    CleanupStack::PopAndDestroy(); // To pop up and destroy groupItem  

    }

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

// CVPbkGroupCardHandler::DecodeContactGroupInVCardL

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

void CVPbkGroupCardHandler::DecodeContactGroupInVCardL(TPtr16 aValue,

        CVPbkGroupCardHandler** aSelfPointer )

    {        

    if(iStore == NULL)

        return;

    iSelfPtr = aSelfPointer;

    const MVPbkContactLink* contactLink = iStore->CreateLinkLC();

    TInt newLinePos = aValue.Find(KVersitTokencrlf());

    if (newLinePos != KErrNotFound)

        aValue = aValue.Left(newLinePos); //remove CRLF from aValue

    TInt semiColonPos = 0;

    TBool endGrpValue = EFalse;    

    DeleteContactFromGroupsL(); //Delete the contact from the Groups it belongs

    TBool destroyed = EFalse;

    while(!endGrpValue && !destroyed)

        {        

        semiColonPos = aValue.Find( KSemiColon() );

        if(semiColonPos == KErrNotFound)

            {

            semiColonPos = aValue.Length();

            endGrpValue = ETrue;  // all the Group card values are parsed

            }

        if(semiColonPos > 0)

            {          

            //Get each group card value to save OR add to Groups

            TPtrC16 desGrpValue = aValue.Left(semiColonPos); 

            HBufC16* unicodeGrpValue = desGrpValue.Alloc();

            CleanupStack::PushL( unicodeGrpValue );

            TPtr16 desGrpValueHash = unicodeGrpValue->Des();

            MVPbkContactGroup* groupContactItemId = NULL;

            MVPbkStoreContact* storeContact = NULL;

            if(iContactsGroupsMap)

                {

                // Find whether Group already present in VPBK, to get group store

                storeContact = iContactsGroupsMap->Find(desGrpValueHash);

                if (storeContact)

                    groupContactItemId = storeContact->Group();

                }

            // if group already present add the contact to existing group otherwise 

            // add the contact to new group 

            if(groupContactItemId != NULL)

                { 

                storeContact->LockL(*this);

                iDestroyed = &destroyed;

                //wait for Lock operation to complete

                if( ! (iWait->IsStarted()) )

                    {

                    iWait->Start();

                    }

                if ( !destroyed )

                    {

                    iDestroyed = NULL;

                    groupContactItemId->AddContactL(*contactLink);

                    storeContact->CommitL(*this);  // save Group modifications.

                    iDestroyed = &destroyed;

                    if( ! (iWait->IsStarted()) )

                        {

                        iWait->Start();

                        }

                    if ( !destroyed )

                        {

                        iDestroyed = NULL;

                        }

                    }

                }

            else

                {                                

                CreateNewGroupFromContactL(desGrpValueHash);

                }// End of if(err = KErrNone)

            CleanupStack::PopAndDestroy(unicodeGrpValue);

            }// End of if(semiColonPos > 0)

        //Get Next Group card Value

        if(!endGrpValue)

            aValue = aValue.Right( aValue.Length() - semiColonPos - KSemiColon().Length());

        } //End Of While loop

    CleanupStack::PopAndDestroy(); // For contactLink 

    if(!destroyed)

        {

        iSelfPtr = NULL;

        delete iStore;

        iStore = NULL;

        }

    }

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

// CVPbkGroupCardHandler::BuildContactGroupsHashMapL

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

void CVPbkGroupCardHandler::BuildContactGroupsHashMapL(

        MVPbkContactStore& aTargetContactStore, 

        CVPbkGroupCardHandler** aSelfPointer)

    {

    //Get all the Group Links in current VPBK

    MVPbkContactLinkArray* groupLinks = aTargetContactStore.ContactGroupsLC();

    if( (groupLinks == NULL || iContactsGroupsMap != NULL))

        return;

    iSelfPtr = aSelfPointer;

    iContactsGroupsMap = new(ELeave) RPtrHashMap<TDesC16, MVPbkStoreContact>();

    TInt groupCount = 0;

    groupCount = groupLinks->Count();

    // Get Group Name and Group store, store these values into Hash Table.

    TBool thisDestroyed = EFalse;

    for(TInt i = 0;i < groupCount && !thisDestroyed;i++)

        {

        const MVPbkContactLink& groupLink = (*groupLinks)[i];

        thisDestroyed = RetrieveContactL( groupLink, *this );

        if (!thisDestroyed && iTargetStore)

            {

            MVPbkContactGroup* contactGrp = iTargetStore->Group();

            if(contactGrp)

                {   

                TPtrC16 contactGroupName;

                contactGroupName.Set( contactGrp->GroupLabel());

                HBufC16* grpName = contactGroupName.AllocLC();

                // iContactsGroupsMap takes the ownership of iTargetStore

                TInt res = iContactsGroupsMap->Insert(grpName, iTargetStore);

                if ( res != KErrNone )

                    {

                    delete iTargetStore;

                    }

                iTargetStore = NULL;

                CleanupStack::Pop();  //grpName

                }       

            }    

        }// End of for loop

    CleanupStack::PopAndDestroy(); //for groupLinks

    if ( !thisDestroyed )

        {

        iSelfPtr = NULL;

        }

    }

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

// CVPbkGroupCardHandler::RetrieveContactL

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

TBool CVPbkGroupCardHandler::RetrieveContactL( const MVPbkContactLink& aLink,

            MVPbkSingleContactOperationObserver& aObserver)

    {

    delete iTargetStore;

    iTargetStore = NULL;

    iRetrieveOp = iData.GetContactManager().RetrieveContactL( aLink, aObserver );

    TBool destroyed = EFalse;

    // Set iDestroyed to point to stack variable that is accessed from

    // destructor.

    iDestroyed = &destroyed; 

    //wait for GetContactGroupStoreL operation to complete,to get storecontact

    if( ! (iWait->IsStarted()) )

        {

        iWait->Start();

        }

    if ( !destroyed )

        {

        // Reset pointer to stack variable.

        iDestroyed = NULL;

        delete iRetrieveOp;

        iRetrieveOp = NULL;

        }

    return destroyed; 

    }

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

// CVPbkGroupCardHandler::VPbkSingleContactOperationComplete

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

void CVPbkGroupCardHandler::VPbkSingleContactOperationComplete(

        MVPbkContactOperationBase& /*aOperation*/,

        MVPbkStoreContact* aContact)

    {

    iTargetStore = aContact;

    if( iWait->IsStarted() )

        iWait->AsyncStop();

    }

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

// CVPbkGroupCardHandler::VPbkSingleContactOperationFailed

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

void CVPbkGroupCardHandler::VPbkSingleContactOperationFailed

(MVPbkContactOperationBase& /*aOperation*/, TInt /*aError*/)

    {

    if( iWait->IsStarted() )

        iWait->AsyncStop();

    }

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

// CVPbkGroupCardHandler::GetContactGroupStoreL

// Retrieve the contact store of group contact

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

void CVPbkGroupCardHandler::GetContactGroupStoreL(

        const MVPbkContactLink& aContactLink, 

        CVPbkGroupCardHandler** aSelfPointer)

    {

    iSelfPtr = aSelfPointer;

    delete iStore;

    iStore = NULL;

    if ( !RetrieveContactL( aContactLink, *this ) )

        {

        iSelfPtr = NULL;

        // iStore takes the ownership.

        iStore = iTargetStore;

        iTargetStore = NULL;

        }        

    }

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

// CVPbkGroupCardHandler::ContactOperationCompleted

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

void CVPbkGroupCardHandler::ContactOperationCompleted(TContactOpResult aResult)

    {

    delete aResult.iStoreContact;

    if( iWait->IsStarted() )

        iWait->AsyncStop();

    }

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

// CVPbkGroupCardHandler::ContactOperationFailed

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

void CVPbkGroupCardHandler::ContactOperationFailed

(TContactOp /*aOpCode*/, TInt /*aErrorCode*/, TBool /*aErrorNotified*/)

    {

    if( iWait->IsStarted() )

        iWait->AsyncStop();

    }