/*
* Copyright (c) 2005 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:   This file contains methods for aiding the process of saving
*              : landmarks which are received via messaging
*
*/







// INCLUDE FILES
#include <e32std.h>
#include <eikenv.h>
#include <StringLoader.h>
#include <AknQueryDialog.h>
#include <AknWaitDialog.h>
#include <aknnotewrappers.h>
#include <EPos_CPosLmCategoryManager.h>
#include <lmkui.rsg>
#include "CLmkParser.h"
#include "CLmkLandMarkCategoriesName.h"
#include "CLmkSaveLandmarkUtils.h"
#include "CLmkPkgFindNewCatOp.h"

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

// -----------------------------------------------------------------------------
// CLmkSaveLandmarkUtils::CLmkSaveLandmarkUtils
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CLmkSaveLandmarkUtils::CLmkSaveLandmarkUtils(
    CPosLandmarkDatabase& aDb,
    CLmkParser& aParser)
    : iDb( aDb ),
      iParser( aParser )
    {
    }

// -----------------------------------------------------------------------------
// CLmkSaveLandmarkUtils::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CLmkSaveLandmarkUtils::ConstructL()
    {
    iEnv = CEikonEnv::Static();
    }

// -----------------------------------------------------------------------------
// CLmkSaveLandmarkUtils::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CLmkSaveLandmarkUtils* CLmkSaveLandmarkUtils::NewL(
    CPosLandmarkDatabase& aDb,
    CLmkParser& aParser)
    {
    CLmkSaveLandmarkUtils* self =
        new( ELeave )CLmkSaveLandmarkUtils( aDb, aParser );

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// ----------------------------------------------------
// CLmkSaveLandmarkUtils::~CLmkSaveLandmarkUtils
// ----------------------------------------------------
//
CLmkSaveLandmarkUtils::~CLmkSaveLandmarkUtils()
    {
    CancelSearchNewCat();
    }

// ----------------------------------------------------
// CLmkSaveLandmarkUtils::~CheckForNewCategoriesL
// ----------------------------------------------------
//
TInt CLmkSaveLandmarkUtils::CheckForNewCategoriesL(RArray<TUint> & aSelectedIndices,
                                                   TDes& aNewFoundCategory,
                                                   RArray<TCategoryName>& aNewcategories)
	{
	TInt TotalCount = aSelectedIndices.Count();
	RArray<TCategoryName> categories;
	CleanupClosePushL(categories);

	for(TInt cnt = 0; cnt < TotalCount; cnt++ )
		{
		CLmkLandMarkCategoriesName* categoryNames = iParser.CategoryNameLC(aSelectedIndices[cnt]);
		categories.Reset();
		categoryNames->GetCategoryNames(categories);
		TInt totCategories = categories.Count();
		for(TInt catCount = 0; catCount < totCategories; catCount++ )
			{
			CheckCategoryInDatabaseL(aNewcategories,categories[catCount]);
			}

		CleanupStack::PopAndDestroy(); //categoryNames
		}

	TInt newCategoriesFound = aNewcategories.Count();
	if ( newCategoriesFound == 1 )
		{
		aNewFoundCategory.Copy(aNewcategories[0]);
		}
	CleanupStack::PopAndDestroy(); // categories
	return newCategoriesFound;
	}

// ----------------------------------------------------
// CLmkSaveLandmarkUtils::CheckCategoryInDatabase
// This routine check wheather category associated with landmark is already exist in database or not.
// ----------------------------------------------------
void CLmkSaveLandmarkUtils::CheckCategoryInDatabaseL(RArray<TCategoryName>& aNewcategories,const TDesC& aCategoryTobeAdded)
	{
	TInt Total = aNewcategories.Count();
	for(TInt cnt = 0; cnt < Total; cnt++ )
		{
		if (aNewcategories[cnt] == aCategoryTobeAdded)
		return;
		}

	CPosLmCategoryManager* categoryManager = CPosLmCategoryManager::NewL( iDb );
	CleanupStack::PushL( categoryManager );

	if ( categoryManager->GetCategoryL(aCategoryTobeAdded) ==  KPosLmNullItemId)
		{
		aNewcategories.Append(aCategoryTobeAdded);
		}
	CleanupStack::PopAndDestroy(); //categoryManager
	}

// ----------------------------------------------------
// CLmkSaveLandmarkUtils::CategoryAddConfirmationQueryL
// This routine ask confirmation about adding landmark , with OR without category
// ----------------------------------------------------
TInt CLmkSaveLandmarkUtils::CategoryAddConfirmationQueryL( TInt aAmount,const TDesC& aNewCategoryName )
	{
	HBufC* noteText = NULL;

	if ( aAmount > 1)
		{
		noteText = StringLoader::LoadLC( R_LMK_ADD_CATEGORIES,aAmount, iEnv );
		}
	else if ( aAmount == 1)
		{
		noteText = StringLoader::LoadLC( R_LMK_ADD_CATEGORY,aNewCategoryName, iEnv );
		}
	else
		{
		return 1;
		}

	CAknQueryDialog* query =
	new( ELeave ) CAknQueryDialog( *noteText );
	TInt ret = query->ExecuteLD( R_LMK_QUERY );	// noteText

	CleanupStack::PopAndDestroy(noteText); //noteText
	return ret;
	}

// ----------------------------------------------------
// CLmkSaveLandmarkUtils::LmsSavedConfirmationNoteL
// This method takes care of importing the selected Landmarks
// ----------------------------------------------------
void CLmkSaveLandmarkUtils::LmsSavedConfirmationNoteL(RArray<TUint> & aImportIndexes,
                                           			  TInt aEditedItemIndex)

   	{
	HBufC* noteText = NULL;

    // Display Landmark numbers in the Note
	CPosLandmark* landmark = iParser.LandmarkLC(aEditedItemIndex);
	TPtrC lmName;
	User::LeaveIfError(landmark->GetLandmarkName(lmName));
	TUint lmCount = aImportIndexes.Count();

	if (lmCount > 1)
		{
		noteText = StringLoader::LoadLC( R_LMK_NOTE_LMS_SAVED,lmCount, iEnv );
		}
	else if (lmCount == 1)
		{
		noteText = StringLoader::LoadLC( R_LMK_NOTE_LANDMARK_SAVED, lmName, iEnv );
		}
	else
		{
		return;
		}

	CAknConfirmationNote* note = new (ELeave) CAknConfirmationNote( ETrue );
	TInt retVal = note->ExecuteLD( *noteText );
	CleanupStack::PopAndDestroy(2);//  noteText
	}

// ----------------------------------------------------
// CLmkSaveLandmarkUtils::CheckForNewCategories2L
// ----------------------------------------------------
//
TInt CLmkSaveLandmarkUtils::CheckForNewCategories2L(
                                     TDes& aNewFoundCategory,
                                     RArray<TCategoryName>& aNewcategories)
	{
	TInt TotalCount = iParser.NumOfParsedLandmarks();
	RArray<TCategoryName> categories;
	CleanupClosePushL(categories);

	for(TInt cnt = 0; cnt < TotalCount; cnt++ )
		{
		CLmkLandMarkCategoriesName* categoryNames = iParser.CategoryNameLC(cnt);
		categories.Reset();
		categoryNames->GetCategoryNames(categories);
		TInt totCategories = categories.Count();
		for(TInt catCount = 0; catCount < totCategories; catCount++ )
			{
			CheckCategoryInDatabaseL(aNewcategories,categories[catCount]);
			}

		CleanupStack::PopAndDestroy(); //categoryNames
		}

	TInt newCategoriesFound = aNewcategories.Count();
	if ( newCategoriesFound == 1 )
		{
		aNewFoundCategory.Copy(aNewcategories[0]);
		}
	CleanupStack::PopAndDestroy(); // categories
	return newCategoriesFound;
	}

// ----------------------------------------------------
// CLmkSaveLandmarkUtils::StartSearchNewCatL
// ----------------------------------------------------
//
void CLmkSaveLandmarkUtils::StartSearchNewCatL(
                            TInt& aNoOfNewCategories,
                            RArray<TCategoryName>& aNewCategories,
                            TCategoryName& aNewCategoryFound)
	{
	CPosLmOperation* operation = CLmkPkgFindNewCatOp::NewL
	                                (aNoOfNewCategories,
	                                 aNewCategories,
	                                 aNewCategoryFound,
	                                 this);
    CleanupStack::PushL( operation );
	iAOOperation =
	CLmkAOOperation::NewL( operation,
	               *this,
	               ENewPkgCategory,
	               ETrue );
	CleanupStack::Pop( operation ); // ownership transferred

	iAOOperation->StartOperation();
	}
// ----------------------------------------------------
// CLmkSaveLandmarkUtils::CancelSearchNewCat
// ----------------------------------------------------
//
void CLmkSaveLandmarkUtils::CancelSearchNewCat()
	{
	if (iAOOperation)
    	{
    	delete iAOOperation;
        iAOOperation = NULL;
    	}
	}
// ----------------------------------------------------
// CLmkSaveLandmarkUtils::HandleOperationL
// ----------------------------------------------------
//
void CLmkSaveLandmarkUtils::HandleOperationL(
                                       TOperationTypes aType,
                                       TReal32 aProgress,
                                       TInt aStatus )
    {
    if ( iObserver )
        {
        iObserver->HandleOperationL(aType,aProgress,aStatus);
        }
    }
// ----------------------------------------------------
// CLmkSaveLandmarkUtils::SetObserver
// ----------------------------------------------------
//
void CLmkSaveLandmarkUtils::SetObserver(MLmkAOOperationObserver* aObserver)
    {
    iObserver = aObserver;
    }
// End of File