/*

* Copyright (c) 2007 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: 

*       

*

*/

// INCLUDES

#include <spsettings.h>

#include <spproperty.h>

#include <MVPbkFieldType.h>

#include <MVPbkStoreContact.h>

#include <CVPbkContactManager.h>

#include <presencecachereader2.h>

#include <CPbk2SortOrderManager.h>

#include <MPbk2ContactNameFormatter.h>

#include <Pbk2ContactNameFormatterFactory.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactFieldUriData.h>

#include <MVPbkContactFieldDateTimeData.h>

#include <CVPbkContactFieldIterator.h>

#include <MVPbkContactFieldBinaryData.h>

#include <CVPbkDefaultAttribute.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreProperties.h>

#include "bpas.h"

#include "cmsserver.h"

#include "cmsdefines.h"

#include "cmsserverutils.h"

#include "cmsservercontact.h"

#include "cmsphonebookproxy.h"

#include "cmsserverasynccontact.h"

#include "cmsserverxspcontacthandler.h"

#include "cmsserverdefines.h"

#include "cmsdebug.h"

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

// CCmsServerAsyncContact::CCmsServerAsyncContact

// 

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

//

CCmsServerAsyncContact::CCmsServerAsyncContact( CCmsServerContact& aSyncContact,

                                                CCmsServer& aCmsServer ) :

                                  CActive( EPriorityStandard ),

                                  iSyncContact( aSyncContact ),

                                  iCmsServer( aCmsServer )

    {

    CActiveScheduler::Add( this );

    }

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

// CCmsServerAsyncContact::NewL

// 

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

//

