/*

* Copyright (c) 2010 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: Database manager implementation for location picker and

*              maptile service.

*

*/

#include <EPos_CPosLandmark.h>

#include <EPos_CPosLandmarkCategory.h>

#include <EPos_CPosLmTextCriteria.h>

#include <EPos_CPosLandmarkSearch.h>

#include <EPos_CPosLmDatabaseManager.h>

#include <lbsposition.h>

#include <mylocations.rsg>

#include <barsread.h>

#include <barsc.h>

#include "mylocationsdatabasemanager.h"

#include "mylocationlogger.h"

#include "mylocationsdefines.h"

//Custom landmark database for storing the my locations details

_LIT( KMyLocationsDatabaseUri, "file://c:MyLocationsLandmarks.ldb" );

// separator

_LIT( KSeparator, ",");

// space

_LIT( KSpace, " ");

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

// CMyLocationsDatabaseManager::ConstructL()

// 2nd phase constructor.

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

//

void CMyLocationsDatabaseManager::ConstructL()

{

    __TRACE_CALLSTACK;//Open and intialize Landmark DB

    iLandmarkDb = CPosLandmarkDatabase::OpenL();

    ExecuteAndDeleteLD(iLandmarkDb->InitializeL());

    // create landmarks lookup database.

    iLandmarksLookupDb = CLookupDatabase::NewL(KLandmarksLookupDatabaseName);

    User::LeaveIfError( iLandmarksLookupDb->Open() );

    CPosLmDatabaseManager* dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    //Create custom landmark database for storing my locations data

    if (!dbManager->DatabaseExistsL(KMyLocationsDatabaseUri))

    {

        HPosLmDatabaseInfo* dbInfo = HPosLmDatabaseInfo::NewLC(

                KMyLocationsDatabaseUri);

        dbManager->CreateDatabaseL(*dbInfo);

        CleanupStack::PopAndDestroy(dbInfo);

    }

    CleanupStack::PopAndDestroy(dbManager);

    //Open and initialize the custom landmark database

    iMyLocationsLandmarksDb = CPosLandmarkDatabase::OpenL(

                                        KMyLocationsDatabaseUri);

    if (iMyLocationsLandmarksDb->IsInitializingNeeded())

    {

        ExecuteAndDeleteLD(iMyLocationsLandmarksDb->InitializeL());

    }

    // create mylocations lookup database.

    iMylocationsLookupDb

            = CLookupDatabase::NewL(KMylocationsLookupDatabaseName);

    // Create category manager for mylocations

    iMyLocationsCatManager = CPosLmCategoryManager::NewL(

            *iMyLocationsLandmarksDb);

    // Create category manager for landmarks

    iLandmarksCatManager = CPosLmCategoryManager::NewL(*iLandmarkDb);

    //open the lookup database

    User::LeaveIfError( iMylocationsLookupDb->Open() );

    // open file session

    User::LeaveIfError(iFsSession.Connect());

    // Add contacts, calendar and history categories

    AddMylocationsCategoryL(ESourceLandmarksContactsCat);

    //close the lookup database

    iMylocationsLookupDb->Close();

}

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

// CMyLocationsDatabaseManager::CMyLocationsDatabaseManager()

// Default constructor.

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

//

CMyLocationsDatabaseManager::CMyLocationsDatabaseManager() : iLandmarkDb( NULL ),

                iMyLocationsLandmarksDb( NULL ), 

                iLmContactsCatId( 0 ), iLandmarksLookupDb( NULL ), 

                iMylocationsLookupDb( NULL ), iMyLocationsCatManager( NULL ), 

                iLandmarksCatManager( NULL )

{

}

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

// CMyLocationsDatabaseManager::_CMyLocationsDatabaseManager()

// Destructor.

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

//

CMyLocationsDatabaseManager::~CMyLocationsDatabaseManager()

{

    __TRACE_CALLSTACK;// delete member variables.

    if (iLandmarksLookupDb)

    {

        iLandmarksLookupDb->Close();

        delete iLandmarksLookupDb;

    }

    if (iMylocationsLookupDb)

    {

        iMylocationsLookupDb->Close();

        delete iMylocationsLookupDb;

    }

    delete iLandmarksCatManager;

    delete iLandmarkDb;

    delete iMyLocationsCatManager;

    delete iMyLocationsLandmarksDb;

    // close the file session

    iFsSession.Close();

}

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

// CMyLocationsDatabaseManager::AddMylocationsCategoryL()

// Adds the category to the mylocations and landmarks database..

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

//

