/*

* 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 for parsing landmarks to url and vice versa

*

*/

#include "emailtrace.h"

#include <EPos_CPosLandmark.h>

#include <ecom/implementationproxy.h>

#include <barsread.h>

#include <esmrurlparserplugindata.rsg>

#include <data_caging_path_literals.hrh>

#include <barsc.h>

#include <f32file.h>

#include <lbsposition.h>

#include "cesmrurlparserpluginimpl.h"

#include "esmrinternaluid.h"

_LIT( KResourceName, "esmrurlparserplugindata.rsc" );

_LIT( KResourceFileLocFormat, "r%02d" );

_LIT( KResourceFormat, "rsc" );

const TInt KCoordinateMaxLength = 10;

const TInt KNumberOfDecimals = 4;

const TUint KDecimalSeparator = '.';

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

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

// Non-leaving constructor

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

//

CESMRUrlParserPluginImpl::CESMRUrlParserPluginImpl()

:   iIsInitialized(EFalse)

    {

    FUNC_LOG;

    }

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

// ConstructL for leaving construction

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

//

void CESMRUrlParserPluginImpl::ConstructL()// codescanner::LFunctionCantLeave

    {

    FUNC_LOG;

    }

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

// Symbian style NewL constructor

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

//

CESMRUrlParserPluginImpl* CESMRUrlParserPluginImpl::NewL()

    {

    FUNC_LOG;

    CESMRUrlParserPluginImpl* self = CESMRUrlParserPluginImpl::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Symbian style NewLC constructor

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

//

CESMRUrlParserPluginImpl* CESMRUrlParserPluginImpl::NewLC()

    {

    FUNC_LOG;

    CESMRUrlParserPluginImpl* self = new( ELeave ) CESMRUrlParserPluginImpl;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CESMRUrlParserPluginImpl::~CESMRUrlParserPluginImpl()

    {

    FUNC_LOG;

    iFile.Close();

    iFs.Close();

    }

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

// Finds location URL from given text input

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

//

TInt CESMRUrlParserPluginImpl::FindLocationUrl( const TDesC& aText, 

                                                      TPtrC& aUrl )

    {

    FUNC_LOG;

    TInt pos(0);

    TRAPD( error, pos = DoFindLocationUrlL( aText, aUrl ) );

    if ( error != KErrNone )

        {

        return error;

        }

    else

        {

        return pos;

        }

    }

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

// Finds location URL from given text input

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

//

TInt CESMRUrlParserPluginImpl::DoFindLocationUrlL( // codescanner::intleaves

                                       const TDesC& aText, 

                                       TPtrC& aUrl )

    {

    FUNC_LOG;

    //If this parserplugin instance is not yet initialized

    //init it now

    if( !iIsInitialized )

        {

        InitializeL();

        }

    //Read basestring from resource file

    HBufC* baseString = ReadResourceStringLC(R_QTN_LOCATION_URL);

    //Seach if base string is found from aText

    TInt urlLocation = aText.Find(*baseString);

    CleanupStack::PopAndDestroy(baseString);

    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

    HBufC* urlAndAfterBuf = aText.Mid( urlLocation ).AllocLC();

    TInt urlAndAfterBufLength = urlAndAfterBuf->Length();

    TInt urlEndmarkLocation = KErrNotFound; 

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

        {

        if( TChar( (*urlAndAfterBuf)[i] ).IsSpace() )

            {

            urlEndmarkLocation = i;

            break;

            }

        }

    if( urlEndmarkLocation == KErrNotFound )

        {

        urlEndmarkLocation = urlAndAfterBufLength;

        }

    //Take out part from beginning of URL to endmark

    HBufC* urlToEndMark = urlAndAfterBuf->Left( urlEndmarkLocation ).AllocLC();

    //Now we should have only URL left, check with "sieve" that it is about in 

    //right format

    HBufC* sieve = ReadResourceStringLC(R_QTN_LOCATION_SIEVE_URL);

    TInt sievedStartPoint = urlToEndMark->Match( *sieve );

    CleanupStack::PopAndDestroy(sieve);

    CleanupStack::PopAndDestroy(urlToEndMark);

    CleanupStack::PopAndDestroy(urlAndAfterBuf);

    if( sievedStartPoint == KErrNotFound )

        {

        User::Leave(KErrNotFound);

        }

    //Check that parameters are in right format

    TPtrC latValue;

    TPtrC lonValue;

    GetCoordinateParamValuesL( aText.Mid(urlLocation,urlEndmarkLocation),

                               latValue, lonValue );

    CheckCoordinateParamL( latValue );

    CheckCoordinateParamL( lonValue );

    //Set aURL to correspond URL part of aText and return with url position

    aUrl.Set( aText.Mid(urlLocation,urlEndmarkLocation));

    return urlLocation;

    }

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

// Creates location URL from landmark object

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

//

HBufC* CESMRUrlParserPluginImpl::CreateUrlFromLandmarkL( 

                                               const CPosLandmark& aLandmark )

    {

    FUNC_LOG;

    //If this parserplugin instance is not yet initialized

    //init it now

    if( !iIsInitialized )

        {

        InitializeL();

        }

    //Take longitude and latitude out of landmark

    TLocality position;

    User::LeaveIfError( aLandmark.GetPosition( position ) );

    TReal64 latitude = position.Latitude();

    TReal64 longitude = position.Longitude();

    //Define TReal format type

    TRealFormat format( KCoordinateMaxLength );

    format.iType = KRealFormatFixed;

    format.iPlaces = KNumberOfDecimals;

    format.iPoint = TChar(KDecimalSeparator);

    //Read strings from resourcefile

    HBufC* baseUrl = ReadResourceStringLC( R_QTN_LOCATION_URL );                        

    HBufC* lat = ReadResourceStringLC( R_QTN_LOCATION_URL_LATITUDE );               

    HBufC* separator = ReadResourceStringLC( R_QTN_LOCATION_URL_PARAM_SEPARATOR );        

    HBufC* lon = ReadResourceStringLC( R_QTN_LOCATION_URL_LONGITUDE );

    //Concatenate all strings and coordinates

    HBufC* url = HBufC::NewL( baseUrl->Length() + lat->Length() + separator->Length() 

                         + lon->Length() + format.iWidth + format.iWidth );

    TPtr pointer = url->Des();

    pointer.Append( *baseUrl );

    pointer.Append( *lat );

    pointer.AppendNum( latitude, format );

    pointer.Append( *separator );

    pointer.Append( *lon );

    pointer.AppendNum( longitude, format );

    CleanupStack::PopAndDestroy( lon );

    CleanupStack::PopAndDestroy( separator );

    CleanupStack::PopAndDestroy( lat  );

    CleanupStack::PopAndDestroy( baseUrl );

    //Transfer ownership of url

    return url;

    }

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

// Creates landmark object from location URL

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

//

CPosLandmark* CESMRUrlParserPluginImpl::CreateLandmarkFromUrlL( 

                                                           const TDesC& aUrl )

    {

    FUNC_LOG;

    //If this parserplugin instance is not yet initialized

    //init it now

    if( !iIsInitialized )

        {

        InitializeL();

        }

    //Read sieve from resourcefile and check if URL matches the sieveformat

    HBufC* sieve = ReadResourceStringLC( R_QTN_LOCATION_SIEVE_URL );

    TInt matchPos = User::LeaveIfError( aUrl.Match( *sieve ) );

    CleanupStack::PopAndDestroy( sieve );

    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;

    }

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

// CESMRUrlParserPluginImpl::LocateResourceFile

//

// For locating resource file    

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

// 

TInt CESMRUrlParserPluginImpl::LocateResourceFile( 

        const TDesC& aResource,

        const TDesC& aPath,

        TFileName &aResourceFile,

        RFs* aFs )

    {

    FUNC_LOG;

    TFindFile resourceFile( *aFs );

    TInt err = resourceFile.FindByDir(

            aResource,

            aPath );

    if ( KErrNone == err )

        {

        aResourceFile.Copy( resourceFile.File() );

        }

    else

        {

        const TChar KFileFormatDelim( '.' );

        TFileName locResourceFile;

        TInt pos = aResource.LocateReverse( KFileFormatDelim );

        if ( pos != KErrNotFound )

            {       

            locResourceFile.Copy( aResource.Mid(0, pos + 1) );

            TInt language( User::Language() );

            locResourceFile.AppendFormat( KResourceFileLocFormat, language );

            TFindFile resourceFile( *aFs );

            err = resourceFile.FindByDir(

                    locResourceFile,

                    aPath );            

            if ( KErrNone == err )

                {

                aResourceFile.Copy( resourceFile.File() );

                aResourceFile.Replace(

                        aResourceFile.Length() - KResourceFormat().Length(),

                        KResourceFormat().Length(),

                        KResourceFormat() );

                }

            }

        }

    return err; 

    }

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

// CESMRUrlParserPluginImpl::InitializeL

//

// Initializes resources

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

// 

void CESMRUrlParserPluginImpl::InitializeL()

    {

    FUNC_LOG;

    if( iIsInitialized )

        {

        return;

        }

    //Connect to RFs session

    User::LeaveIfError( iFs.Connect( KFileServerDefaultMessageSlots ) );

    //Find and open resource file containing URL strings

    TFileName fileName;

    User::LeaveIfError( LocateResourceFile( KResourceName,

                                            KDC_RESOURCE_FILES_DIR,

                                            fileName,

                                            &iFs ) );

    iFile.OpenL( iFs, fileName );

    iFile.ConfirmSignatureL();

    iIsInitialized = ETrue;

    }

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

// CESMRUrlParserPluginImpl::ReadResourceStringLC 

// Reads resource string from specified id

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

// 

HBufC* CESMRUrlParserPluginImpl::ReadResourceStringLC( TInt aResourceId )

    {

    FUNC_LOG;

    HBufC8* string = iFile.AllocReadLC(aResourceId);

    iReader.SetBuffer(string);

    HBufC* stringBuffer = iReader.ReadTPtrC().AllocL();

    CleanupStack::PopAndDestroy( string );

    CleanupStack::PushL( stringBuffer );

    //stringBuffer ownership is transfered

    return stringBuffer; 

    }

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

// CESMRUrlParserPluginImpl::CheckCoordinateParam 

//

// 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 CESMRUrlParserPluginImpl::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 );

    const TUint KMinusSign = '-';

    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 decimalseparator 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 );

            }

        }

    }

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

