/*

* 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:  PIM item base implementation.

 *

*/

// CLASS HEADER

#include "cpimitem.h"

// INTERNAL INCLUDES

#include "cpimitemdata.h"

#include "mpimadaptermanager.h"

#include "mpimlistadapter.h"

#include "cpimvalidator.h"

#include "pimbase64converter.h"

#include "pimpanics.h"

#include "pimjnitools.h"

#include "pimutils.h"

#include "s60commonutils.h"

#include "jstringutils.h"

#include "logger.h"

// EXTERNAL INCLUDES

#include <e32std.h>

//CONSTANTS

const TInt KByteArrayGranularity = 8;

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

// CPIMItem::CPIMItem

// Default C++ constructor

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

//

CPIMItem::CPIMItem(const CPIMValidator& aValidator) :

        iValidator(aValidator)

{

    JELOG2(EPim);

}

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

// CPIMItem::ConstructL

// (other items were commented in a header)

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

//

void CPIMItem::ConstructL()

{

    JELOG2(EPim);

    // 5 for array granularity. Items is partial for default

    iInitializedFields = new(ELeave) CArrayFixFlat<TPIMField> (5);

    iItemID = KPIMNullItemID().AllocL();

    iItemData = CPIMItemData::NewL();

}

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

// CPIMItem::~CPIMItem

// (other items were commented in a header)

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

//

CPIMItem::~CPIMItem()

{

    JELOG2(EPim);

    delete iItemData;

    delete iItemID;

    delete iInitializedFields;

}

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

// CPIMItem::FieldDataType

// (other items were commented in a header)

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

//

TPIMFieldDataType CPIMItem::fieldDataType(const TPIMField& aField) const

{

    JELOG2(EPim);

    return iValidator.FieldDataType(aField);

}

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

// CPIMItem::ValidAttributes

// (other items were commented in a header)

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

//

TPIMAttribute CPIMItem::ValidAttributes() const

{

    JELOG2(EPim);

    return iValidator.ValidAttributes();

}

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

// CPIMItem::IsValidBooleanValue

// (other items were commented in a header)

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

//

TBool CPIMItem::IsValidBooleanValue(const TPIMField& aField,

                                    const TBool& aValue) const

{

    JELOG2(EPim);

    return iValidator.IsValidBooleanValue(aField, aValue);

}

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

// CPIMItem::IsValidDateValue

// (other items were commented in a header)

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

//

TBool CPIMItem::IsValidDateValue(const TPIMField& aField,

                                 const TPIMDate& aValue) const

{

    JELOG2(EPim);

    return iValidator.IsValidDateValue(aField, aValue);

}

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

// CPIMItem::IsValidIntegerValue

// (other items were commented in a header)

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

//

TBool CPIMItem::IsValidIntegerValue(const TPIMField& aField, const TInt& aValue) const

{

    JELOG2(EPim);

    return iValidator.IsValidIntegerValue(aField, aValue);

}

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

// CPIMItem::IsValidBinaryValue

// (other items were commented in a header)

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

//

TBool CPIMItem::IsValidBinaryValue(const TPIMField& aField,

                                   const CPIMByteArray& aValue) const

{

    JELOG2(EPim);

    return iValidator.IsValidBinaryValue(aField, aValue);

}

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

// CPIMItem::IsValidStringValue

// (other items were commented in a header)

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

//

TBool CPIMItem::IsValidStringValue(const TPIMField& aField, const HBufC& aValue) const

{

    JELOG2(EPim);

    return iValidator.IsValidStringValue(aField, aValue);

}

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

// CPIMItem::IsValidStringArrayValue

// (other items were commented in a header)

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

//

TBool CPIMItem::IsValidStringArrayValue(const TPIMField& aField,

                                        const CDesCArray& aValue) const

{

    JELOG2(EPim);

    return iValidator.IsValidStringArrayValue(aField, aValue);

}

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

// CPIMItem::SetModified

// (other items were commented in a header)

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

//

void CPIMItem::SetModified()

{

    JELOG2(EPim);

    SetModified(ETrue);

}

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

// CPIMItem::SetModified

// (other items were commented in a header)

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

//

void CPIMItem::SetModified(TBool aIsModified)

{

    JELOG2(EPim);

    iIsModified = aIsModified;

}

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

// CPIMItem::ListClosed

// (other items were commented in a header)

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

//

void CPIMItem::ListClosed()

{

    JELOG2(EPim);

    // The list adapter is owned by the associated list.

    iListAdapter = NULL;

}

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

// CPIMItem::CategoryRenamedL

// (other items were commented in a header)

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

//

