/*

* Copyright (c) 2007 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:  ESMR Location plugin handler implementation

*

*/

#include "emailtrace.h"

#include "cesmrlocationpluginhandler.h"

#include <calentry.h>

#include <StringLoader.h>

#include <AknQueryDialog.h>

#include <esmrgui.rsg>

//<cmail>

#include "cesmrurlparserplugin.h"

//</cmail>

#include <CLmkLandmarkSelectorDlg.h>

#include <TLmkItemIdDbCombiInfo.h>

#include <EPos_CPosLandmark.h>

#include <AknUtils.h>

#include <ct/rcpointerarray.h>

#include "cesmrlocationplugin.h"

#include "esmrcommands.h"

#include "mesmrcalentry.h"

#include "cesmrdynamicitemselectionlist.h"

#include "cesmrlocationhistorymanager.h"

#include "mesmrlocationhistoryitem.h"

#include "cesmrconfirmationquery.h"

// Unnamed namespace for local definitions

namespace { //codescanner::namespace

_LIT(KSpace, " ");

// Maximum length of the text in location field

const TInt KMaxLocationTextLength = 255;

}

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

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

// CESMRLocationPluginHandler::CESMRLocationPluginHandler

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

//

CESMRLocationPluginHandler::CESMRLocationPluginHandler( MObjectProvider& aParent )

: iParent(&aParent)

	{

    FUNC_LOG;

	}

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

// CESMRLocationPluginHandler::~CESMRLocationPluginHandler

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

//

CESMRLocationPluginHandler::~CESMRLocationPluginHandler()

	{

    FUNC_LOG;

    delete iWait;

    delete iLocationPlugin;

    delete iLandmark;

    delete iUrlParser;

	delete iLocationHistoryManager;

	}

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

// CESMRLocationPluginHandler::NewL

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

//

