/*

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

*          Provides phonebook card converter class methods

*

*/

// INCLUDE FILES

#include "CPbkvCardConverter.h"

#include <CPbkFieldInfo.h>

#include <CPbkContactEngine.h>

#include <CPbkContactItem.h>

#include <CPbkAttachmentFile.h>

#include <BCardEng.h>

#include <pbkdebug.h>

// Unnamed namespace for local functions

namespace {

// LOCAL FUNCTIONS

CPbkAttachmentFile* CreateEmptyvCardFileLC

        (RFs& aFs, const CPbkContactItem& aContact)

    {

    // Create the file name using contact's name

    HBufC* name = aContact.GetContactTitleL();

    CleanupStack::PushL(name);

    HBufC* fileNameBuf = HBufC::NewLC(name->Length() + KPbkvCardFileExtension().Length());

    TPtr fileName = fileNameBuf->Des();

    fileName = *name;

    fileName.Append(KPbkvCardFileExtension);

    // Create attachment file object

    CPbkAttachmentFile* result = CPbkAttachmentFile::NewL

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

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

    CleanupStack::PushL(result);

    return result;

    }

void WritevCardFileL

        (CBCardEngine& aBcardEngine,

        RFileWriteStream& aStream, 

        CPbkContactItem& aContact)

    {

    aBcardEngine.ExportBusinessCardL(aStream, aContact);

    aStream.CommitL();

    }

void WritevCardToAttachmentFileL

        (CBCardEngine& aBcardEngine,

        CPbkAttachmentFile& vCardFile, 

        CPbkContactItem& aContact)

    {

    // Write vCard to attachment file

    TBool retry=EFalse;

    do

        {

        RFileWriteStream fileWriteStream(vCardFile.File());

        fileWriteStream.PushL();

        TRAPD(err, WritevCardFileL(aBcardEngine,fileWriteStream,aContact));

        if (err != KErrNone)

            {

            if (retry)

                {

                // Out of retry attempts

                User::Leave(err);

                }

            // If write fails, try again on different drive

            vCardFile.SwitchDriveL();

            retry = ETrue;

            }

        CleanupStack::PopAndDestroy(); // fileWriteStream

        }

    while (retry);

    }

// LOCAL DEBUG CODE

#ifdef _DEBUG

enum TPanicCode

    {

	EPanicLogic_AddFieldToContactL = 1,

    EPanicInvalidStorageType,

    EPanicPostCond_PrepareContactLC

    };

void Panic(TPanicCode aReason)

    {

    _LIT(KPanicText, "CPbkvCardConverter");

    User::Panic(KPanicText,aReason);

    }

#endif // _DEBUG

}  // namespace

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

inline CPbkvCardConverter::CPbkvCardConverter

        (RFs& aFs, CPbkContactEngine& aEngine, CBCardEngine& aBCardEngine) :

    iFs(aFs), iEngine(aEngine), iBCardEngine(aBCardEngine), iField(NULL)

    {

    }

inline void CPbkvCardConverter::ConstructL()

    {

    iVcardFiles = new(ELeave) CPbkAttachmentFileArray(1);

    }

