/*

* Copyright (c) 2005-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:  Phonebook 2 vCard converter.

*

*/

#include "CPbk2vCardConverter.h"

// Phonebook 2

#include "Pbk2SendCmdUtils.h"

#include <CPbk2AttachmentFile.h>

#include <Pbk2Commands.rsg>

#include <Pbk2CmdExtRes.rsg>

#include <MPbk2ContactLinkIterator.h>

// Virtual Phonebook

#include <CVPbkVCardEng.h>

#include <MVPbkStoreContact.h>

#include <MPbk2ContactNameFormatter.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactFieldData.h>

#include <CVPbkContactManager.h>

#include <MVPbkFieldType.h>

#include <TVPbkFieldTypeMapping.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactFieldDateTimeData.h>

#include <MVPbkContactFieldBinaryData.h>

#include <MVPbkContactFieldUriData.h>

#include <MVPbkContactLink.h>

// System includes

#include <barsread.h>

#include <coemain.h>

// Debugging headers

#include <Pbk2Debug.h>

/// Unnamed namespace for local functions

namespace {

// CONSTANTS

_LIT(KPbk2vCardFileExtension, ".vcf");

// LOCAL FUNCTIONS

/**

 * Creates an empty vCard file from the given contact.

 *

 * @param aFs               File server session handle.

 * @param aContact          The contact.

 * @param aNameFormatter    Contact name formatter.

 * @return  Created vCard file.

 */

CPbk2AttachmentFile* CreateEmptyvCardFileL

        ( RFs& aFs, const MVPbkStoreContact& aContact,

          MPbk2ContactNameFormatter& aNameFormatter )

    {

    // Create the file name using contact's name

    HBufC* name = aNameFormatter.GetContactTitleL

        ( aContact.Fields(),

          MPbk2ContactNameFormatter::EPreserveLeadingSpaces );

    CleanupStack::PushL(name);

    HBufC* fileNameBuf = HBufC::NewLC(

        name->Length() + KPbk2vCardFileExtension().Length());

    TPtr fileName = fileNameBuf->Des();

    fileName = *name;

    fileName.Append(KPbk2vCardFileExtension);

    // Create attachment file object

    CPbk2AttachmentFile* result = CPbk2AttachmentFile::NewL

        (fileName, aFs, EFileWrite|EFileStream|EFileShareExclusive);

    CleanupStack::PopAndDestroy(2);  // fileNameBuf, name

    return result;

    }

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicLogic_AddFieldToContactL = 1,

    EPanicInvalidStorageType,

    EPanicPostCond_PrepareContactL

    };

void Panic(TPanicCode aReason)

    {

    _LIT(KPanicText, "CPbk2vCardConverter");

    User::Panic(KPanicText,aReason);

    }

#endif // _DEBUG

}  /// namespace

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

// CPbk2vCardConverter::CPbk2vCardConverter

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

//

inline CPbk2vCardConverter::CPbk2vCardConverter

        (RFs& aFs, CVPbkContactManager& aEngine, CVPbkVCardEng& aVCardEngine,

        MPbk2ContactNameFormatter& aNameFormatter) :

            CActive(EPriorityIdle),

            iFs(aFs), iEngine(aEngine), iVCardEngine(aVCardEngine),

            iNameFormatter(aNameFormatter), iField(NULL),

            iObserver(NULL), iOpIndex(0), iFieldLevelOperation(EFalse),

            iNextDriveTried(EFalse)

    {

    }

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

// CPbk2vCardConverter::~CPbk2vCardConverter

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

//

CPbk2vCardConverter::~CPbk2vCardConverter()

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter, destructor (0x%x)"), this);

    Cancel();

    if (iVcardFiles)

        {

        iVcardFiles->ResetAndDestroy();

        delete iVcardFiles;

        }

    delete iVCardFile;

    delete iVCardContact;

    iFileWriteStream.Close();

    delete iContactOperation;

    iContacts.Reset(); // iContacts does not own its items

    }

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

// CPbk2vCardConverter::ConstructL

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

//

inline void CPbk2vCardConverter::ConstructL()

    {

    CActiveScheduler::Add(this);

    iVcardFiles = new(ELeave) CPbk2AttachmentFileArray(1);

    }

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

// CPbk2vCardConverter::CPbk2vCardConverter

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

//

