/*

* 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:  Abstract PIMList base class.

 *

*/

// INCLUDE FILES

#include  "cpimlist.h"

#include  "mpimadaptermanager.h"

#include  "mpimlistadapter.h"

#include  "mpimlocalizationdata.h"

#include  "cpimvalidator.h"

#include  "cpimitem.h"

#include  "cpimitemmatcher.h"

#include  "cpimstringmatcher.h"

#include  "pimexternalchanges.h"

#include  "pimpanics.h"

#include  "pimjnitools.h"

#include  "pimutils.h"

#include  "s60commonutils.h"

#include  "jstringutils.h"

#include "logger.h"

// CONSTANTS

/** Item array granularity. */

const TInt KItemArrayGranularity = 8;

CPIMList::CPIMList(const CPIMValidator& aValidator) :

        iItems(KItemArrayGranularity), iValidator(aValidator) // not owned

{

    JELOG2(EPim);

}

void CPIMList::ConstructL(MPIMLocalizationData* aLocalizationData,

                          MPIMAdapterManager* aAdapterManager, MPIMListAdapter* aListAdapter)

{

    JELOG2(EPim);

    iLocalizationData = aLocalizationData; // not owned

    iAdapterManager = aAdapterManager; // not owned

    iListAdapter = aListAdapter; // not owned

}

CPIMList::~CPIMList()

{

    JELOG2(EPim);

    iItems.Close();

}

pimbaseitem* CPIMList::createItem()

{

    JELOG2(EPim);

    TInt error = KErrNone;

    CPIMItem* item = NULL;

    TRAP(error, item = DoCreateItemL(KPIMNullItemID(), NULL));

    if (error != KErrNone)

        throw error;

    item->SetModified(ETrue);

    return item;

}

void CPIMList::removeItem(pimbaseitem* aItem)

{

    JELOG2(EPim);

    TInt error = KErrNone;

    TRAP(error,

    {

        if (!iListAdapter)

        {

            User::Leave(KErrSessionClosed);

        }

        CPIMItem* item = static_cast<CPIMItem*>(aItem);

        // Find the item in the list

        TInt itemIndex = iItems.Find(item);

        if (itemIndex == KErrNotFound)

        {

            // The item is not in the list

            User::Leave(KErrArgument);

        }

        // Remove item from native database.

        // If the item does not exist any more in the database, we will

        // not touch but let the update mechanism clean it away at

        // some other time.

        DoDeleteItemL(*item);

        // Remove item from the list

        item->RemoveAdapterAssociation();

        iItems.Remove(itemIndex);

        // The item is owned by its Java side peer, so we won't

        // delete it here.

    }

        );

    if (error != KErrNone)

        throw error;

}

void CPIMList::addCommittedItem(pimbaseitem* aItem)

{

    JELOG2(EPim);

    CPIMItem* item = static_cast<CPIMItem*>(aItem);

    TInt error = KErrNone;

    TRAP(error,

    {

        __ASSERT_DEBUG(

            iItems.Find(item)== KErrNotFound,

            User::Panic(KPIMPanicCategory, EPIMPanicCommittedExists));

        User::LeaveIfError(iItems.Append(item));

    }

        );

    if (error != KErrNone)

        throw error;

}

jstring CPIMList::getName(JNIEnv* aJniEnv)

{

    JELOG2(EPim);

    HBufC* name = NULL;

    TInt error = KErrNone;

    TRAP(error, name = iAdapterManager->ListNameL().AllocL());

    if (error != KErrNone || !name)

    {

        // If a leave occurred the name was never created

        return NULL;

    }

    jstring javaName = java::util::S60CommonUtils::NativeToJavaString(

                           *aJniEnv, *name);

    delete name;

    return javaName; // if NULL, it indicates error

}

void CPIMList::close()