void CMyLocationsDatabaseManager::AddMylocationsCategoryL( const TUint32 aCategoryType )

{

    __TRACE_CALLSTACK;//Open the resource file

    RResourceFile resourceFile;

    resourceFile.OpenL( iFsSession, KMyLocationsResourceFile );

    CleanupClosePushL( resourceFile );

    // Get the category name

    HBufC8* dataBuffer = NULL;

    if (aCategoryType == ESourceLandmarksContactsCat)

    {

        dataBuffer = resourceFile.AllocReadLC(R_LOCINT_LIST_CATEGORY_CONTACTS);

    }

    TResourceReader resReader;

    resReader.SetBuffer(dataBuffer);

    TPtrC resData = resReader.ReadTPtrC();

    TLookupItem lookupItem;

    lookupItem.iLmId = 0;

    lookupItem.iSource = aCategoryType;

    lookupItem.iUid = 0;

    RArray<TLookupItem> itemArray;

    CleanupClosePushL(itemArray);

    iMylocationsLookupDb->FindEntriesBySourceTypeL(lookupItem.iSource,

            itemArray);

    // Get the category from mylocations lookup table

    if (itemArray.Count() == 0)

    {

        // category not found, so create one.

        CPosLandmarkCategory *category = CPosLandmarkCategory::NewL();

        CleanupStack::PushL(category);

        category->SetCategoryNameL(resData);

        if ( aCategoryType == ESourceLandmarksContactsCat)

        {

            TPosLmItemId landmarksCatId = 0;

            // Add category to landmarks database

            TRAPD ( error, ( landmarksCatId = iLandmarksCatManager->AddCategoryL( *category ) ) );

            if (error == KErrNone || error == KErrAlreadyExists)

            {

                landmarksCatId = iLandmarksCatManager->GetCategoryL(resData);

            }

            lookupItem.iUid = landmarksCatId;

        }

        // Add the catefory to mylocations database

        TPosLmItemId myLocationsCatId = 0;

        // Add category to mylocations database

        TRAPD ( error, ( myLocationsCatId = iMyLocationsCatManager->AddCategoryL( *category ) ) );

        if (error == KErrNone || error == KErrAlreadyExists)

        {

            myLocationsCatId = iMyLocationsCatManager->GetCategoryL(resData);

        }

        // create this entry in mylocations lookup table

        lookupItem.iSource = aCategoryType;

        lookupItem.iLmId = myLocationsCatId;

        iMylocationsLookupDb->CreateEntryL(lookupItem);

        CleanupStack::PopAndDestroy(category);

    }

    else

    {

        // category found in lookup table,

        // update the corresponding category in Mylocations and landmarks database with 

        // current localized string  

        lookupItem.iLmId = itemArray[0].iLmId;

        lookupItem.iUid = itemArray[0].iUid;

        if ( aCategoryType == ESourceLandmarksContactsCat)

        {

            CPosLandmarkCategory *category =

                    iLandmarksCatManager->ReadCategoryLC(lookupItem.iUid);

            category->SetCategoryNameL(resData);

            TRAP_IGNORE ( ( iLandmarksCatManager->UpdateCategoryL( *category ) ) );

            CleanupStack::PopAndDestroy(category);

        }

        // update category in mylocations db

        CPosLandmarkCategory *category2 =

                iMyLocationsCatManager->ReadCategoryLC(lookupItem.iLmId);

        category2->SetCategoryNameL(resData);

        TRAP_IGNORE ( ( iMyLocationsCatManager->UpdateCategoryL( *category2 ) ) );

        CleanupStack::PopAndDestroy(category2);

    }

    CleanupStack::PopAndDestroy(&itemArray);

    if ( dataBuffer )

    {

        CleanupStack::PopAndDestroy(dataBuffer);

    }

    if (aCategoryType == ESourceLandmarksContactsCat)

        iLmContactsCatId = lookupItem.iUid;

    // Close the resource file

    CleanupStack::PopAndDestroy( &resourceFile );

}

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

// CMyLocationsDatabaseManager::UpdateDatabaseL()

// Updates the location into the landmark database and lookup table. Based on 

// the entry source type and the entry change type the updation can be 

// addition/modification/deletion.

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

//

void CMyLocationsDatabaseManager::UpdateDatabaseL(CPosLandmark* aLandmark,

        const TUint32 aUid, const TUint32 aSourceType, const TEntryChangeType aChangeType)

