/*
* 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:  Location API category manager
 *
*/


// INTERNAL INCLUDES
#include    "clapicategorymanager.h"
#include    "mlapilandmarkstore.h"
#include    "mlapilmdatabaseeventnotifier.h"
#include    "logger.h"
// EXTERNAL INCLUDES
#include    <EPos_CPosLmCategoryManager.h>
#include    <EPos_CPosLandmarkDatabase.h>

// UNNAMED LOCAL NAMESPACE
namespace
{
// Minimum usage of the native landmark database. If the usage drops
// below this level, the database will be compacted to avoid that the
// Landmark Server would do that which eventually locks the database
const TReal KLAPIMinCompactUsage = 0.7;
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::NewL
// ---------------------------------------------------------------------------
//
CLAPICategoryManager* CLAPICategoryManager::NewL(const TCtorParams& aParams)
{
    JELOG2(EJavaLocation);
    CLAPICategoryManager* self = CLAPICategoryManager::NewLC(aParams);
    CleanupStack::Pop(self);
    return self;
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::NewLC
// ---------------------------------------------------------------------------
//
CLAPICategoryManager* CLAPICategoryManager::NewLC(const TCtorParams& aParams)
{
    JELOG2(EJavaLocation);
    CLAPICategoryManager* self = new(ELeave) CLAPICategoryManager(aParams);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::~CLAPICategoryManager
// ---------------------------------------------------------------------------
//
CLAPICategoryManager::~CLAPICategoryManager()
{
    JELOG2(EJavaLocation);
    if (iEventNotifier)
    {
        iEventNotifier->RemoveObserver(this);
    }
    iCategoryIds.Close();
    delete iCategoryNames;
    delete iCategoryManager;
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::ListCategoriesL
// ---------------------------------------------------------------------------
//
const CDesCArray& CLAPICategoryManager::ListCategoriesL()
{
    JELOG2(EJavaLocation);
    // Check if Event listening is supported so it is not necessary to
    // refresh the whole list of categories in the database. Note that
    // if the amount of categories is huge, this operation may take some
    // time so it is always better to track database events if possible
    if (!iEventNotifier || !iEventNotifier->IsEventListeningSupported())
    {
        RefreshCategoryListL();
    }
    // Return a reference to the current list of categories
    return *iCategoryNames;
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::AddCategoryL
// ---------------------------------------------------------------------------
//
void CLAPICategoryManager::AddCategoryL(const TDesC& aName)
{
    JELOG2(EJavaLocation);
    CPosLandmarkCategory* category = CPosLandmarkCategory::NewLC();
    // The native Landmarks API supports only specific length category names
    // There is no other option but to truncat the rest of the name off
    TPtrC name = aName.Left(KPosLmMaxCategoryNameLength);
    category->SetCategoryNameL(name);
    // Manager does not take the ownership
    TPosLmItemId id = iCategoryManager->AddCategoryL(*category);
    CleanupStack::PopAndDestroy(category);
    // Store the information about the category if it was successfully added
    if (id != KPosLmNullItemId)
    {
        // Store the new id and category name
        TInt position = iCategoryNames->InsertIsqL(name, ECmpCollated);
        // Insert the element to the same place in the id array
        TInt error = iCategoryIds.Insert(id, position);
        if (error != KErrNone)
        {
            // The arrays must be in sync so remove the added id
            iCategoryNames->Delete(position);
            User::Leave(error);
        }
    }
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::RemoveCategoryL
// ---------------------------------------------------------------------------
//
void CLAPICategoryManager::RemoveCategoryL(const TDesC& aName)
{
    JELOG2(EJavaLocation);
    // Remove the category if it exists. If not, this function call is
    // silently discareded as specified in the Location API specification
    TInt index = FindCategory(aName);
    if (index != KErrNotFound)
    {
        ExecuteAndDeleteLD(iCategoryManager->RemoveCategoryL(
                               iCategoryIds[index]));
        // Remove the category from the list
        iCategoryIds.Remove(index);
        iCategoryNames->Delete(index);
    }
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::AddLandmarkToCategoryL
// ---------------------------------------------------------------------------
//
void CLAPICategoryManager::AddLandmarkToCategoryL(MLAPILandmark& aLandmark,
        const TDesC& aCategoryName)
{
    JELOG2(EJavaLocation);
    TInt index = FindCategory(aCategoryName);
    // Leave if the requested category was not found
    __ASSERT_ALWAYS(index != KErrNotFound, User::Leave(KErrArgument));
    TLAPIItemId categoryId = iCategoryIds[index];

    // Load the landmark information from the database and update categories
    CPosLandmark* landmark = iLandmarkDatabase.ReadLandmarkLC(aLandmark.Id());
    landmark->AddCategoryL(categoryId);

    // Currently, the passed landmark does not have to know to which categories
    // it belongs to so there is no need to update the information in the
    // landmark. This will change in Location API v2.0

    // Update the existing landmark into the database.
    iLandmarkDatabase.UpdateLandmarkL(*landmark);
    CleanupStack::PopAndDestroy(landmark);
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::RemoveLandmarkFromCategoryL
// ---------------------------------------------------------------------------
//
void CLAPICategoryManager::RemoveLandmarkFromCategoryL(
    MLAPILandmark& aLandmark, const TDesC& aCategoryName)
{
    JELOG2(EJavaLocation);
    TInt index = FindCategory(aCategoryName);
    // The function call is silently discarded if the specified category
    // does not exist in the landmark store
    if (index != KErrNotFound)
    {
        TLAPIItemId categoryId = iCategoryIds[index];
        // Load the landmark information from the database and update categories
        CPosLandmark* lm = iLandmarkDatabase.ReadLandmarkLC(aLandmark.Id());
        lm->RemoveCategory(categoryId);
        // Update the existing landmark into the database.
        iLandmarkDatabase.UpdateLandmarkL(*lm);
        CleanupStack::PopAndDestroy(lm);

        // Currently, the passed landmark does not have to know to which
        // categories it belongs to so there is no need to update the information
        // in the landmark. This will change in Location API v2.0
    }
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::NotifyEvent
// ---------------------------------------------------------------------------
//
void CLAPICategoryManager::NotifyEvent(TPosLmEventType& aEventType,
                                       TPosLmItemId& aItemId)
{
    JELOG2(EJavaLocation);
    // Handle the change. The error must be ignored because there is no way
    // to recover from out of memory situation
    TRAP_IGNORE(HandleCategoryChangeL(aEventType, aItemId));
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::ConstructL
// ---------------------------------------------------------------------------
//
void CLAPICategoryManager::ConstructL()
{
    JELOG2(EJavaLocation);
    iCategoryManager = CPosLmCategoryManager::NewL(iLandmarkDatabase);
    iCategoryNames = new(ELeave) CDesCArrayFlat(5);
    // Refresh the category list for the first time here. Note that this
    // is called only here if the event notifier supports listening changes
    RefreshCategoryListL();
    // Start listening category changes if it is supported by the event notifier
    if (iEventNotifier && iEventNotifier->IsEventListeningSupported())
    {
        iEventNotifier->AddObserverL(this);
    }
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::CLAPICategoryManager
// ---------------------------------------------------------------------------
//
CLAPICategoryManager::CLAPICategoryManager(const TCtorParams& aParams) :
        iLandmarkDatabase(*(aParams.iLandmarkDatabase)), iEventNotifier(
            aParams.iEventNotifier)
{
    JELOG2(EJavaLocation);
    iLandmarkDatabasePtr = aParams.iLandmarkDatabase;
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::RefreshCategoryListL
// ---------------------------------------------------------------------------
//
void CLAPICategoryManager::RefreshCategoryListL()
{
    JELOG2(EJavaLocation);
    // Reset any existing category information
    iCategoryIds.Reset();
    iCategoryNames->Reset();
    // Initialize the list of current categories. The order is handled internally
    CPosLmItemIterator* iterator = iCategoryManager->CategoryIteratorL();
    CleanupStack::PushL(iterator);
    // Do not iterate categories if there is nothing to iterate
    if (iterator->NumOfItemsL() == 0)
    {
        CleanupStack::PopAndDestroy(iterator);
        return;
    }
    RArray<TPosLmItemId> ids;
    CleanupClosePushL(ids);
    // Get the prepared category identifiers from the iterator
    iterator->GetItemIdsL(ids, 0, iterator->NumOfItemsL());

    // Read all available categories
    TInt itemCount = ids.Count();
    for (TInt i = 0; i < itemCount; i++)
    {
        TPosLmItemId id = ids[i];
        // Read category information from the category manager
        DoReadCategoryL(id);
    }
    CleanupStack::PopAndDestroy(2, iterator); // The id array is the second
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::DoReadCategoryL
// ---------------------------------------------------------------------------
//
void CLAPICategoryManager::DoReadCategoryL(TPosLmItemId& aItemId)
{
    JELOG2(EJavaLocation);
    // Read category information from the category manager
    CPosLandmarkCategory* cat = iCategoryManager->ReadCategoryLC(aItemId);
    // Get the information from the category
    TPtrC namePtr;
    User::LeaveIfError(cat->GetCategoryName(namePtr));
    // Add the category to the name array and update the id array also
    TInt position = iCategoryNames->InsertIsqL(namePtr, ECmpCollated);
    // Insert new id or append if the array
    TInt error = iCategoryIds.Insert(aItemId, position);
    if (error != KErrNone)
    {
        // The arrays must be in sync so remove the added id
        iCategoryNames->Delete(position);
        User::Leave(error);
    }
    CleanupStack::PopAndDestroy(cat);
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::FindCategory
// ---------------------------------------------------------------------------
//
TInt CLAPICategoryManager::FindCategory(const TDesC& aName) const
{
    JELOG2(EJavaLocation);
    TInt pos = 0;
    TInt found = iCategoryNames->FindIsq(aName, pos, ECmpCollated);
    // Return the index of the category name. KErrNotFound if the category
    // was not found from the category names list
    return found == 0 ? pos : KErrNotFound;
}

void CLAPICategoryManager::CompactIfNeededL()
{
    JELOG2(EJavaLocation);

    LOG(EJavaLocation, EInfo, "CLAPICategoryManager::CompactIfNeededL ");

    // Check if the database has been closed
    __ASSERT_ALWAYS(iLandmarkDatabasePtr, User::Leave(KErrSessionClosed));

    CPosLandmarkDatabase::TSize databaseSize = iLandmarkDatabasePtr->SizeL();

    // the minimum compact limit. This prevents that Landmarks Server will
    // not do this operation and lock the database
    if (databaseSize.iUsage < KLAPIMinCompactUsage)
    {
        ExecuteAndDeleteLD(iLandmarkDatabasePtr->CompactL());
    }
}

// ---------------------------------------------------------------------------
// CLAPICategoryManager::HandleCategoryChangeL
// ---------------------------------------------------------------------------
//
void CLAPICategoryManager::HandleCategoryChangeL(TPosLmEventType& aEventType,
        TPosLmItemId& aItemId)
{
    JELOG2(EJavaLocation);
    LOG1(EJavaLocation, EInfo,
         "CLAPICategoryManager::HandleCategoryChangeL - event %d",
         aEventType);
    // Check the type of the event and perform the correct operation
    switch (aEventType)
    {
    case EPosLmEventCategoryUnknownChanges:
    {
        // Unknown changes. This may occur when multiple categories are
        // deleted at once. The whole list needs to be refreshed
        RefreshCategoryListL();
        break;
    }
    case EPosLmEventCategoryCreated: // Fallthrough
    case EPosLmEventCategoryUpdated: // Fallthrough
    case EPosLmEventCategoryDeleted:
    {
        // Update and delete events require deleting the existing category
        if (aEventType != EPosLmEventCategoryCreated)
        {
            TInt index = iCategoryIds.Find(aItemId);
            if (index != KErrNotFound)
            {
                iCategoryIds.Remove(index);
                iCategoryNames->Delete(index);
            }
        }

        // Read the newly added category from the database and add it to the
        // category name and identifier list. Delete event will not add new
        if (aEventType != EPosLmEventCategoryDeleted)
        {
            DoReadCategoryL(aItemId);
        }

        if (aEventType == EPosLmEventCategoryDeleted)
        {
            // Compact the store if needed
            CompactIfNeededL();
        }
        break;
    }
    default:
    {
        // Other events are simply ignored
        break;
    }
    }
}

// End of file