{

    JELOG2(EPim);

    if (!iListAdapter)

    {

        throw KErrSessionClosed;

    }

    // Close the list adapter

    iListAdapter->Close();

    // Notify items about closing list

    const TInt n = iItems.Count();

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

    {

        iItems[i]->ListClosed();

    }

    // Setting the list adapter NULL denotes closed list

    iListAdapter = NULL;

}

jintArray CPIMList::callItemsByEnumerationType(JNIEnv* aJniEnv,

        int aEnumerationType, int aMatchingItemHandle, jstring aStringArg,

        jintArray aError)

{

    JELOG2(EPim);

    const JStringUtils stringArg(*aJniEnv, aStringArg);

    const TDesC* nativeStringArg = (aStringArg ? &stringArg : NULL);

    TInt error = KErrNone;

    jintArray itemHandles = NULL;

    TRAP(error, itemHandles = CallItemsByEnumerationTypeL(aJniEnv,

                              aEnumerationType, aMatchingItemHandle, nativeStringArg));

    SetJavaErrorCode(aJniEnv, aError, error);

    return itemHandles;

}

jintArray CPIMList::CallItemsByEnumerationTypeL(JNIEnv* aJniEnv,

        int aEnumerationType, int aMatchingItemHandle,

        const TDesC* aStringArg)

{

    JELOG2(EPim);

    RPointerArray<CPIMItem>* items = NULL;

    if (aEnumerationType == EPIMItemAll)

    {

        items = ItemsL();

    }

    else if (aEnumerationType == EPIMItemMatchingItem)

    {

        pimbaseitem * baseMatchingItem =

            reinterpret_cast<pimbaseitem *>(aMatchingItemHandle);

        CPIMItem* matchingItem =

            static_cast<CPIMItem *>(baseMatchingItem);

        items = ItemsL(*matchingItem);

    }

    else if (aEnumerationType == EPIMItemMatchingString)

    {

        __ASSERT_DEBUG(aStringArg, User::Panic(KPIMPanicCategory,

                                               EPIMPanicNullArgument));

        items = ItemsL(*aStringArg);

    }

    else if (aEnumerationType == EPIMItemMatchingCategory)

    {

        // Category argument may be NULL, indicating "uncategorized"

        items = ItemsByCategoryL(aStringArg);

    }

    else

    {

        User::Leave(KErrCorrupt); // Error

    }

    // We now own the items array

    jintArray itemHandles = GetJavaItemHandles(*aJniEnv, *items);

    items->Close();

    delete items;

    items = NULL;

    if (!itemHandles)

    {

        User::Leave(KErrNoMemory);

    }

    return itemHandles;

}

RPointerArray<CPIMItem>* CPIMList::ItemsL()

{

    JELOG2(EPim);

    if (!iListAdapter)

    {

        User::Leave(KErrSessionClosed);

    }

    // Put all items in an array as MPIMItemData objects

    RPointerArray<MPIMItem> tempArr(KItemArrayGranularity);

    CleanupClosePushL(tempArr);

    const TInt n = iItems.Count();

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

    {

        CPIMItem* item = iItems[i];

        User::LeaveIfError(tempArr.Append(item));

    }

    TLinearOrder<MPIMItem> order(iAdapterManager->ItemOrder());

    RPointerArray<CPIMItem>* retArr = SortAndConvertToCPIMItemsL(order,

                                      tempArr);

    CleanupStack::PopAndDestroy(); // tempArr cleanup close

    return retArr;

}

RPointerArray<CPIMItem>* CPIMList::ItemsL(const CPIMItem& aMatchingItem)