CCmsServerAsyncContact* CCmsServerAsyncContact::NewL( CCmsServerContact& aSyncContact,

                                                      CCmsServer& aCmsServer )

    {

    CCmsServerAsyncContact* self = new( ELeave ) CCmsServerAsyncContact(

        aSyncContact, aCmsServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCmsServerAsyncContact::~CCmsServerAsyncContact

// 

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

//

CCmsServerAsyncContact::~CCmsServerAsyncContact()

    {

    Cancel();

    delete iSortOrderManager;

    delete iNameFormatter;  

    }

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

// CCmsServerAsyncContact::ConstructL

// 

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

//

void CCmsServerAsyncContact::ConstructL()

    {

    PRINT( _L("Start CCmsServerAsyncContact::ConstructL()" ) );

    iContactManager = iCmsServer.PhonebookProxyHandle().ContactManager();

    //for full name

    iSortOrderManager = CPbk2SortOrderManager::NewL( iContactManager->FieldTypes() );            

    iNameFormatter = Pbk2ContactNameFormatterFactory::CreateL

            ( iContactManager->FieldTypes(), *iSortOrderManager, &iCmsServer.FileSession() );

    PRINT( _L("End CCmsServerAsyncContact::ConstructL()" ) );

    }

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

// CCmsServerAsyncContact::ContactDataTextLC

// 

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

//        

CDesCArrayFlat* CCmsServerAsyncContact::ContactDataTextLC( CCmsContactFieldItem::TCmsContactFieldGroup aFieldGroup )

    {

    PRINT( _L(" Start CCmsServerAsyncContact::ContactDataTextL( group )" ) );

    CDesCArrayFlat* fieldArray = NULL;

    switch( aFieldGroup )

        {

        case CCmsContactFieldItem::ECmsGroupVoIP:

            {

            const TInt count = sizeof( KCmsVoIPGroup ) / sizeof( KCmsVoIPGroup[0] );

            fieldArray = FieldsFromArrayLC( count, KCmsVoIPGroup );

            break;

            }

        case CCmsContactFieldItem::ECmsGroupVoice:

            {

            const TInt count = sizeof( KCmsVoiceCallGroup ) / sizeof( KCmsVoiceCallGroup[0] );

            fieldArray = FieldsFromArrayLC( count, KCmsVoiceCallGroup );

            break;

            }

        case CCmsContactFieldItem::ECmsGroupEmail:

            {

            const TInt count = sizeof( KCmsEmailAddressGroup ) / sizeof( KCmsEmailAddressGroup[0] );

            fieldArray = FieldsFromArrayLC( count, KCmsEmailAddressGroup );

            break;

            }

        default:

            {

            User::Leave( KErrArgument );

            break;

            }

        }

    PRINT( _L(" End CCmsServerAsyncContact::ContactDataTextL( group )" ) );

    return fieldArray;

    }

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

// CCmsServerAsyncContact::ContactDataUriLC

// 

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

//        

CDesCArrayFlat* CCmsServerAsyncContact::ContactDataUriLC( TInt aResourceId )

    {

    PRINT( _L(" Start CCmsServerAsyncContact::ContactDataUriLC()" ) );

    MCmsContactInterface& syncContact = iSyncContact;

    CDesCArrayFlat* fieldArray = new ( ELeave ) CDesCArrayFlat( 5 );

    CleanupStack::PushL( fieldArray );

    const MVPbkFieldType* type = iContactManager->FieldTypes().Find( aResourceId );

    CVPbkBaseContactFieldTypeIterator* fieldIterator = CVPbkBaseContactFieldTypeIterator::NewLC( *type, syncContact.Contact().Fields() );

    while( fieldIterator->HasNext() )

        {

        const MVPbkBaseContactField* field = fieldIterator->Next();

        const MVPbkContactFieldUriData& uri = MVPbkContactFieldUriData::Cast( field->FieldData() );

        fieldArray->AppendL( uri.Uri() );

        }

    CleanupStack::PopAndDestroy();  //fieldIterator

    PRINT( _L(" End CCmsServerAsyncContact::ContactDataUriLC()" ) );

    return fieldArray;

    }

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

// CCmsServerAsyncContact::FieldsFromArray

// 

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

//        

CDesCArrayFlat* CCmsServerAsyncContact::FieldsFromArrayLC( TInt aCount, const TInt aResourceArray[] )

    {

    PRINT( _L(" Start CCmsServerAsyncContact::FieldsFromArrayLC()" ) );

    CDesCArrayFlat* fieldArray = new ( ELeave ) CDesCArrayFlat( aCount );

    CleanupStack::PushL( fieldArray );

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

        {

        PhonebookDataL( aResourceArray[i], *fieldArray );

        }

    return fieldArray;

    }

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

// CCmsServerAsyncContact::PhonebookDataL

// 

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

//        

void CCmsServerAsyncContact::PhonebookDataL( TInt aResourceId, CDesCArrayFlat& aFieldArray )

    {

    PRINT( _L(" Start CCmsServerAsyncContact::PhonebookDataL()" ) );

    MCmsContactInterface& syncContact = iSyncContact;

    CVPbkBaseContactFieldTypeIterator* fieldIterator = NULL;

    CCmsServerXSPContactHandler* xspHandler = iSyncContact.XSPHandler();

    const TInt xspCount( xspHandler ? xspHandler->ContactCount() : 0 );

    const MVPbkFieldType* type = iContactManager->FieldTypes().Find( aResourceId );

    fieldIterator = CVPbkBaseContactFieldTypeIterator::NewLC( *type, syncContact.Contact().Fields() );

    GetOneFieldL( aFieldArray, *fieldIterator );

    CleanupStack::PopAndDestroy();  //fieldIterator

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

        {

        fieldIterator = CVPbkBaseContactFieldTypeIterator::NewLC( *type, xspHandler->Contact( i )->Fields() );

        GetOneFieldL( aFieldArray, *fieldIterator );

        CleanupStack::PopAndDestroy();  //fieldIterator

        }

    PRINT( _L("End CCmsServerAsyncContact::PhonebookDataL()" ) );

    }

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

// CCmsServerAsyncContact::GetOneFieldL

// 

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

//        

void CCmsServerAsyncContact::GetOneFieldL( CDesCArrayFlat& aFieldArray, CVPbkBaseContactFieldTypeIterator& aFieldIterator )

    {

    PRINT( _L("Start CCmsServerAsyncContact::GetOneFieldL()" ) );

    while( aFieldIterator.HasNext() )

        {

        HBufC* data = ParseContactFieldL( *aFieldIterator.Next() );  

        if( data )

            {

            TInt index( 0 );

            CleanupStack::PushL( data );

            TPtrC descriptor( data->Des() );

            if( aFieldArray.Find( descriptor, index ) != 0 )

                {

                aFieldArray.AppendL( descriptor );

                }

            CleanupStack::PopAndDestroy();  //data

            }

        }

    PRINT( _L("End CCmsServerAsyncContact::GetOneFieldL()" ) );   

    }

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

// CCmsServerAsyncContact::ContactDataBinaryL

// 

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

//        

HBufC8* CCmsServerAsyncContact::ContactDataBinaryL( TInt aResourceId )

    {

    PRINT( _L(" Start CCmsServerAsyncContact::ContactDataBinaryL()" ) );

    HBufC8* binData = NULL;

    MCmsContactInterface& syncContact = iSyncContact;

    const MVPbkStoreContact& contact = syncContact.Contact();

    const MVPbkFieldType* type = iContactManager->FieldTypes().Find( aResourceId );

    CVPbkBaseContactFieldTypeIterator* itr = CVPbkBaseContactFieldTypeIterator::NewLC( *type, contact.Fields() );

    if( itr->HasNext() )

        {

        PRINT( _L( "CCmsServerAsyncContact::ContactDataBinaryL():Phonebook thumbnail available" ) );

        const MVPbkBaseContactField* field = itr->Next();

        const MVPbkContactFieldBinaryData& data = MVPbkContactFieldBinaryData::Cast( field->FieldData() );

        binData = data.BinaryData().AllocL();

        }

    else

        {   

        PRINT( _L( "CCmsServerAsyncContact::ContactDataBinaryL(): Try to fetch avatar" ) );

        binData = FetchAvatarL();

        }

    CleanupStack::PopAndDestroy( itr );

    PRINT( _L(" End CCmsServerAsyncContact::ContactDataBinaryL()" ) );

    return binData;

    }

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

// CCmsServerAsyncContact::FetchAvatarL

// 

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

//

HBufC8* CCmsServerAsyncContact::FetchAvatarL()

    {

    PRINT( _L(" Start CCmsServerAsyncContact::FetchAvatarL()" ) );

    TBool found( EFalse );

    HBufC8* avatarBuf = NULL;

    MPresenceCacheReader2* reader = MPresenceCacheReader2::CreateReaderL();

    CleanupDeletePushL( reader );

    CDesCArrayFlat* uriArray( ContactDataUriLC( R_VPBK_FIELD_TYPE_IMPP ) );

    const TInt count( uriArray->MdcaCount() );

    for( TInt i = 0; !found && i < count; i++ )

        {

        MPresenceBuddyInfo2* info = reader->PresenceInfoLC( uriArray->MdcaPoint( i ) );

        if( info )

            {

            TPtrC8 avatarDesc( info->Avatar() );

            PRINT1( _L("CCmsServerAsyncContact::FetchAvatarL(): Avatar data length: %d" ), avatarDesc.Length() );

            avatarBuf = avatarDesc.AllocL();

            CleanupStack::PopAndDestroy();  //info

            found = ETrue;

            }

        }

    CleanupStack::PopAndDestroy( 2 );  //uriArray, reader

    PRINT( _L(" End  CCmsServerAsyncContact::FetchAvatarL()" ) );

    return avatarBuf;

    }

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

// CCmsServerAsyncContact::FetchContactdata

// 

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

//

void CCmsServerAsyncContact::FetchContactData( CCmsContactFieldItem::TCmsContactField aField )

    {

    PRINT( _L(" Start CCmsServerAsyncContact::FetchContactData()" ) );

    iStatus = KRequestPending;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, ( TInt )aField );

    iAsyncOperation = SelectOperationType( aField ); 

    SetActive();

    PRINT( _L(" End CCmsServerAsyncContact::FetchContactData()" ) );

    }

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

// CCmsServerAsyncContact::FetchEnabledFields

// 

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

//

void CCmsServerAsyncContact::FetchEnabledFields()

    {

    PRINT( _L(" Start CCmsServerAsyncContact::FetchEnabledFields()" ) );

    iStatus = KRequestPending;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    iAsyncOperation = EFetchEnabledFields;

    SetActive();

    PRINT( _L(" End CCmsServerAsyncContact::FetchEnabledFields()" ) );

    }

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

// CCmsServerAsyncContact::SelectOperationType

// 

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

//

CCmsServerAsyncContact::TCmsAsyncOperation CCmsServerAsyncContact::SelectOperationType( TInt aCmsField )

    {

    PRINT( _L(" Start CCmsServerAsyncContact::SelectOperationType()" ) );

    CCmsServerAsyncContact::TCmsAsyncOperation operation = CCmsServerAsyncContact::ENone;

    switch( aCmsField )

        {

        case CCmsContactFieldItem::ECmsPresenceData:

            {

            operation = CCmsServerAsyncContact::EFetchPresenceData;

            break;

            }

        case CCmsContactFieldItem::ECmsThumbnailPic:

            {

            operation = CCmsServerAsyncContact::EFetchPhonebookBinData;

            break;

            }

        case CCmsContactFieldItem::ECmsImpp:

            {

            operation = CCmsServerAsyncContact::EFetchPhonebookUriData;

        	break;

            }

        case CCmsContactFieldItem::ECmsAnniversary:

            {

            operation = CCmsServerAsyncContact::EFetchPhonebookDateTimeData;

        	break;

            }

        default:

            {

            operation = CCmsServerAsyncContact::EFetchPhonebookTextData;

            break;

            }

        }

    PRINT( _L(" End CCmsServerAsyncContact::SelectOperationType()" ) );    

    return operation;

    }

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

// CCmsServerAsyncContact::DoGetEnabledFieldsLC

// 

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

//

HBufC* CCmsServerAsyncContact::GetEnabledFieldsLC()

    {

    TInt bufferIndex = 0;

    CBufFlat* dataBuffer = CBufFlat::NewL( 50 );

    CleanupStack::PushL( dataBuffer );

    MCmsContactInterface& syncContact = iSyncContact;

    CCmsServerXSPContactHandler* xspHandler = iSyncContact.XSPHandler();

    const TInt xspCount( xspHandler ? xspHandler->ContactCount() : 0 );

    DoGetEnabledFieldsL( bufferIndex, dataBuffer, syncContact.Contact() );

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

        {

        DoGetEnabledFieldsL( bufferIndex, dataBuffer, *xspHandler->Contact( i ) );

        }

    //Fullname is always available. Pbhk default name used atleast. 

    TBuf8<32> fullnameBuffer( _L8( "" ) );

    fullnameBuffer.AppendNum( CCmsContactFieldItem::ECmsFullName );

    fullnameBuffer.Append( KDelimiter );

    dataBuffer->InsertL( 0, fullnameBuffer );

    //Make thumbnail to be always "available". There may also be

    //an avatar available in the presence cache, so we need to 

    //make the client application ask this field explicitly

    TBuf8<32> thumbnailBuffer( _L8( "" ) );

    thumbnailBuffer.AppendNum( CCmsContactFieldItem::ECmsThumbnailPic );

    thumbnailBuffer.Append( KDelimiter );

    dataBuffer->InsertL( 0, thumbnailBuffer );

    TInt dataLength( dataBuffer->Size() );

    HBufC8* data8 = HBufC8::NewLC( dataLength );

    TPtr8 desc( data8->Des() );

    dataBuffer->Read( 0, desc, dataLength );

    dataBuffer->Reset();

    PRINT1( _L("CCmsServerAsyncContact::GetEnabledFieldsLC():Enabled fields: %S" ), &desc );

    HBufC* data16 = CmsServerUtils::ConvertDescLC( desc );

    CleanupStack::Pop();  //data16

    CleanupStack::PopAndDestroy( 2 );  //data8, dataBuffer

    CleanupStack::PushL( data16 );

    return data16;

    }

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

// CCmsServerAsyncContact::DoGetEnabledFieldsLC

// 

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

//

void CCmsServerAsyncContact::DoGetEnabledFieldsL( TInt& aBufferIndex, CBufFlat* aDataBuffer,

                                                  const MVPbkStoreContact& aContact )

    {

    PRINT( _L(" Start CCmsServerAsyncContact::DoGetEnabledFieldsLC()" ) );

    TBuf8<32> itemBuffer( _L8( "" ) );

    const MVPbkBaseContactFieldCollection& fieldCollection( aContact.Fields() );    

    TInt fieldCount = fieldCollection.FieldCount();

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

        {

        const MVPbkBaseContactField& fieldBase( fieldCollection.FieldAt( i ) );

        const MVPbkContactFieldData& field( fieldBase.FieldData() );

        const TInt KMatchPriority = 0;

        const MVPbkFieldType* type = fieldBase.MatchFieldType( KMatchPriority );

        if( type && !field.IsEmpty() )

            {

            itemBuffer.Zero();

            CCmsContactFieldItem::TCmsContactField cmsField( CmsServerUtils::MatchFieldType( type->FieldTypeResId() ) );

            itemBuffer.AppendNum( cmsField );

            if( !HasElement( aDataBuffer->Ptr( 0 ), itemBuffer ) )

                {

                itemBuffer.Append( KDelimiter );

                aDataBuffer->InsertL( aBufferIndex, itemBuffer );

                aBufferIndex = aBufferIndex + itemBuffer.Length();

                }

            }

        }

    PRINT( _L(" End CCmsServerAsyncContact::DoGetEnabledFieldsLC()" ) );

    }

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

// CCmsServerAsyncContact::HasElement

// 

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

// 

TBool CCmsServerAsyncContact::HasElement( const TDesC8& aBuffer, const TDesC8& aItem )

    {

    TBool match = EFalse;

    TLex8 items( aBuffer );

    TPtrC8 token( _L8( " " ) );

    while( aBuffer.Length() > 0 && !match && 0 < token.Length() )

        {

        token.Set( items.NextToken() );

        if( token.Compare( aItem ) == 0 )

            {

            match = ETrue;

            }

        items.SkipSpace();

        }

    return match;

    }

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

// CCmsServerAsyncContact::DoGetDataLC

// 

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

//

HBufC* CCmsServerAsyncContact::DoGetDataLC( TInt aResourceId )

    {    

    //If full name is requested

    //Full name is created by using PbhkNameFormatter.

    HBufC* returnData = NULL;

    if( CCmsContactFieldItem::ECmsFullName == aResourceId )

        {  

        returnData = DoGetFullNameDataLC();         

        }

    else    

        {

        returnData = DoGetPhonebookDataLC( aResourceId );

        }

    return returnData;                           

    }

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

// CCmsServerAsyncContact::FindImAvailability

// 

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

//

TInt CCmsServerAsyncContact::FindImAvailabilityL()

    {

    TInt result( 0 );

    MCmsContactInterface& syncContact = iSyncContact;

    const MVPbkStoreContact& contact = syncContact.Contact();

    const MVPbkFieldType* type = iContactManager->FieldTypes().Find( R_VPBK_FIELD_TYPE_IMPP );

    CVPbkBaseContactFieldTypeIterator* itr = CVPbkBaseContactFieldTypeIterator::NewLC( *type, contact.Fields() );

    while( itr->HasNext() && result == 0 )

        {

        const MVPbkBaseContactField* field = itr->Next();

        const MVPbkContactFieldUriData& uri = MVPbkContactFieldUriData::Cast( field->FieldData() );