void CPIMItem::CategoryRenamedL(const TDesC& aOldName, const TDesC& aNewName)

{

    JELOG2(EPim);

    // If the new name is same as the old name, nothing needs to be done

    if (aOldName == aNewName)

    {

        return;

    }

    // Take action only if the old category is found

    TInt oldCatIndex = iItemData->FindCategory(aOldName);

    if (oldCatIndex != KErrNotFound)

    {

        // Add the new category only if it is not already present

        if (iItemData->FindCategory(aNewName) == KErrNotFound)

        {

            // Not found, add

            iItemData->AddNewCategoryL(aNewName);

        }

        // It was checked earlier that the old and new category are

        // not the same, so we'll just delete the old category

        iItemData->RemoveCategory(aOldName);

    }

}

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

// CPIMItem::CategoryDeleted

// (other items were commented in a header)

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

//

TBool CPIMItem::CategoryDeleted(const TDesC& aCategory)

{

    JELOG2(EPim);

    return iItemData->RemoveCategory(aCategory);

}

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

// CPIMItem::RemoveAdapterAssociation

// (other items were commented in a header)

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

//

void CPIMItem::RemoveAdapterAssociation()

{

    JELOG2(EPim);

    iAdapterManager = NULL;

    iListAdapter = NULL;

}

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

// CPIMItem::LoadFullItemL

// (other items were commented in a header)

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

//

void CPIMItem::LoadFullItemL() const

{

    JELOG2(EPim);

    // Initialized fields are NULL if there is no need to

    // load any fields and the item has been fully constructed

    if (iInitializedFields && iListAdapter && (iItemID->Compare(KPIMNullItemID)

            != 0))

    {

        // Const cast is necessary. Call specialized class to load

        // full item if it is supported. The state of the item must

        // be changed by this call, because after this it is expected

        // that the item contains full item data and does not need to load

        CPIMItem* self = const_cast<CPIMItem*>(this);

        self->DoLoadFullItemL();

    }

}

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

// CPIMItem::LoadFieldL

// (other items were commented in a header)

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

//

void CPIMItem::LoadFieldL(const TPIMField aField) const

{

    JELOG2(EPim);

    // Initialized fields are NULL if there is no need to

    // load any fields and the item has been fully constructed

    if (iInitializedFields && iListAdapter && (iItemID->Compare(KPIMNullItemID)

            != 0))

    {

        // First check that the item data doesn't have this field

        if (iItemData->HasField(aField))

        {

            // Field has been loaded by the adapter

            iInitializedFields->AppendL(aField);

            return;

        }

        TInt index(0);

        TKeyArrayFix key(0, ECmpTInt);

        // The field needs to be loaded if it is not initialized

        if (iInitializedFields->Find(aField, key, index) != 0)

        {

            // Const cast is necessary. Call specialized class to load

            // full item if it is supported. The state of the item must

            // be changed by this call, because after this it is expected

            // that the item contains full item data and does not need to load

            CPIMItem* self = const_cast<CPIMItem*>(this);

            self->DoLoadFieldL(aField);

        }

    }

}

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

// CPIMItem::DoLoadFullItemL

// (other items were commented in a header)

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

//

void CPIMItem::DoLoadFullItemL()

{

    JELOG2(EPim);

    // Default implementation changes partial item to full item

    delete iInitializedFields;

    iInitializedFields = NULL;

}

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

// CPIMItem::DoLoadFieldL

// (other items were commented in a header)

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

//

void CPIMItem::DoLoadFieldL(const TPIMField aField)

{

    JELOG2(EPim);

    // Default implementation. Just adds the field to initialized fields

    // to mark that this field has been loaded from the database

    iInitializedFields->AppendL(aField);

}

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

// CPIMItem::UpdateUidFieldL

// (other items were commented in a header)

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

//

void CPIMItem::UpdateUidFieldL(const TPIMField& aUidStringField,

                               const TPIMItemID& aItemId)

{

    JELOG2(EPim);

    // Extra checking

    if (iAdapterManager && !iAdapterManager->IsSupportedField(aUidStringField))

    {

        return;

    }

    __ASSERT_DEBUG(iItemData->CountValues(aUidStringField) == 0

                   || iItemData->CountValues(aUidStringField) == 1, User::Panic(

                       KPIMPanicCategory, EPIMPanicInvalidState));

    // Remove the value from the field, if present

    if (aItemId != KPIMNullItemID)

    {

        // Create value class for this value

        HBufC* value = HBufC::NewLC(aItemId.Length());

        TPtr valuePtr(value->Des());

        valuePtr.Copy(aItemId);

        TPIMFieldData fieldData(aUidStringField, KPIMAttrNone, value);

        // The value must be overwritten if there is an existing one

        // Else just add new value

        if (iItemData->CountValues(aUidStringField) == 0)

        {

            iItemData->AddValueL(fieldData);

        }

        else

        {

            // There was a value so set a new one

            iItemData->SetValueL(fieldData);

        }

        CleanupStack::Pop(value);

    }

    // else we just leave the field empty

}

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