{

    JELOG2(EPim);

    if (!iListAdapter)

    {

        User::Leave(KErrSessionClosed);

    }

    // Matching items are inserted temporarily into this array for sorting

    RPointerArray<MPIMItem> tempArr(KItemArrayGranularity);

    CleanupClosePushL(tempArr);

    CPIMItemMatcher* itemMatcher = CPIMItemMatcher::NewLC(iValidator,

                                   *iAdapterManager, aMatchingItem);

    const TInt numItems = iItems.Count();

    for (TInt itemIndex = 0; itemIndex < numItems; itemIndex++)

    {

        CPIMItem* listItem = iItems[itemIndex];

        if (itemMatcher->MatchL(*listItem))

        {

            User::LeaveIfError(tempArr.Append(listItem));

        }

    }

    CleanupStack::PopAndDestroy(itemMatcher);

    TLinearOrder<MPIMItem> order(iAdapterManager->ItemOrder());

    RPointerArray<CPIMItem>* retArr = SortAndConvertToCPIMItemsL(order,

                                      tempArr);

    CleanupStack::PopAndDestroy(); // tempArr cleanup close

    return retArr;

}

RPointerArray<CPIMItem>* CPIMList::ItemsL(const TDesC& aMatchingValue)

{

    JELOG2(EPim);

    if (!iListAdapter)

    {

        User::Leave(KErrSessionClosed);

    }

    // Matching items are inserted temporarily into this array for sorting

    RPointerArray<MPIMItem> tempArr(KItemArrayGranularity);

    CleanupClosePushL(tempArr);

    CPIMStringMatcher* stringMatcher =

        new(ELeave) CPIMStringMatcher(iValidator);

    CleanupStack::PushL(stringMatcher);

    // Iterate through all items in the list

    const TInt numItems = iItems.Count();

    for (TInt itemIndex = 0; itemIndex < numItems; itemIndex++)

    {

        CPIMItem* listItem = iItems[itemIndex];

        if (stringMatcher->MatchL(aMatchingValue, *listItem))

        {

            User::LeaveIfError(tempArr.Append(listItem));

        }

    }

    CleanupStack::PopAndDestroy(stringMatcher);

    TLinearOrder<MPIMItem> order(iAdapterManager->ItemOrder());

    RPointerArray<CPIMItem>* retArr = SortAndConvertToCPIMItemsL(order,

                                      tempArr);

    CleanupStack::PopAndDestroy(); // tempArr cleanup close

    return retArr;

}

RPointerArray<CPIMItem>* CPIMList::ItemsByCategoryL(

    const TDesC* aCategory)

{

    JELOG2(EPim);

    if (!iListAdapter)

    {

        User::Leave(KErrSessionClosed);

    }

    // Matching items are inserted temporarily into this array for sorting

    RPointerArray<MPIMItem> tempArr(KItemArrayGranularity);

    CleanupClosePushL(tempArr);

    // Iterate through all items in the list

    const TInt numItems = iItems.Count();

    for (TInt itemIndex = 0; itemIndex < numItems; itemIndex++)

    {

        MPIMItem* listItem = iItems[itemIndex];

        // Iterate through the categories in the list item

        const CDesCArray& categories = listItem->GetCategoriesL();

        if (!aCategory)

        {

            // We are matching non-assigned items

            if (categories.Count() == 0)

            {

                User::LeaveIfError(tempArr.Append(listItem));

            }

        }

        else // aCategory is non-NULL

        {

            // We are matching items assigned to given category

            // Compare case-sensitive with accents etc.

            TInt dummyPosition = 0;

            if (0 == categories.Find(*aCategory, dummyPosition,

                                     ECmpNormal))

            {

                User::LeaveIfError(tempArr.Append(listItem));

            }

        }

    }

    TLinearOrder<MPIMItem> order(iAdapterManager->ItemOrder());

    RPointerArray<CPIMItem>* retArr = SortAndConvertToCPIMItemsL(order, tempArr);

    CleanupStack::PopAndDestroy(); // tempArr cleanup close

    return retArr;

}

const CDesCArray& CPIMList::GetCategoriesL()

{

    JELOG2(EPim);

    if (!iListAdapter)

    {

        User::Leave(KErrSessionClosed); // codescanner::leave

    }

    return iListAdapter->GetCategoriesL(); // codescanner::leave

}

jobjectArray CPIMList::getCategories(JNIEnv* aJniEnv, jintArray aError)

