/*
* Copyright (c) 2008-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:  Parser class extension for parsing landmarks to url and vice versa
*
*/



#include "cmrurlparserextension.h"

#include <EPos_CPosLandmark.h>
#include <lbsposition.h>
#include <utf.h>
#include <finditemengine.h>
#include <calentry.h>

#include "emailtrace.h"

namespace
{
// Old location base URL format
_LIT( KLocationUrl, "http://www.ovi.com/maps/" );

// Latitude parameter
_LIT( KUrlParamLatitude, "lat=" );

// Parameter separator
_LIT( KUrlParamSeparator, "&" );

// Longitude parameter
_LIT( KUrlParamLongitude, "lon=" );

// Location sieve URL
_LIT( KLocationSieveUrl, "http://www.ovi.com/maps/lat=*&lon=*" );

const TUint KDecimalSeparator = '.';
const TUint KMinusSign = '-';

// ======== LOCAL FUNCTIONS ========
// ----------------------------------------------------------------------------
// CheckCoordinateParamL
//
// Checks if coordinate parameter (lon or lat) is in correct format
// Leaves if not
// Correct form is:
// -minus sign allowed only in first position
// -only one decimalseparator sign allowed
// -only digits allowed
// -aParam length not allowed to be zero
// ----------------------------------------------------------------------------
//
void CheckCoordinateParamL( const TDesC& aParam )
    {
    FUNC_LOG;
    if( aParam.Length() == 0 )
        {
        User::Leave( KErrArgument );
        }

    //check that aParam contains only digits and only one decimalseparator
    //and minus sign is first, if it exists
    TChar character;
    TBool decimalSeparatorFound = EFalse;
    TLex lex;
    lex.Assign( aParam );

    for( TInt i = 0; i < aParam.Length(); i++)
        {
        character = lex.Get();
        //checks if first character is minus sign and continues if it is
        if( i == 0 && (TUint)character == KMinusSign)
            {
            continue;
            }
        
        //check that only one decimal separator exists
        if ( (TUint)character == KDecimalSeparator )
            {
            if ( decimalSeparatorFound )
                {
                User::Leave( KErrArgument );
                }
            else
                {
                decimalSeparatorFound = ETrue;
                }
            }
        //check that character is either digit or decimalseparator
        if( !( character.IsDigit() ) && (TUint)character != KDecimalSeparator )
            {
            User::Leave( KErrArgument );
            }
        }
    }

// ----------------------------------------------------------------------------
// GetCoordinateParamValuesL
// Returns longitude and latitude if found correctly
// ----------------------------------------------------------------------------
//
void GetCoordinateParamValuesL( const TDesC& aUrl,
                                TPtrC& aLatitude,
                                TPtrC& aLongitude )
    {
    FUNC_LOG;
    
    //Find out if lat and lon params and separator exists in aUrl
    TInt latPos = aUrl.Find( KUrlParamLatitude );
    TInt lonPos = aUrl.Find( KUrlParamLongitude );
    TInt separatorPos = aUrl.Find( KUrlParamSeparator );
    
    if( latPos == KErrNotFound || lonPos == KErrNotFound
         || separatorPos == KErrNotFound )
        {
        User::Leave( KErrNotFound );
        }

    //takes from aUrl parts with actual coordinate data
    aLatitude.Set( aUrl.Mid(
            latPos + KUrlParamLatitude().Length(),
            separatorPos - latPos - KUrlParamLatitude().Length() ) );
    
    aLongitude.Set( aUrl.Right(
            aUrl.Length() - separatorPos - 1 - KUrlParamLongitude().Length() ) );
    }
}

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

