/*

* 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:  Class that provides handling of vpbk server store

*

*/

// INCLUDE FILES

#include "cvimpststoragevpbkserverstore.h"

#include "cvimpststoragevpbkstorehandler.h"

#include <MVPbkContactView.h>

#include <CVPbkContactIdConverter.h>

#include "tvimpstconsts.h"

#include "mvimpststorageserviceview.h"

#include <CVPbkContactLinkArray.h>

#include <MVPbkContactLink.h>

#include "cvimpststoragecontact.h"

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

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

// CVIMPSTStorageVPbkServerStore::

//      CVIMPSTStorageVPbkServerStore

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

//

CVIMPSTStorageVPbkServerStore:: CVIMPSTStorageVPbkServerStore( MVIMPSTStorageServiceCacheWriter& aServiceCacheWriter ):

    CActive( CActive::EPriorityIdle ),

    iServiceCacheWriter( aServiceCacheWriter ),

    iFetchStep( EFetchingUnknown )

    { 

    CActiveScheduler::Add( this );

    }

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

// CVIMPSTStorageVPbkServerStore::ConstructL

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

//

void CVIMPSTStorageVPbkServerStore::ConstructL( const TDesC& aContactDb, const TDesC& aServiceName)

    {

    iVPbkStoreHandler = CVIMPSTStorageVPbkStoreHandler::NewL( aContactDb,aServiceName, *this, EFalse );

    }

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

// CVIMPSTStorageVPbkServerStore::NewL

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

//