{

    __TRACE_CALLSTACK;//open the lookup database

    User::LeaveIfError(iMylocationsLookupDb->Open());

    switch (aChangeType)

    {

    // if the entry is added

    case EEntryAdded:

    {

        // Handle this entry in the lookup table and update landmarks db.

        HandleEntryAdditionL(aLandmark, aUid, aSourceType);

        break;

    }

        // if the entry is modified

    case EEntryModified:

    {

        // Handle this entry in the lookup table and update landmarks db.

        HandleEntryModificationL(aLandmark, aUid, aSourceType);

        break;

    }

        // if the entry is deleted

    case EEntryDeleted:

    {

        // Handle this entry in the lookup table and update landmarks db.

        HandleEntryDeletionL(aUid, aSourceType);

        break;

    }

    }

    //close the lookup database

    iMylocationsLookupDb->Close();

}

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

// CMyLocationsDatabaseManager::CheckIfDuplicateExistsL()

// Checks if this landmark is already present in database. If present returns the landmark id, else 0

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

//

TPosLmItemId CMyLocationsDatabaseManager::CheckIfDuplicateExistsL(

                                    const CPosLandmark* aLandmark)

{

    __TRACE_CALLSTACK;// Stores the found duplicate landmark's id. 

    TPosLmItemId retId = 0;

    // Initially filter only the landmarks which are nearer to the current landmark.

    // Then we can make a duplicate check on each of the found landmarks.

    // create a search object.

    CPosLandmarkSearch* search = CPosLandmarkSearch::NewL(

            *iMyLocationsLandmarksDb);

    CleanupStack::PushL(search);

    TBuf<KMaxAddressLength> lmAddress;

    GetLandmarkFullAddress(lmAddress, aLandmark);

    // Create the search criterion

    CPosLmTextCriteria* crit = CPosLmTextCriteria::NewLC();

    crit->SetTextL(lmAddress);

    crit->SetAttributesToSearch(CPosLandmark::ELandmarkName);

    // Start the search and execute it at once.

    ExecuteAndDeleteLD(search->StartLandmarkSearchL(*crit));

    CleanupStack::PopAndDestroy(crit);

    // Retrieve an iterator to access the matching landmarks.

    CPosLmItemIterator* iter = search->MatchIteratorL();

    CleanupStack::PushL(iter);

    // Iterate the search matches.

    TPosLmItemId lmId;

    while ((lmId = iter->NextL()) != KPosLmNullItemId)

    {

        //Found duplicate entries.

        // Get the corresponding id in landmarks db

        RArray<TLookupItem> itemArray;

        CleanupClosePushL(itemArray);

        iMylocationsLookupDb->FindEntriesByLandmarkIdL(lmId, itemArray);

        if (itemArray.Count())

        {

            if (itemArray[0].iSource == ESourceLandmarks)

            {

                // return id only if the source is from landmarks database.

                retId = itemArray[0].iUid;

                CleanupStack::PopAndDestroy(&itemArray);

                break;

            }

        }

        CleanupStack::PopAndDestroy(&itemArray);

    }

    CleanupStack::PopAndDestroy(iter);

    CleanupStack::PopAndDestroy(search);

    return retId;

}

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

// CMyLocationsDatabaseManager::CompareLandmarks()

// Compares two landmarks. Only the text fields, landmark name, street, city, state country and 

// postal code are compared.

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

//

TBool CMyLocationsDatabaseManager::CompareLandmarks(

        const CPosLandmark* aLandmark1, const CPosLandmark* aLandmark2)

{

    __TRACE_CALLSTACK;// Compare landmark names

    TPtrC name1, name2;

    aLandmark1->GetLandmarkName(name1);

    aLandmark2->GetLandmarkName(name2);

    if (name1 != name2)

    {

        return EFalse;

    }

    // Compare street info

    TPtrC street1, street2;

    aLandmark1->GetPositionField(EPositionFieldStreet, street1);

    aLandmark2->GetPositionField(EPositionFieldStreet, street2);

    if (street1 != street2)

    {

        return EFalse;

    }

    // Compare City info

    TPtrC city1, city2;

    aLandmark1->GetPositionField(EPositionFieldCity, city1);

    aLandmark2->GetPositionField(EPositionFieldCity, city2);

    if (city1 != city2)

    {

        return EFalse;

    }

    // compare state info

    TPtrC state1, state2;

    aLandmark1->GetPositionField(EPositionFieldState, state1);

    aLandmark2->GetPositionField(EPositionFieldState, state2);

    if (state1 != state2)

    {

        return EFalse;

    }

    // compare postal code

    TPtrC postalCode1, postalCode2;

    aLandmark1->GetPositionField(EPositionFieldPostalCode, postalCode1);

    aLandmark2->GetPositionField(EPositionFieldPostalCode, postalCode2);

    if (postalCode1 != postalCode2)

    {

        return EFalse;

    }

    // compare country name

    TPtrC country1, country2;

    aLandmark1->GetPositionField(EPositionFieldCountry, country1);

    aLandmark2->GetPositionField(EPositionFieldCountry, country2);

    if (country1 != country2)

    {

        return EFalse;

    }

    return ETrue;

}

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