CPbkvCardConverter* CPbkvCardConverter::NewL

        (RFs& aFs,

        CPbkContactEngine& aEngine, 

        CBCardEngine& aBCardEngine)

    {

    CPbkvCardConverter* self =

        new(ELeave) CPbkvCardConverter (aFs,aEngine,aBCardEngine);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CPbkvCardConverter::~CPbkvCardConverter()

    {

    delete iContacts;

    if (iVcardFiles)

        {

        iVcardFiles->ResetAndDestroy();

        delete iVcardFiles;

        }

    }

void CPbkvCardConverter::ConvertContactL(TContactItemId aContactId,

        TPbkContactItemField* aField, TInt aDataToSend)

    {

    Reset();

    iDataToSend = aDataToSend;

    iField = aField;

    if (!iContacts)

        {

        iContacts = CContactIdArray::NewL();

        }

    iContacts->AddL(aContactId);

    }

void CPbkvCardConverter::ConvertContactsL(const CContactIdArray& aContacts,

        TInt aDataToSend)

    {

    Reset();

    iDataToSend = aDataToSend;

    delete iContacts;

    iContacts = NULL;

    iContacts = CContactIdArray::NewL(&aContacts);

    }

MDesC16Array& CPbkvCardConverter::FileNames() const

    {

    return (*iVcardFiles);

    }

void CPbkvCardConverter::StepL()

    {

    if (iContacts && iContacts->Count() > 0)

        {

        const TInt index = iContacts->Count()-1;

        const TContactItemId contactId = (*iContacts)[index];

        iContacts->Remove(index);

        CreatevCardFileL(contactId);

        }

    }

TInt CPbkvCardConverter::TotalNumberOfSteps()

    {

    TInt ret(0);

    if (iContacts && iContacts->Count() > 0)

        {

        ret = iContacts->Count();

        }

    return ret;

    }

TBool CPbkvCardConverter::IsProcessDone() const

    {

    return (!iContacts || iContacts->Count()==0);

    }

void CPbkvCardConverter::ProcessFinished()

    {

    }

TInt CPbkvCardConverter::HandleStepError(TInt aError)

    {

    Reset();

    return aError;

    }

void CPbkvCardConverter::ProcessCanceled()

    {

    Reset();

    }

void CPbkvCardConverter::Reset()

    {

    iVcardFiles->ResetAndDestroy();

    iDataToSend = ESendAllData;

    if (iContacts)

        {

        iContacts->Reset();

        }

    iField = NULL;

    }

/**

 * Creates a file containing vCard of aContactId and attaches the file to 

 * internal list of files.

 */

void CPbkvCardConverter::CreatevCardFileL(TContactItemId aContactId)

    {

    // Prepare contact by cropping image or other fields if so desired

    CPbkContactItem* vCardContact = PrepareContactLC(aContactId);

	// Check first, is the contact item empty

	TBool emptyContact(ETrue);

	TInt fieldCount = vCardContact->CardFields().Count();

	CPbkFieldArray& fieldSet = vCardContact->CardFields();

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

		{

		TPbkContactItemField field = fieldSet[i];

		if (!field.IsEmptyOrAllSpaces())

			{

			// There was a field, which was not empty (or all spaces),

			// that's enough for us, the contact gets sent

			emptyContact = EFalse;

			break;

			}

		}

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

	if (!emptyContact)

		{

		CPbkAttachmentFile* vCardFile = CreateEmptyvCardFileLC(iFs, *vCardContact);

		WritevCardToAttachmentFileL(iBCardEngine, *vCardFile, *vCardContact);

		iVcardFiles->AppendL(vCardFile);

		CleanupStack::Pop(vCardFile);

		}

    CleanupStack::PopAndDestroy(vCardContact);

    }

CPbkContactItem* CPbkvCardConverter::PrepareContactLC(TContactItemId aContactId)

    {

    CPbkContactItem* vCardContact = NULL;

    if (iDataToSend == ESendAllData)

        {

        // If all data is to be sent, just read aContactId

        // into a contact item...

        vCardContact = iEngine.ReadContactLC(aContactId);

        }

    else

        {

        // ...otherwise create a temporary contact

        vCardContact = iEngine.CreateEmptyContactL();

        CleanupStack::PushL(vCardContact);

        CPbkContactItem* sourceContact = iEngine.ReadContactLC(aContactId);

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

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

        CleanupStack::PopAndDestroy(sourceContact);

        }

    __ASSERT_DEBUG(vCardContact, Panic(EPanicPostCond_PrepareContactLC));

    return vCardContact;

    }

void CPbkvCardConverter::FillTemporaryContactL(CPbkContactItem& aDestItem,

        CPbkContactItem& aSourceItem, const TPbkContactItemField& aDataField) const

    {

    if (iDataToSend == ESendAllDataWithoutPicture)

        {

	    TInt fieldCount = aSourceItem.CardFields().Count();

	    CPbkFieldArray& fieldSet = aSourceItem.CardFields();

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

		    {

		    TPbkContactItemField field = fieldSet[i];

            // Do not add thumbnail

            if (field.PbkFieldId() != EPbkFieldIdThumbnailImage)

                {

                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

        if ( aDataField.FieldInfo().FieldId() != EPbkFieldIdLastName )

            {

            TPbkContactItemField* lastName =

    		    aSourceItem.FindField(EPbkFieldIdLastName);

            if (lastName)

                {

                if (!lastName->IsEmptyOrAllSpaces())

                    {

                    AddFieldToContactL(aDestItem, *lastName);

                    }

                }

            }

        if ( aDataField.FieldInfo().FieldId() != EPbkFieldIdFirstName )

            {

            TPbkContactItemField* firstName =

    		    aSourceItem.FindField(EPbkFieldIdFirstName);

            if (firstName)

                {

                if (!firstName->IsEmptyOrAllSpaces())

                    {

                    AddFieldToContactL(aDestItem, *firstName);

                    }

                }

            }

        }

    }

void CPbkvCardConverter::AddFieldToContactL(

        CPbkContactItem& aDestItem, 

        const TPbkContactItemField& aSourceField) const

    {

    TPbkContactItemField* dstField =

		aDestItem.AddOrReturnUnusedFieldL(aSourceField.FieldInfo());

    __ASSERT_DEBUG(dstField, Panic(EPanicLogic_AddFieldToContactL));

    switch (dstField->StorageType())

        {

        case KStorageTypeText:

            {

            HBufC* data = aSourceField.Text().AllocL();

            dstField->TextStorage()->SetText(data); // takes ownership of data

            break;

            }

        case KStorageTypeDateTime:

            {

            TTime time = aSourceField.DateTimeStorage()->Time();

            dstField->DateTimeStorage()->SetTime(time);

            break;

            }

        default:

            {

            __ASSERT_DEBUG(EFalse, Panic(EPanicInvalidStorageType));

            break;

            }

        }    

    }

//  End of File