CESMRLocationPluginHandler* CESMRLocationPluginHandler::NewL( 

        MObjectProvider& aParent )

	{

    FUNC_LOG;

	CESMRLocationPluginHandler* self = 

		new (ELeave) CESMRLocationPluginHandler( aParent );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

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

// CESMRLocationPluginHandler::ConstructL

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

//

void CESMRLocationPluginHandler::ConstructL()

	{

    FUNC_LOG;

	iWait = new( ELeave ) CActiveSchedulerWait;

	}

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

// CESMRLocationPluginHandler::HandleCommandL

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

//

TBool CESMRLocationPluginHandler::HandleCommandL( TInt aCommand,

												 MESMRCalEntry& aEntry,

												 TBool aIgnoreQuery )

	{

    FUNC_LOG;

	iIgnoreQuery = aIgnoreQuery;

	iEntryUpdated = EFalse;

	switch ( aCommand )

		{

		case EESMRCmdAssignFromMap:

			{

			if( !(iWait->IsStarted()) )

			    {

			    const TDesC& location = aEntry.Entry().LocationL();

			    // Extract location URL from description

			    TPtrC locationUrl;

			    UrlParserL().FindLocationUrl( aEntry.Entry().DescriptionL(),

			                                  locationUrl );

			    // Launch Maps

			    LocationPluginL().SelectFromMapL( location, locationUrl );

			    iWait->Start(); // codescanner::callActiveObjectWithoutCheckingOrStopping

			    // iLandmark is set in async callback SelectFromMapCompleted

			    // from Maps application.

			    if ( iLandmark )

			        {

			        UpdateEntryFromLandmarkL( aEntry, *iLandmark );

			        delete iLandmark;

			        iLandmark = NULL;

			        }

			    }

			}

			break;

        case EESMRCmdUpdateFromMap:

            {

            if ( !(iWait->IsStarted()) )

                {

                // Launch Maps and ignore existing coordinates, 

                // because location has been updated

                LocationPluginL().SelectFromMapL( aEntry.Entry().LocationL(), 

                                                  KNullDesC );

                iWait->Start(); // codescanner::callActiveObjectWithoutCheckingOrStopping

                // iLandmark is set in async callback SelectFromMapCompleted

                // from Maps application.

                if ( iLandmark )

                    {

                    UpdateEntryFromLandmarkL( aEntry, *iLandmark );

                    delete iLandmark;

                    iLandmark = NULL;

                    }                

                }

            break;

            }

		case EESMRCmdSearchFromMap:

		    {

		    const TDesC& location = aEntry.Entry().LocationL();

		    LocationPluginL().SearchFromMapL( location );

		    }		    

		    break;

		case EESMRCmdShowOnMap:

		    {

		    const TDesC& description = aEntry.Entry().DescriptionL();

		    TPtrC locationUrl;

		    TInt position = iUrlParser->FindLocationUrl( description,

		                                                 locationUrl );

		    if ( position >= 0 )

		        {

		        }

		    break;

		    }

		case EESMRCmdLandmarks:

		    {

            SearchFromLandmarksL( iParent, aEntry );

		    break;

		    }

		case EESMRCmdPreviousLocations:

		    {

		    ShowSelectPreviousLocationQueryL( aEntry );

		    break;

		    }

		default:

			User::Leave( KErrGeneral );

		}

	return iEntryUpdated;

	}

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

// CESMRLocationPluginHandler::IsCommandAvailableL

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

//

TBool

CESMRLocationPluginHandler::IsCommandAvailableL( TInt aCommand,

                                                 const MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    TBool res( EFalse );

    switch ( aCommand )

        {

        case EESMRCmdAssignFromMap: //fallthrough

        case EESMRCmdUpdateFromMap:

        case EESMRCmdSearchFromMap:

        case EESMRCmdLandmarks:

            {

            res = ETrue;

            break;

            }

        case EESMRCmdPreviousLocations:

            {

            if ( LocationHistoryManagerL().ItemCount() > 0 )

                {

                res = ETrue;

                }

            break;

            }

        case EESMRCmdShowOnMap:

            {

            const TDesC& description = aEntry.Entry().DescriptionL();

            TPtrC locationUrl;

            TInt position = UrlParserL().FindLocationUrl( description,

                                                          locationUrl );

            if ( position >= 0 )

                {

                res = ETrue;

                }

            break;

            }

        default:

            {

            break;

            }

        }

    return res;

    }

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

// CESMRLocationPluginHandler::StoreLocationToHistoryL

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

//

void CESMRLocationPluginHandler::StoreLocationToHistoryL(

        const MESMRCalEntry& aEntry  )

    {

    FUNC_LOG;

    const CCalEntry& entry = aEntry.Entry();

    const TDesC& entryLocation = entry.LocationL();

    // Store location only if location field contains text.

    if ( entryLocation.Length() > 0 )

        {

        const TDesC& entryDescription = entry.DescriptionL();

        // Search for location url from description.

        TPtrC locationUrl;

        TInt position = UrlParserL().FindLocationUrl( entryDescription,

                                                      locationUrl );

        // If url was not found.

        if ( position < 0 )

            {

            locationUrl.Set( KNullDesC );

            }

        // Check if history item with same location and url

        // is already stored.

        TInt existingHistoryItemIndex = KErrNotFound;

        TInt itemCount = LocationHistoryManagerL().ItemCount();

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

            {

            const MESMRLocationHistoryItem& item =

                iLocationHistoryManager->LocationHistoryItemL( i );

            if ( item.Address().Compare( entryLocation ) == 0 &&

                 item.Url().Compare( locationUrl ) == 0 )

                {

                existingHistoryItemIndex = i;

                break;

                }

            }

        // If history item with same location and url existed

        // update it's position in history array only.

        if ( existingHistoryItemIndex >= 0 )

            {

            // Ownership is not transferred,

            // existing item is already owned by location manager.

            const MESMRLocationHistoryItem& item =

                iLocationHistoryManager->LocationHistoryItemL( existingHistoryItemIndex );

            iLocationHistoryManager->UpdateLocationHistoryL( &item );

            }

        else

            {

            // Create new history item.

            MESMRLocationHistoryItem* historyItem =

                iLocationHistoryManager->CreateLocationHistoryItemL(

                            entryLocation,

                            locationUrl );

            // Store new item to history.

            CleanupDeletePushL( historyItem );

            iLocationHistoryManager->UpdateLocationHistoryL( historyItem );

            CleanupStack::Pop( historyItem );

            }

        }

    }

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

// CESMRLocationPluginHandler::UpdateEntryLocationL

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

//

TBool CESMRLocationPluginHandler::UpdateEntryLocationL( MESMRCalEntry& aEntry,

                                                        const TDesC& aLocation,

                                                        TBool aIgnoreQuery )

    {

    FUNC_LOG;

    TBool entryUpdated = EFalse;

    if ( aLocation.Length() > 0 )

        {

        CCalEntry& entry = aEntry.Entry();

        const TDesC& location = entry.LocationL();

        // Replace old location field content.

        TBool replace = ETrue;

        if ( !aIgnoreQuery

             && location.Length() > 0

             && location != aLocation )

            {

            // Query for replacing old location field content 

            replace = CESMRConfirmationQuery::ExecuteL( location ); 

            }

        // If previous location was empty or user selects to

        // replace previous location with new one.

        if (  location.Length() == 0 || replace )

            {

            entry.SetLocationL( aLocation.Left( KMaxLocationTextLength ) );

            entryUpdated = ETrue;                

            }

        else

            {

            // Concatenate new address to existing one

            // Create CPtrCArray for existing and new location strings

            CPtrCArray* strings = new( ELeave ) CPtrCArray( 2 );

            CleanupStack::PushL( strings );

            strings->AppendL( TPtrC( location ) );

            strings->AppendL( TPtrC( aLocation ) );

            HBufC* newLocation =

                StringLoader::LoadLC( R_MEET_REQ_NEW_LOCATION_FORMAT,

                                      *strings );

            entry.SetLocationL( newLocation->Left( KMaxLocationTextLength ) );

            entryUpdated = ETrue;

            CleanupStack::PopAndDestroy( 2, strings );

            }

        }

    return entryUpdated;

    }

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

// From MESMRLocationPluginObserver

// CESMRLocationPluginHandler::SelectFromMapCompleted

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

//

void CESMRLocationPluginHandler::SelectFromMapCompleted( TInt aError,

                                                         CPosLandmark* aLandmark )

	{

    FUNC_LOG;

	// Remove previous landmark if one is set.

    if ( iLandmark )

        {

        delete iLandmark;

        iLandmark = NULL;

        }

	if ( aError == KErrNone )

		{

		// pointer to the result of landmark fetch

		iLandmark = aLandmark;

		}

	if ( iWait->IsStarted() )

		{

		iWait->AsyncStop();

		}

	}

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

// CESMRLocationPluginHandler::LocationPluginL

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

//

CESMRLocationPlugin& CESMRLocationPluginHandler::LocationPluginL()

	{

    FUNC_LOG;

	if ( !iLocationPlugin )

		{

		// Lazy construction of Location ECom plugin

		iLocationPlugin = CESMRLocationPlugin::NewL();

		iLocationPlugin->SetObserver(this);

		}

	return *iLocationPlugin;

	}

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

// Creates adress descriptor from a  landmark object

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

//

HBufC* CESMRLocationPluginHandler::CreateAddressFromLandmarkL( 

                                               const CPosLandmark& aLandmark )

    {

    FUNC_LOG;

    CPtrCArray* addressStrings = new( ELeave ) CPtrCArray( 2 );

    CleanupStack::PushL( addressStrings );

    TBool streetAvailable = aLandmark.IsPositionFieldAvailable( EPositionFieldStreet );

    TBool cityAvailable = aLandmark.IsPositionFieldAvailable( EPositionFieldCity );

    if ( streetAvailable )

        {

        TPtrC streetPtr( KNullDesC );

        User::LeaveIfError( aLandmark.GetPositionField( EPositionFieldStreet,

                                                         streetPtr ) );

        if ( streetPtr.Length() > 0 )

            {

            addressStrings->AppendL( streetPtr );

            }

        }

    if ( cityAvailable )

        {

        TPtrC cityPtr( KNullDesC );

        User::LeaveIfError( aLandmark.GetPositionField( EPositionFieldCity,

                                                         cityPtr ) );

        if ( cityPtr.Length() > 0 )

            {

            addressStrings->AppendL( cityPtr );

            }

        }

    HBufC* address(NULL);

    if ( addressStrings->Count() == 2 )

        {

        //format street and city to buffer

        address = StringLoader::LoadL( R_MEET_REQ_ADDRESS_STREET_CITY, 

                                       *addressStrings );

        }

    else if ( addressStrings->Count() == 1 )

        {

        // alloc street or city to buffer

        address = addressStrings->At( 0 ).AllocL();

        }

    else if ( addressStrings->Count() == 0 )

        {

        TPtrC namePtr( KNullDesC );

        User::LeaveIfError( aLandmark.GetLandmarkName( namePtr ));

        if ( namePtr.Length() > 0)

            {

            address = namePtr.AllocL();

            }

        }

    CleanupStack::PopAndDestroy( addressStrings );                       

    //Transfer ownership of address

    return address;

    }

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

// CESMRLocationPluginHandler::UpdateEntryFromLandmarkL

// Updates location information into calendar entry from aLandmark.

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

//

void CESMRLocationPluginHandler::UpdateEntryFromLandmarkL( MESMRCalEntry& aEntry, const CPosLandmark& aLandmark )

	{

    FUNC_LOG;

    //parse and add address to calendar entry

    HBufC* streetAddress = CreateAddressFromLandmarkL( aLandmark );

    if ( streetAddress )

        {

        CleanupDeletePushL( streetAddress );

        UpdateEntryLocationL( aEntry, *streetAddress );

        CleanupStack::PopAndDestroy( streetAddress );

        }

    //parse and add location url to calendar entry

    HBufC* locationUrl = NULL;

    TRAP_IGNORE( locationUrl = UrlParserL().CreateUrlFromLandmarkL( aLandmark ) )

    if ( locationUrl )

        {

        CleanupDeletePushL( locationUrl );

        UpdateEntryDescriptionL( aEntry, *locationUrl );

        CleanupStack::PopAndDestroy( locationUrl );

        }

	}

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

// CESMRLocationPluginHandler::SearchFromLandmarksL

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

//

void CESMRLocationPluginHandler::SearchFromLandmarksL( MObjectProvider* aParent, MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    CLmkLandmarkSelectorDlg* landmarkDlg = CLmkLandmarkSelectorDlg::NewL();

    CleanupStack::PushL( landmarkDlg );

    landmarkDlg->SetMopParent( aParent );

    TLmkItemIdDbCombiInfo selectedItem;

    // Execute landmark selection dialog

    TInt isAccepted = landmarkDlg->ExecuteLD( selectedItem );