// CMyLocationsDatabaseManager::HandleEntryAdditionL()

// Handles the entry addition in lookup table and landmarks db

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

//

void CMyLocationsDatabaseManager::HandleEntryAdditionL(CPosLandmark* aLandmark,

        const TUint32 aUid, const TUint32 aSourceType)

{

    __TRACE_CALLSTACK;

    if ( aSourceType == ESourceLandmarks )

    {

        AddToMylocationsDbL(aLandmark, aUid, aSourceType);

        return;

    }

    if ( aSourceType == ESourceLandmarksCategory )

    {

        CreateCategoryL(aUid);

        return;

    }

    // Create a lookup item

    TLookupItem lookupItem;

    lookupItem.iUid = aUid;

    lookupItem.iSource = aSourceType;

    // check if this landmark is already present in database

    TPosLmItemId dupLmId = CheckIfDuplicateExistsL(aLandmark);

    if (dupLmId)

    {

        // landmark already present in db. get the details

        CPosLandmark* dupLandmark = iLandmarkDb->ReadLandmarkLC(dupLmId);

        if (dupLandmark)

        {

            if (aSourceType == ESourceContactsPref || aSourceType

                    == ESourceContactsWork || aSourceType

                    == ESourceContactsHome)

            {

                dupLandmark->AddCategoryL(iLmContactsCatId);

            }

            // update the landmark object in the db

            iLandmarkDb->UpdateLandmarkL(*dupLandmark);

            CleanupStack::PopAndDestroy(dupLandmark);

        }

        // point the lookup item's landmark uid to the existing landmark.

        lookupItem.iLmId = dupLmId;

    }

    else // it is a new entry, so add into the database

    {

        if (aSourceType == ESourceContactsPref || aSourceType

                == ESourceContactsWork || aSourceType == ESourceContactsHome)

        {

            aLandmark->AddCategoryL(iLmContactsCatId);

        }

        // add the landmark into the db. 

        // point the lookup item's landmark uid to the newly created landmark in the db.

        lookupItem.iLmId = iLandmarkDb->AddLandmarkL(*aLandmark);

    }

    // create the entry in the lookup table.

    iLandmarksLookupDb->CreateEntryL(lookupItem);

}

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

// CMyLocationsDatabaseManager::HandleEntryModificationL()

// Handles the entry modification in the lookup table and landmarks db.

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

//

void CMyLocationsDatabaseManager::HandleEntryModificationL(

        CPosLandmark* aLandmark, const TUint32 aUid, const TUint32 aSourceType)

{

    __TRACE_CALLSTACK;

    if ( aSourceType == ESourceLandmarks )

    {

        ModifyMylocationsDbL( aLandmark, aUid, aSourceType );

        return;

    }

    TLookupItem lookupItem;

    lookupItem.iUid = aUid;

    lookupItem.iSource = aSourceType;

    if (aSourceType == ESourceContactsPref || aSourceType

            == ESourceContactsWork || aSourceType == ESourceContactsHome)

    {

        // Behavior: If a contact is modified, 

        // If this entry is not present in lookup table. add the entry and update the landmarks db.

        // If this entry is already present in lookup table, check if the location info is modified or not.

        // If the location info is modified, delete the landmark from db and add the new landmark

        // into the db. 

        // Before deletion make sure that the landmark is not being refered by other lookup entries.

        // find the entry in the lookup table.

        if (iLandmarksLookupDb->FindEntryL(lookupItem))

        {

            // check if the location info is modified by comparing the new landmark with the existing landmark

            CPosLandmark* existingLandmark = NULL;

            TRAPD( error, ( existingLandmark = 

                   CheckAndReadLandmarkL( iLandmarkDb, lookupItem.iLmId ) ) );

            CleanupStack::PushL(existingLandmark);

            if (error == KErrNotFound)

            {

                // Landmarks item deleted. So delete corresponding lookup entries.

                RArray<TLookupItem> itemArray;

                CleanupClosePushL(itemArray);