CPbk2vCardConverter* CPbk2vCardConverter::NewL

        ( RFs& aFs, CVPbkContactManager& aEngine,

          CVPbkVCardEng& aVCardEngine,

          MPbk2ContactNameFormatter& aNameFormatter )

    {

    CPbk2vCardConverter* self = new(ELeave) CPbk2vCardConverter

        ( aFs,aEngine,aVCardEngine, aNameFormatter );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CPbk2vCardConverter::ConvertContactL

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

//

void CPbk2vCardConverter::ConvertContactL

        ( const TArray<MVPbkStoreContact*> aContacts,

          const MVPbkBaseContactField* aField, TInt aDataToSend,

          MPbk2vCardConverterObserver& aObserver )

    {

    iField = aField;

    iFieldLevelOperation = ETrue;

    ConvertContactsL(aContacts, aDataToSend, aObserver);

    }

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

// CPbk2vCardConverter::ConvertContactsL

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

//

void CPbk2vCardConverter::ConvertContactsL

        ( const TArray<MVPbkStoreContact*> aContacts,

          TInt aDataToSend, MPbk2vCardConverterObserver& aObserver )

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::ConvertContactsL(0x%x)"), this);

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::ConvertContactsL, Contacts Count=%d"), 

        aContacts.Count());

    Reset();

    iObserver = &aObserver;

    iDataToSend = aDataToSend;

    for (TInt i = 0; i < aContacts.Count(); ++i)

        {

        iContacts.AppendL(aContacts[i]);

        }

    Start();

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::ConvertContactsL, end (0x%x)"), this);

    }

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

// CPbk2vCardConverter::ConvertContactsL

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

//

void CPbk2vCardConverter::ConvertContactsL

        ( MPbk2ContactLinkIterator& aIterator, TInt aDataToSend,

          MPbk2vCardConverterObserver& aObserver )

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::ConvertContactsL, dataToSend=%d"), aDataToSend);

    Reset();

    iObserver = &aObserver;

    iDataToSend = aDataToSend;

    iIterator = &aIterator;

    Start();

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::ConvertContactsL, end (0x%x)"), this);

    }

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

// CPbk2vCardConverter::FileNames

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

//

MDesC16Array& CPbk2vCardConverter::FileNames() const

    {

    return ( *iVcardFiles );

    }

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

// CPbk2vCardConverter::Reset

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

//

void CPbk2vCardConverter::Reset()

    {

    iIterator = NULL;

    iVcardFiles->ResetAndDestroy();

    iDataToSend = ESendAllData;

    if (!iFieldLevelOperation)

        {

        iField = NULL;

        }

    }

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

// CPbk2vCardConverter::AttachmentFileArray

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

//

CPbk2AttachmentFileArray& CPbk2vCardConverter::AttachmentFileArray()

    {

    return *iVcardFiles;

    }

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

// CPbk2vCardConverter::RunL

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

//

void CPbk2vCardConverter::RunL()

    {

    if ( iIterator && iIterator->HasNext() )

        {

        HandleNextContactL( NULL );

        }

    else if (iOpIndex < iContacts.Count())

        {

        HandleNextContactL( iContacts[iOpIndex] );

        ++iOpIndex;

        }

    else

        {

        iObserver->ConversionDone(iOpIndex);

        }

    }

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

// CPbk2vCardConverter::DoCancel

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

//

void CPbk2vCardConverter::DoCancel()

    {

    // Do nothing

    }

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

// CPbk2vCardConverter::RunError

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

//

TInt CPbk2vCardConverter::RunError(TInt aError)

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::RunError=%d"), aError);

    Reset();

    iObserver->ConversionError(aError);

    return aError;

    }

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

// CPbk2vCardConverter::VPbkSingleContactOperationComplete

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

//

void CPbk2vCardConverter::VPbkSingleContactOperationComplete

        ( MVPbkContactOperationBase& /*aOperation*/ ,

          MVPbkStoreContact* aContact )

    {

    if ( iRetrieveOperation )

        {

        delete iRetrieveOperation;

        iRetrieveOperation = NULL;

        TRAPD( err, HandleNextContactL( aContact ) );

        delete aContact;

        aContact = NULL;

        if ( err != KErrNone )

            {

            CCoeEnv::Static()->HandleError( err );        

            }

        }

    else

        {

        delete iContactOperation;

        iContactOperation = NULL;

        // Delete temp contact

        delete iVCardContact;

        iVCardContact = NULL;

        FinalizeVCardExport();

        IssueRequest();

        }

    }

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

// CPbk2vCardConverter::VPbkSingleContactOperationFailed

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

//

void CPbk2vCardConverter::VPbkSingleContactOperationFailed

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

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

      ("CPbk2vCardConverter::VPbkSingleContactOperationFailed (0x%x)"), this);

    if ( iRetrieveOperation )

        {

        delete iRetrieveOperation;

        iRetrieveOperation = NULL;

        }

    else

        {

        delete iContactOperation;

        iContactOperation = NULL;

        iFileWriteStream.Close();

        if ( iNextDriveTried )

            {

            delete iVCardFile;

            iVCardFile = NULL;

			RunError( aError );

            }

        else

            {

            TRAPD( err, 

 	        	{

				// Try to switch next drive if previous failed

               iVCardFile->SwitchDriveL();

               iFileWriteStream.Attach( iVCardFile->File() );

               iContactOperation = iVCardEngine.ExportVCardL

                    ( iFileWriteStream, *iVCardContact, *this );

                }); // TRAPD

            if ( err != KErrNone )

           		{

            	RunError( aError );

            	}

            iNextDriveTried = ETrue;

            }

        }

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::VPbkSingleContactOperationFailed, end"), this);

    }

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