{

    JELOG2(EPim);

    const CDesCArray* categories = NULL;

    TInt error = KErrNone;

    TRAP(error, categories = &(GetCategoriesL()));

    SetJavaErrorCode(aJniEnv, aError, error);

    if (error != KErrNone)

    {

        return NULL;

    }

    jobjectArray javaCategories = CreateJavaStringArray(aJniEnv, *categories,

                                  EFalse); // (do not handle KPIMNullArrayElement elements specially)

    if (!javaCategories)

    {

        SetJavaErrorCode(aJniEnv, aError, KErrNoMemory);

    }

    return javaCategories;

}

TBool CPIMList::IsCategoryL(const TDesC& aCategory)

{

    JELOG2(EPim);

    TBool retVal = EFalse;

    if (!iListAdapter)

    {

        User::Leave(KErrSessionClosed);

    }

    const CDesCArray& categories = iListAdapter->GetCategoriesL();

    TInt dummyIndex = -1;

    if (0 == categories.Find(aCategory, dummyIndex, ECmpNormal))

    {

        retVal = ETrue;

    }

    return retVal;

}

jboolean CPIMList::isCategory(jstring aCategory, JNIEnv* aJniEnv,

                              jintArray aError)

{

    JELOG2(EPim);

    __ASSERT_DEBUG(aCategory, User::Panic(KPIMPanicCategory,

                                          EPIMPanicNullArgument));

    const JStringUtils nativeCategory(*aJniEnv, aCategory);

    TBool retVal = EFalse;

    TInt error = KErrNone;

    TRAP(error, retVal = IsCategoryL(*(static_cast<const TDesC*>(&nativeCategory))));

    SetJavaErrorCode(aJniEnv, aError, error);

    return static_cast<jboolean>(retVal);

}

void CPIMList::AddCategoryL(const TDesC& aCategory)

{

    JELOG2(EPim);

    if (!iListAdapter)

    {

        User::Leave(KErrSessionClosed);

    }

    iListAdapter->AddCategoryL(aCategory);

}

void CPIMList::addCategory(jstring aCategory, JNIEnv* aJniEnv,

                           jintArray aError)

{

    JELOG2(EPim);

    __ASSERT_DEBUG(aCategory, User::Panic(KPIMPanicCategory,

                                          EPIMPanicNullArgument));

    const JStringUtils category(*aJniEnv, aCategory);

    TInt error = KErrNone;

    TRAP(error, AddCategoryL(*(static_cast<const TDesC*>(&category))));

    SetJavaErrorCode(aJniEnv, aError, error);

}

RPointerArray<CPIMItem>* CPIMList::DeleteCategoryL(

    const TDesC& aCategory)

{

    JELOG2(EPim);

    if (!iListAdapter)

    {

        User::Leave(KErrSessionClosed);

    }

    // The adapter category deletion operation does not tell whether

    // the category did exist, so we'll put it down here.

    TBool categoryExists = EFalse;

    TInt dummyPosition = 0;

    if (0 == iListAdapter->GetCategoriesL().Find(aCategory,

            dummyPosition, ECmpNormal))

    {

        categoryExists = ETrue;

    }

    iListAdapter->DeleteCategoryL(aCategory);

    // NULL return value indicates that the category was not really

    // deleted (because it did not exist).

    RPointerArray<CPIMItem>* unassignedItems = NULL;

    if (categoryExists)

    {

        RPointerArray<CPIMItem> categoryMembers(KItemArrayGranularity);

        CleanupClosePushL(categoryMembers);

        const TInt n = iItems.Count();

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

        {

            TBool wasMember = iItems[i]->CategoryDeleted(aCategory);

            if (wasMember)

            {

                User::LeaveIfError(categoryMembers.Append(iItems[i]));

            }

        }

        unassignedItems = ResolveUnassignedItemsL(categoryMembers);

        CleanupStack::PopAndDestroy(); // categoryMembers cleanup close

    }

    return unassignedItems;