CVIMPSTStorageVPbkServerStore* 

    CVIMPSTStorageVPbkServerStore::NewL( const TDesC& aContactDb,

    									 const TDesC& aServiceName,

    									MVIMPSTStorageServiceCacheWriter& aServiceCacheWriter )

    {

    CVIMPSTStorageVPbkServerStore* self = NewLC( aContactDb, 

    											 aServiceName, 

    											 aServiceCacheWriter );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVIMPSTStorageVPbkServerStore::NewLC

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

//

CVIMPSTStorageVPbkServerStore* 

    CVIMPSTStorageVPbkServerStore::NewLC(const TDesC& aContactDb,

    									const TDesC& aServiceName,

    									MVIMPSTStorageServiceCacheWriter& aServiceCacheWriter )

    {

    CVIMPSTStorageVPbkServerStore* self =

        new (ELeave) CVIMPSTStorageVPbkServerStore(aServiceCacheWriter);

    CleanupStack::PushL( self );

    self->ConstructL( aContactDb,aServiceName );

    return self;    

    }

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

// CVIMPSTStorageVPbkServerStore::

//      ~CVIMPSTStorageVPbkServerStore

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

//

CVIMPSTStorageVPbkServerStore::~CVIMPSTStorageVPbkServerStore()

    {

    iRetrivedXSPIdArray.ResetAndDestroy();

    TRAP_IGNORE( ResetAndDestroyLocalArrayL() );

    delete iVPbkStoreHandler;

    }

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

// CVIMPSTStorageVPbkServerStore::ResetAndDestroyLocalArrayL

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

//

void CVIMPSTStorageVPbkServerStore::ResetAndDestroyLocalArrayL()

    {

    TInt count = iFetchContactsToBeAdded.Count();

   	while( count )

	   	{

	   	TVIMPSTContactInfo contactInf = iFetchContactsToBeAdded[ count-1 ];

	   	iFetchContactsToBeAdded.Remove( count-1 );

		delete contactInf.iUserId;

		contactInf.iUserId = NULL;	

		delete contactInf.iDisplayName;

		contactInf.iDisplayName = NULL;				         

         // not exist need to add 

        iFetchContactsToBeAdded.Compress();	

        count = iFetchContactsToBeAdded.Count();

	   	}

	iFetchContactsToBeAdded.Reset();

    }

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

// CVIMPSTStorageVPbkServerStore::LocalStore

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

//

TBool CVIMPSTStorageVPbkServerStore::LocalStore() const 

	{

	return EFalse;	

	}

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

// CVIMPSTStorageVPbkServerStore::HandleVPbkStoreEventL

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

//

void CVIMPSTStorageVPbkServerStore::HandleVPbkStoreEventL(TVIMPSTVPbkStoreEvent aVPbkStoreEvent) 

    {

    switch( aVPbkStoreEvent.iEventType )

        {

        case EVPbkContactReadCompleted:

            {

            iServiceCacheWriter.NotifyServiceViewL(TVIMPSTEnums::EStorageContactReadComplete);

            if( iFetchStep == EFetchingCalled )

                {

                IssueRequest();		

                }

            iFetchStep = EContactReadComplete;

            break;

            }

        case EVPbkContactReading:

            {

             // a contact entry has been created in virtual database store

            // create the cache contact

            // fetched one by one contact from cdb file

            // Add to storage cache

            iServiceCacheWriter.AddContactToCacheL(*aVPbkStoreEvent.iContactLink , 

                    aVPbkStoreEvent.iUserId ,

                    aVPbkStoreEvent.iDisplayName ,

                    aVPbkStoreEvent.iAvatarContent,

                    TVIMPSTEnums::EStorageContactReading  );

		    break;	

		    }

        case EVPbkContactFetching:

        case EVPbkContactAdded:

            {

            TVIMPSTEnums::TVIMPSTStorgaeEventType event = TVIMPSTEnums::EStorageEventContactAddition;

            // a contact entry has been created in virtual database store

            // create the cache contact

            // fetched one by one contact from cdb file

            // Add to storage cache

            if( iFetchStep == EFetchingOn )

                {

                event = TVIMPSTEnums::EStorageContactFetching;

                } 

            iServiceCacheWriter.AddContactToCacheL(*aVPbkStoreEvent.iContactLink , 

                    aVPbkStoreEvent.iUserId ,

                    aVPbkStoreEvent.iDisplayName ,

                    aVPbkStoreEvent.iAvatarContent,

                    event );

            if(iFetchStep == EFetchingOn)			

                {

                IssueRequest();

                }

            break;	

            }

        case EVPbkContactSynchronizing:

            {

            // a contact entry has been created in virtual database store

            // create the cache contact

            // fetched one by one contact from cdb file

            // Add to storage cache

            iServiceCacheWriter.AddContactToCacheL(*aVPbkStoreEvent.iContactLink , 

                    aVPbkStoreEvent.iUserId ,

                    aVPbkStoreEvent.iDisplayName ,

                    aVPbkStoreEvent.iAvatarContent,

                    TVIMPSTEnums::EStorageContactSynchronizing );

            if(iFetchStep == EFetchingOn)          

                   {

                   IssueRequest();

                   }

            break;

            }

        case EVPbkContactDeleted:

            {

            // a contact entry has been deleted from virtual database store

            // delete from cache contact

            // not Needed in case of server contact

            iServiceCacheWriter.RemoveContactFromCacheL(*aVPbkStoreEvent.iContactLink,

                    TVIMPSTEnums::EStorageEventContactDelete );

            break;	 

            }

        case EVPbkContactChanged:

            {

            // a contact entry has been updated to virtual database store

            // update to cache contact

            // not Needed in case of server contact

            iServiceCacheWriter.UpdateCacheContactL(*aVPbkStoreEvent.iContactLink , 

                    aVPbkStoreEvent.iUserId ,

                    aVPbkStoreEvent.iDisplayName,

                    aVPbkStoreEvent.iAvatarContent);

            if(iFetchStep == EFetchingOn)         

                  {

                  IssueRequest();

                  }

            break;	

            }

        case EVPbkContactRetriving:

            {

            // ONLY VALID USER ID ALLOWED

            if( aVPbkStoreEvent.iUserId.Length() )

                {

                HBufC* sxpId = aVPbkStoreEvent.iUserId.AllocL();

                iRetrivedXSPIdArray.Append( sxpId ); // takes the ownership of retrivedContact

                // keep the backup of retrieved contacts

                // user can add later once it sent to server

                }

            break;	

            }

        case EVPbkUnknownChanges:

            {

            // unknow mean all contact deleted from store

            // Not supported in case of server contact

            iServiceCacheWriter.RemoveAllCacheContactsL();

            if(iFetchStep == EFetchingCalled )

                { 

                IssueRequest();

                }

            break;	

            }

        default:

            {

            break;

            }

        }

    }

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

// CVIMPSTStorageVPbkServerStore::IssueRequest

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

//

void CVIMPSTStorageVPbkServerStore::IssueRequest()

    {

    if( !IsActive() )

        {

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        SetActive();

        }

    }

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

// CVIMPSTStorageVPbkServerStore::RunL

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

//

void CVIMPSTStorageVPbkServerStore::RunL()

    {

    TInt count = iFetchContactsToBeAdded.Count();

    if( !count )

        {

        iFetchStep = EContactReadComplete;

        iServiceCacheWriter.NotifyServiceViewL( TVIMPSTEnums::EStorageContactFetchComplete );

        }

    else

        {

        iFetchStep  = EFetchingOn;

        TVIMPSTContactInfo contactInfoToAdd = iFetchContactsToBeAdded[0];

        // pass the display NAme in place of NULL

       	iVPbkStoreHandler->CreateVPbkContactL( *contactInfoToAdd.iUserId, *contactInfoToAdd.iDisplayName ); // process always 0th item	

	    iFetchContactsToBeAdded.Remove( 0 );

        delete contactInfoToAdd.iUserId;

        contactInfoToAdd.iUserId = NULL;

        delete contactInfoToAdd.iDisplayName;

        contactInfoToAdd.iDisplayName = NULL ;

        iFetchContactsToBeAdded.Compress();

        }

    }

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

// CVIMPSTStorageVPbkServerStore::DoCancel

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

//

void CVIMPSTStorageVPbkServerStore::DoCancel()

    {

    }

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

// CVIMPSTStorageVPbkServerStore::RunError

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

//

TInt CVIMPSTStorageVPbkServerStore::RunError( TInt aError )

    {

    return aError;    

    }

//////////////////////////////////////////////////////////

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

// CVIMPSTStorageVPbkServerStore::CreateVPbkContactL

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

// 

TInt CVIMPSTStorageVPbkServerStore::CreateVPbkContactL( const TDesC& aUserId, 

        						 					   const TDesC& aDisplayName,

        						 					   TBool /*aInvitationAutoAccept = EFalse */ )   

	{

    return iVPbkStoreHandler->CreateVPbkContactL( aUserId ,aDisplayName );

	}

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

// CVIMPSTStorageVPbkServerStore::AddVPbkFetchContactsL

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

//

 void CVIMPSTStorageVPbkServerStore::AddVPbkFetchContactsL( RArray <TPtrC>& aFirstNameList, 

                                                            RArray <TPtrC> &aServiceField ) 

     {

     // in case of server case we delete all contacts and then add fetch contacts

     // in case of server contacts delete all contacts

     TInt oldContactCount = RemoveAllVPbkContactsL();

     ResetAndDestroyLocalArrayL();

     TInt fetchContactCount = aServiceField.Count();

     for( TInt i = 0; i<fetchContactCount; i++ )

         {

         TVIMPSTContactInfo contactInf =

							         {

							         aServiceField[i].AllocL() ,

							         aFirstNameList[i].AllocL()	

							         };

         iFetchContactsToBeAdded.Append( contactInf );

         }

     if( iFetchStep == EContactReadComplete || !oldContactCount)

	     {

	     IssueRequest();	

	     }

	 else

		 {

		 iFetchStep = EFetchingCalled;	

		 }

	 }

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

// CVIMPSTStorageVPbkServerStore::RemoveVPbkContactL

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

//  

TInt CVIMPSTStorageVPbkServerStore::RemoveVPbkContactL(const MVPbkContactLink& aContactLink) 

    {

    // text now holds the name (or first field of the contact) 

    CVPbkContactLinkArray* contactsToDelete = CVPbkContactLinkArray::NewLC();

    MVPbkContactLink* link = aContactLink.CloneLC();    

    contactsToDelete->AppendL( link ); // takes ownership

    CleanupStack::Pop(); // link

    TInt error = iVPbkStoreHandler->RemoveVPbkContactL( *contactsToDelete );

    CleanupStack::PopAndDestroy(); // contactsToDelete

    return error;

    }

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

// CVIMPSTStorageVPbkServerStore::RemoveAllVPbkContactsL

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

// 

TInt CVIMPSTStorageVPbkServerStore::RemoveAllVPbkContactsL() 

	{

	iRetrivedXSPIdArray.ResetAndDestroy();

	return iVPbkStoreHandler->RemoveAllVPbkContactsL();

	}

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

// CVIMPSTStorageVPbkServerStore::RetrieveVPbkXSPIdL

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

//  

TInt CVIMPSTStorageVPbkServerStore::RetrieveVPbkXSPIdL(const TDesC8& aPackedLinks ) 

	{

	iRetrivedXSPIdArray.ResetAndDestroy();

	iVPbkStoreHandler->RetrieveVPbkContactL( aPackedLinks );

    return iRetrivedXSPIdArray.Count();

	}

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

// CVIMPSTStorageVPbkServerStore::GetRetrieveVPbkXSPIdL

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

//  

const TDesC& CVIMPSTStorageVPbkServerStore::GetRetrieveVPbkXSPIdL(TInt aIndex ) 

	{

	HBufC* contactId = NULL;

	if( aIndex >= 0 && aIndex < iRetrivedXSPIdArray.Count() )

        {

        contactId = iRetrivedXSPIdArray[ aIndex ];

        }

    if( contactId  )

	    {

	    return 	*contactId;

	    }

    return KNullDesC ; 

    }

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

// CVIMPSTStorageVPbkServerStore::CreateRetriveVPbkContactL

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

// 

TInt CVIMPSTStorageVPbkServerStore::CreateRetriveVPbkContactL( TInt /*aIndexToUse*/ )   

    {

    // Not applicable for server store

    return KErrNotSupported;

    }

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

// CVIMPSTStorageVPbkServerStore::deleteRetriveVPbkContactL

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

// 

TInt CVIMPSTStorageVPbkServerStore::deleteRetriveVPbkContactL( TInt /*aIndexToUse*/ )   

    {

    // Not applicable for server store

    return KErrNotSupported;

    }

// CVIMPSTStorageVPbkServerStore::UpdateAvatarFieldDataL()

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

//

TInt CVIMPSTStorageVPbkServerStore::UpdateAvatarFieldDataL(const MVPbkContactLink& aContactLink,

														  const TDesC8& aAvatartData )

    {

    return iVPbkStoreHandler->UpdateAvatarFieldDataL( aContactLink, aAvatartData );

    }