// CPbk2vCardConverter::CreatevCardFileL

// Creates a file containing vCard of aContact and attaches the file to

// internal list of files.

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

//

void CPbk2vCardConverter::CreatevCardFileL(MVPbkStoreContact* aContact)

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::CreatevCardFileL (0x%x)"), this);

    // Check first, is the contact item empty

    // If the contact is not empty, file it so it gets sent

    if (!Pbk2SendCmdUtils::IsContactEmpty(aContact))

        {

        iVCardFile = CreateEmptyvCardFileL(iFs, *aContact, iNameFormatter);

        // Create temp handle, so that iVCardFile stays valid until we close

        // it. Stream will take care of closing tempHandle when closing stream

        RFile tempHandle;

        tempHandle.Duplicate( iVCardFile->File() );

        iFileWriteStream.Attach( tempHandle );

        iContactOperation =

            iVCardEngine.ExportVCardL(iFileWriteStream, *aContact, *this);

        }

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::CreatevCardFileL, end (0x%x)"), this);

    }

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

// CPbk2vCardConverter::PrepareContactL

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

//

MVPbkStoreContact* CPbk2vCardConverter::PrepareContactL

        ( MVPbkStoreContact* aContact )

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::PrepareContactL (0x%x)"), this);

    MVPbkStoreContact* vCardContact = NULL;

    // Create a temporary contact

    vCardContact = aContact->ParentStore().CreateNewContactLC();

    // Copy currently focused field's data to a dummy contact

    FillTemporaryContactL(*vCardContact, *aContact, *iField);

    __ASSERT_DEBUG(vCardContact, Panic(EPanicPostCond_PrepareContactL));

    CleanupStack::Pop(); // vCardContact

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::PrepareContactL, end (0x%x)"), this);

    return vCardContact;

    }

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

// CPbk2vCardConverter::FillTemporaryContactL

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

//

void CPbk2vCardConverter::FillTemporaryContactL

        ( MVPbkStoreContact& aDestItem,

          const MVPbkStoreContact& aSourceItem,

          const MVPbkBaseContactField& aDataField ) const

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::FillTemporaryContactL (0x%x)"), this);

    if (iDataToSend == ESendAllData)

        {

        TInt fieldCount = aSourceItem.Fields().FieldCount();

        PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2vCardConverter::FillTemporaryContactL, fieldCount=%d"), 

        fieldCount);

        const MVPbkStoreContactFieldCollection& fieldSet =

            aSourceItem.Fields();

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

            {

            const MVPbkStoreContactField& field = fieldSet.FieldAt(i);

            AddFieldToContactL(aDestItem, field);

            }

        }

    else if (iDataToSend == ESendAllDataWithoutPicture)

        {

        TInt fieldCount = aSourceItem.Fields().FieldCount();

        const MVPbkStoreContactFieldCollection& fieldSet =

            aSourceItem.Fields();

        const MVPbkFieldType& thumbnailFieldType =

                Pbk2SendCmdUtils::ReadFieldTypeFromResL(

                    R_THUMBNAIL_FIELD_TYPE, iEngine.FieldTypes());            

        const MVPbkFieldType& imageFieldType =

                    Pbk2SendCmdUtils::ReadFieldTypeFromResL(

                        R_IMAGE_FIELD_TYPE, iEngine.FieldTypes());                    

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

            {

            const MVPbkStoreContactField& field = fieldSet.FieldAt(i);

            // Do not add thumbnail or image            

            if (!Pbk2SendCmdUtils::IsFieldMatching(

                    field, thumbnailFieldType, iEngine.FieldTypes()) &&

                !Pbk2SendCmdUtils::IsFieldMatching(

                        field, imageFieldType, iEngine.FieldTypes()))

                {                                

                AddFieldToContactL(aDestItem, field);

                }

            }

        }

    else // ESendCurrentItem

        {

        // Actual single data field

        AddFieldToContactL(aDestItem, aDataField);

        // According to specification lastname & firstname

        // (when existing) must be added when sending single item

        const MVPbkBaseContactField* lastName =

            Pbk2SendCmdUtils::FindFieldL(

                aSourceItem, R_LNAME_FIELD_TYPE, iEngine.FieldTypes());

        if (lastName)

            {

            if (!lastName->FieldData().IsEmpty())

                {

                AddFieldToContactL(aDestItem, *lastName);

                }

            }

        const MVPbkBaseContactField* firstName =

            Pbk2SendCmdUtils::FindFieldL(

                aSourceItem, R_FNAME_FIELD_TYPE, iEngine.FieldTypes());

        if (firstName)

            {

            if (!firstName->FieldData().IsEmpty())

                {

                AddFieldToContactL(aDestItem, *firstName);

                }

            }

        }

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

       ("CPbk2vCardConverter::FillTemporaryContactL, end (0x%x)"), this);

    }