// ---------------------------------------------------------------------------
// CMRUrlParserExtension::CMRUrlParserExtension
// ---------------------------------------------------------------------------
//
CMRUrlParserExtension::CMRUrlParserExtension()
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// CMRUrlParserExtension::NewL
// ---------------------------------------------------------------------------
//
CMRUrlParserExtension* CMRUrlParserExtension::NewL()
    {
    FUNC_LOG;
    
    CMRUrlParserExtension* self = CMRUrlParserExtension::NewLC();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CMRUrlParserExtension::NewLC
// ---------------------------------------------------------------------------
//
CMRUrlParserExtension* CMRUrlParserExtension::NewLC()
    {
    FUNC_LOG;
    
    CMRUrlParserExtension* self = new( ELeave ) CMRUrlParserExtension;
    CleanupStack::PushL( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CMRUrlParserExtension::~CMRUrlParserExtension
// ---------------------------------------------------------------------------
//
CMRUrlParserExtension::~CMRUrlParserExtension()
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// CMRUrlParserExtension::FindLocationUrl
// Finds location URL from given text input
// ---------------------------------------------------------------------------
//
void CMRUrlParserExtension::FindLocationUrlL(
        const TDesC& aText,
        TPtrC& aUrl,
        TInt& aPos)

    {
    FUNC_LOG;
    
    //Seach if base string is found from aText
    TInt urlLocation = aText.FindF( KLocationUrl );
    if ( urlLocation < KErrNone )
        {
        User::Leave(KErrNotFound);
        }

    //Take out unnecessary part before URL and search if endmark (whitespace)
    //is found. If endmark is not found,
    //then all the rest of descriptor is part of URL
    TPtrC urlAndAfter = aText.Mid( urlLocation );
    TInt urlAndAfterLength = urlAndAfter.Length();
    TInt urlEndmarkLocation = KErrNotFound;

    for( TInt i = 0; i < urlAndAfterLength; i++)
        {
        if( TChar( urlAndAfter[i] ).IsSpace() )
            {
            urlEndmarkLocation = i;
            break;
            }
        }

    if( urlEndmarkLocation == KErrNotFound )
        {
        urlEndmarkLocation = urlAndAfterLength;
        }

    //Take out part from beginning of URL to endmark
    TPtrC urlToEndMark = urlAndAfter.Left( urlEndmarkLocation );

    //Now we should have only URL left, check with "sieve" that it is about in
    //right format
    TInt sievedStartPoint = urlToEndMark.MatchF( KLocationSieveUrl );

    if( sievedStartPoint == KErrNotFound )
        {
        User::Leave(KErrNotFound);
        }

    //Check that parameters are in right format
    TPtrC latValue;
    TPtrC lonValue;

    GetCoordinateParamValuesL(
            urlToEndMark,
            latValue,
            lonValue );
    CheckCoordinateParamL( latValue );
    CheckCoordinateParamL( lonValue );

    //Set aURL to correspond URL part of aText and aPos with url position
    aUrl.Set( urlToEndMark );
    aPos = urlLocation;
    }

// ---------------------------------------------------------------------------
// CMRUrlParserExtension::CreateLandmarkFromUrlL
// Creates landmark object from location URL
// ---------------------------------------------------------------------------
//
CPosLandmark* CMRUrlParserExtension::CreateLandmarkFromUrlL(
        const TDesC& aUrl )
    {
    FUNC_LOG;
    
    TInt matchPos = User::LeaveIfError( aUrl.MatchF( KLocationSieveUrl ) );
    
    if( matchPos != 0 )
        {
        //URL was found but is not int the beginning of desc
        User::Leave( KErrArgument );
        }

    //Parse actual coordinate values out of url
    TPtrC latValue;
    TPtrC lonValue;
    GetCoordinateParamValuesL( aUrl, latValue, lonValue );

    //Check that parameters are in right format
    CheckCoordinateParamL( latValue );
    CheckCoordinateParamL( lonValue );

    //Convert parameters to TReal values
    TLex lexConverter( latValue );
    TReal64 realLatitude;
    lexConverter.Val( realLatitude );

    lexConverter.Assign( lonValue );
    TReal64 realLongitude;
    lexConverter.Val( realLongitude );

    //Create landmark with coordinatevalues
    CPosLandmark* landmark = CPosLandmark::NewLC();
    TLocality position;
    position.SetCoordinate( realLatitude, realLongitude );
    landmark->SetPositionL( position );
    CleanupStack::Pop( landmark );
    
    //transfer ownership
    return landmark;
    }

//EOF