// CESMRUrlParserPluginImpl::GetCoordinateParamValuesL 

// Returns longitude and latitude if found correctly

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

// 

void CESMRUrlParserPluginImpl::GetCoordinateParamValuesL( const TDesC& aUrl,

                                                          TPtrC& aLatitude,

                                                          TPtrC& aLongitude )

    {

    FUNC_LOG;

    //Read latitude and longitude strings from resourcefile

    HBufC* lat = ReadResourceStringLC( R_QTN_LOCATION_URL_LATITUDE );

    HBufC* lon = ReadResourceStringLC( R_QTN_LOCATION_URL_LONGITUDE );

    HBufC* separator = ReadResourceStringLC( R_QTN_LOCATION_URL_PARAM_SEPARATOR );

    //Find out if lat and lon params and separator exists in aUrl

    TInt latPos = aUrl.Find( *lat );

    TInt lonPos = aUrl.Find( *lon );

    TInt separatorPos = aUrl.Find( *separator );

    if( latPos == KErrNotFound || lonPos == KErrNotFound 

         || separatorPos == KErrNotFound )

        {

        User::Leave( KErrNotFound );

        }

    //takes from aUrl parts with actual coordinate data

    aLatitude.Set( aUrl.Mid( latPos + lat->Length(), separatorPos - latPos - lat->Length() ) );

    aLongitude.Set( aUrl.Right( aUrl.Length() - separatorPos - 1 - lon->Length() ) );

    CleanupStack::PopAndDestroy( separator );

    CleanupStack::PopAndDestroy( lon );

    CleanupStack::PopAndDestroy( lat );

    }

//EOF