// CPIMItem::UpdateRevisionFieldL

// (other items were commented in a header)

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

//

void CPIMItem::UpdateRevisionFieldL(TPIMField aRevisionField,

                                    TPIMDate aLastModified)

{

    JELOG2(EPim);

    if (iAdapterManager && !iAdapterManager->IsSupportedField(aRevisionField))

    {

        return;

    }

    __ASSERT_DEBUG(iItemData->CountValues(aRevisionField) == 0

                   || iItemData->CountValues(aRevisionField) == 1, User::Panic(

                       KPIMPanicCategory, EPIMPanicInvalidState));

    // Create holder class for the value

    TPIMFieldData fieldData(aRevisionField, KPIMAttrNone, aLastModified);

    // Add new value if there is no old value. Set

    // new if there was value already

    if (iItemData->CountValues(aRevisionField) == 0)

    {

        iItemData->AddValueL(fieldData);

    }

    else

    {

        iItemData->SetValueL(fieldData);

    }

}

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

// CPIMItem::GetFieldsL

// (other items were commented in a header)

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

//

CArrayFix<TPIMField>* CPIMItem::GetFieldsL() const

{

    JELOG2(EPim);

    // We need to load full item to be sure that all

    // fields are filled to this item. This is performed

    // only when the item is associated with a list

    LoadFullItemL();

    // Return value

    CArrayFix<TPIMField>* fields = iItemData->FieldsLC();

    // If this item belongs to a list, we'll sort the result according

    // to the order of the supported fields

    if (iAdapterManager)

    {

        CArrayFixFlat<TPIMField>* sortedFields = new(ELeave) CArrayFixFlat<

        TPIMField> (5);

        CleanupStack::PushL(sortedFields);

        const CArrayFix<TPIMField>& supportedFields =

            iAdapterManager->GetSupportedFieldsL();

        const TInt numSupportedFields = supportedFields.Count();

        for (TInt suppIndex = 0; suppIndex < numSupportedFields; suppIndex++)

        {

            const TPIMField supportedField = supportedFields[suppIndex];

            const TInt numPresentFields = fields->Count();

            for (TInt presIndex = 0; presIndex < numPresentFields; presIndex++)

            {

                const TPIMField presentField = (*fields)[presIndex];

                if (supportedField == presentField)

                {

                    sortedFields->AppendL(presentField);

                    fields->Delete(presIndex);

                    break;

                }

            }

        }

        // There shouldn't be any fields left BUT if there are, we'll

        // append them to the end of the result array

        const TInt numFieldsLeft = fields->Count();

        for (TInt leftIndex = 0; leftIndex < numFieldsLeft; leftIndex++)

        {

            sortedFields->AppendL((*fields)[leftIndex]);

        }

        // Replace the original result array with the sorted array

        CleanupStack::Pop(sortedFields);

        CleanupStack::PopAndDestroy(fields);

        fields = sortedFields;

    }

    else

    {

        CleanupStack::Pop(fields);

    }

    return fields;

}

//void

jintArray CPIMItem::callGetFields(JNIEnv* aJniEnv/*, jintArray aJavaFields*/)

{

    JELOG2(EPim);

    CArrayFix<TPIMField>* fields = NULL;

    TInt error = KErrNone;

    TRAP(error, fields = GetFieldsL());

    if (error != KErrNone)

    {

        // If a leave occurred the field array was never created.

        return NULL;

    }

    // We now own the field array

    jintArray javaFields = ConvertToJavaIntArray(*aJniEnv, *fields);

    delete fields;

    return javaFields;

}

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

// CPIMItem::IsModified

// (other items were commented in a header)

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

//

bool CPIMItem::isModified() const

{

    JELOG2(EPim);

    if (iIsModified)

        return true;

    return false;

}

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

// CPIMItem::GetBinaryL

// (other items were commented in a header)

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

//

CPIMByteArray* CPIMItem::GetBinaryL(TPIMField aField, TInt aIndex) const

{

    JELOG2(EPim);

    const CPIMByteArray& byteArray = GetBinaryRawL(aField, aIndex);

    return PIMBase64Converter::EncodeBase64L(byteArray);