/*

* Copyright (c) 2009 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: Class used for parsing a Landmarks URL & obtaining 

*							 landmarks information from it.

*

*

*/

#include    <lbsposition.h>

#include    <gulutil.h>

#include    <uri8.h>

#include    <escapeutils.h>

#include    <EPos_LandmarksErrors.h>

#include    "epos_cposlmurlparser.h"

#include    "EPos_CPosLmCategoryManager.h"

#include    "EPos_CPosLandmarkDatabase.h"

#include    "epos_cposlmurlparseroperation.h"

#include    "EPos_PosLmConverterUtils.h"

#include    "EPos_PosLmImplExtension.h"

#include    "EPos_CPosLandmarkCategory.h"

// Constants for formatting the Real numbers

const TInt KRealPoint = 46;

const TInt KRealDecimalPlaces = 2;

const TInt KCoordinateDecimalPlaces = 6;

// constants for checking the range of the coordinates

const TReal KMinLatitude = -90.0;

const TReal KMaxLatitude = 90.0;

const TReal KMinLongitude = -180.0;

const TReal KMaxLongitude = 180.0;

// constants that define the decode buffer length

const TInt KDecodeBufferLength = 3;

// constants defining the length for the date time buffers

const TInt KMaxDateTimeBufferLength = 22;

const TInt KMaxMicroSecondsLength = 6;

const TInt KMaxDateFieldLength = 8;

const TInt KMaxTimeFieldLength = 6;

// constants defining the length of the delimeters

const TInt KHostDelimeterLength = 3;

const TInt KQueryStartDelimeterLength = 2;

const TInt KLocationDelimeterLength = 2;

const TInt KParameterDelimeterLength = 1;

// constants defining length of chunk size

const TInt KMaxChunkSize = 5012;

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

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

// CPosLmUrlParser::CPosLmUrlParser

// Default Constructor

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

//

CPosLmUrlParser::CPosLmUrlParser()

    {

    // initialize the TRealFormat variable for latitude & longitude formatting

    iRealFormatCoordinates.iPoint = KRealPoint;

    iRealFormatCoordinates.iType = KRealFormatFixed | KDoNotUseTriads;

    iRealFormatCoordinates.iPlaces = KCoordinateDecimalPlaces;

    iRealFormatCoordinates.iWidth = KRealWidth;

    // initialize the TRealFormat variable for formatting other real32 numbers

    iRealFormat.iPoint = KRealPoint;

    iRealFormat.iType = KRealFormatFixed | KDoNotUseTriads;

    iRealFormat.iPlaces = KRealDecimalPlaces;

    iRealFormat.iWidth = KRealWidth;

    ResetUrlParameters();

    }

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

// CPosLmUrlParser::NewL

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

//

CPosLmUrlParser* CPosLmUrlParser::NewL()

    {

    return  new (ELeave) CPosLmUrlParser;

    }

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

// CPosLmUrlParser::~CPosLmUrlParser 

// Destructor

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

//

CPosLmUrlParser::~CPosLmUrlParser()

    {

    ResetUrlParser();

    }

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

// CPosLmUrlParser::SetInputBuffer 

// 

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

//

void CPosLmUrlParser::SetInputBuffer( const TDesC8&  aBuffer )

    {

    // Reset the parser first,so as to start parsing freshly

    ResetUrlParser();

    // Set the input buffer

    iInputBuffer.Set( aBuffer );

    // Set size of input buffer

    iContentSize = iInputBuffer.Length();

    // Change parser status to EStateInitialized

    iParserStatus = EStateInitialized;

    }

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

// CPosLmUrlParser::SetInputFileL 

// 

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

//

void CPosLmUrlParser::SetInputFileL( const TDesC&  aFile )

    {

    // Reset the parser first,so as to start parsing freshly

    ResetUrlParser();

    // Connect to the file server

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

    // Open the file in the read only mode

    User::LeaveIfError( iFile.Open( iFs, aFile,

            EFileShareReadersOnly | EFileRead ) );

    // Set the file handle

    iFileHandle = &iFile;

    // Set the file content size

    User::LeaveIfError( iFileHandle->Size( iContentSize ) );

    // Change parser status to EStateInitialized

    iParserStatus = EStateInitialized;

    }

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

// CPosLmUrlParser::SetInputFileHandleL 

// 

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

//

void CPosLmUrlParser::SetInputFileHandleL( RFile&  aFileHandle )

    {

    // Reset the parser first,so as to start parsing freshly

    ResetUrlParser();

    // set the file handle

    iFileHandle = &aFileHandle;

    // Set the file content size

    User::LeaveIfError( iFileHandle->Size( iContentSize ) );

    // Change parser status to EStateInitialized

    iParserStatus = EStateInitialized;

    }

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

// CPosLmUrlParser::ParseContentL 

// 

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

//

CPosLmOperation* CPosLmUrlParser::ParseContentL( TBool  aBuildIndex )

    {

    // Check that the parser status is EStateInitialized when this method is called,

    // if not panic with EPosLmProtocolBreak

    __ASSERT_ALWAYS( iParserStatus == EStateInitialized,

            Panic( KPosLandmarksClientPanic, EPosLmProtocolBreak ) );

    // Build index not supported ,hence leave with KErrNotSupported if specified

    if( aBuildIndex )

        {

        User::Leave( KErrNotSupported );

        }

    // Reset the url parameters

    ResetUrlParameters();

    // Delete any previous operation

    DisconnectUrlOperation();

    // Create a new instance of the operation class to be returned

    iUrlParserOp = CPosLmUrlParserOperation::NewL( *this );

    // change the parser status to EStateOperationCreated

    iParserStatus = EStateOperationCreated;

    return iUrlParserOp;

    }

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

// CPosLmUrlParser::NumOfParsedLandmarks 

// 

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

//

TUint32 CPosLmUrlParser::NumOfParsedLandmarks() const

    {

    return iNumOfParsedLandmarks;

    }

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

// CPosLmUrlParser::FirstCollectionDataId 

// 

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

//

TPosLmCollectionDataId CPosLmUrlParser::FirstCollectionDataId() const

    {

    // Do nothing,as collection data is not supported in url parsing

    return EPosLmCollDataNone;

    }

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

// CPosLmUrlParser::NextCollectionDataId 

// 

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

//

TPosLmCollectionDataId CPosLmUrlParser::NextCollectionDataId( 

                       TPosLmCollectionDataId  /*aCollectionDataId*/ ) const

    {

    // Do nothing,as collection data is not supported in url parsing

    return EPosLmCollDataNone;                   

    }

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

// CPosLmUrlParser::CollectionData 

// 

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

//

TPtrC CPosLmUrlParser::CollectionData( TPosLmCollectionDataId  /*aDataId*/ ) const

    {

    // Do nothing,as collection data is not supported in url parsing

    TPtrC nullDescriptor( KNullDesC );

    return nullDescriptor;

    }

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

// CPosLmUrlParser::LandmarkLC 

// 

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

//

CPosLandmark* CPosLmUrlParser::LandmarkLC( TUint aLandmarkIndex ) const

    {

    // Check that index passed always equal to KPosLastParsedLandmark

    // or less than the number of parsed landmarks but not negative

    __ASSERT_ALWAYS(

            aLandmarkIndex < iNumOfParsedLandmarks ||aLandmarkIndex == KPosLastParsedLandmark,

            Panic( KPosLandmarksClientPanic, EPosInvalidIndex ) );

    // Check if there are any parsed landmarks before returning the landmark,

    // else return KErrNotFound

    if( !iNumOfParsedLandmarks )

        {

        User::Leave( KErrNotFound );

        }

    return CPosLandmark::NewLC( *iParsedLandmark );

    }

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

// CPosLmUrlParser::LandmarkCategoryLC 

// 

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

//

CPosLandmarkCategory* CPosLmUrlParser::LandmarkCategoryLC( TPosLmItemId  

                                                           aCategoryId  ) const

    {

    // indicates whether the category with the id specified is found or not

    TBool found = EFalse;

    TInt i = 0;

    // check that there is a parsed landmark before getting any categories associated

    // with it,else leave with KErrNotFound

    if( !iNumOfParsedLandmarks )

        {

        User::Leave( KErrNotFound );

        }

    // check that categories exist for the parsed landmark,else leave with KErrNotFound

    if( !iParsedCategories.Count() )

        {

        User::Leave( KErrNotFound );

        }

    else

        {

        // Find the category with the id provided ,from the parsed categories,if not found 

        // leave with KErrNotFound

        for(  i=0; i<iParsedCategories.Count();i++ )  

            {

            if( iParsedCategories[i]->CategoryId() ==  aCategoryId )

                {

                found = ETrue;

                break;

                }

            }

        if( !found )

            {

            User::Leave( KErrNotFound );

            }

        }

    return CPosLandmarkCategory::NewLC( *iParsedCategories[i] );

    }

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

// CPosLmUrlParser::ResetUrlParser 

// 

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

//

void CPosLmUrlParser::ResetUrlParser()

    {

    // set input buffer to NULL

    iInputBuffer.Set( NULL, 0 );

    // if any filehandle exists,close it 

    if( iFileHandle )

        {

        iFileHandle = NULL;

        iFile.Close();

        iFs.Close();

        // delete the file buffer

        delete iFileReadBuffer;

        iFileReadBuffer = NULL;

        }

    // delete the previously parsed landmark

    if( iParsedLandmark )

        {

        delete iParsedLandmark;

        iParsedLandmark = NULL;

        }

    // reset the number of parsed landmarks to 0

    iNumOfParsedLandmarks = 0;

    // reset the categories array

    iParsedCategories.ResetAndDestroy();

    // Reset the parser status to EStateUnitialized

    iParserStatus = EStateUnitialized;

    }

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

// CPosLmUrlParser::DisconnectUrlOperation 

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

//

void CPosLmUrlParser::DisconnectUrlOperation()

    {

    if ( iUrlParserOp )

        {

        iUrlParserOp->DisconnectUrlParser();

        iUrlParserOp = NULL;

        }

    }

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

// CPosLmUrlParser::UrlOperationDestroyed

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

//

void CPosLmUrlParser::UrlOperationDestroyed()

    {

    iUrlParserOp = NULL;

    }

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

// CPosLmUrlParser::ParseUrlL

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

//

TInt CPosLmUrlParser::ParseUrlL()

    {

    TInt status = KPosLmOperationNotComplete;

    // Set the chunk size to be read from the file

    iChunkSize = iContentSize < KMaxChunkSize ? iContentSize : KMaxChunkSize;

    // Create instance of CPosLandmark to hold the parsed info

    iParsedLandmark = CPosLandmark::NewL();

    // Check on the parser status,if the status is EStateParsingPending

    // then continue with parsing the next location info

    if( iParserStatus == EStateParsingPending )

        {

        // Parse the next location info

        ParseUrlLocationL();

        // Now check the parsing status to confirm if its complete,if 

        // yes change the status to KErrNone

        if( iParserStatus == EStateParsingComplete )

            {

            status = KErrNone;

            }

        }

    else

        {

        // start parsing afresh by setting the input buffer/file

        // Check if the input is through a buffer or file

        if( iInputBuffer.Ptr() )

            {

            ParseBufferL( iInputBuffer );

            }

        else

            {

            // for file parsing read the file in parts & parse the chunks

            while(iSeek < iContentSize)

                {

                iFileReadBuffer = HBufC8::NewL( iChunkSize );

                TPtr8 fileReadBufferPtr = iFileReadBuffer->Des();

                User::LeaveIfError( iFileHandle->Read( iSeek, fileReadBufferPtr, iChunkSize ) );

                ParseBufferL( iFileReadBuffer->Des() );

                }

            }

        // Check on the parser status to set the status 

        if( iParserStatus == EStateParsingComplete )

            {

            status = KErrNone;

            }

        }

    return status;

    }

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

// CPosLmUrlParser::ParseBufferL

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

//

void CPosLmUrlParser::ParseBufferL( const TDesC8& aUrlBuffer )

    {

    // Check if the file parsing has already begun,if yes then parse

    // only the location params since the URL host is already parsed

    // in the beginning

    if( iSeek > 0 && iFileHandle )

        {

        iUrlLocation.Set( aUrlBuffer );

        // Parse & validate the URl location info

        ParseUrlLocationL();

        }

    else

        {

        // parse the buffer to find the query start delimeter

        TInt queryStartDelimeterPosition = aUrlBuffer.Find( KUrlQueryStartDelimeter );

        if( queryStartDelimeterPosition != KErrNotFound )

            {

            // Extract the url host 

            iUrlHost.Set( aUrlBuffer.Mid( 0, queryStartDelimeterPosition ) );

            // Increment the file seek position until the query start delimeter

            iSeek = iSeek + iUrlHost.Length()+ KQueryStartDelimeterLength;

            // Parse & validate the url host

            ParseUrlHostL();

            // Extract the Url location parameters

            iUrlLocation.Set( aUrlBuffer.Mid( queryStartDelimeterPosition+KQueryStartDelimeterLength, 

                              ( aUrlBuffer.Length() - 

                              ( queryStartDelimeterPosition+KQueryStartDelimeterLength ) ) ) );

            // Parse & validate the URl location info

            ParseUrlLocationL();

            }

        else

            {

            User::Leave( KErrPosLmUnknownFormat );

            }

        }

    }

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

// CPosLmUrlParser::ParseUrlHostL

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

//

void CPosLmUrlParser::ParseUrlHostL()

    {

    // Holds the extracted scheme portion of the URl

    TPtrC8 parsedUriScheme ;

    // Holds the extracted host name portion of the URL

    TPtrC8 parsedUriHost;

    // Find the Url host delimeter position

    TInt urlHostDelimeterPosition = iUrlHost.Find( KUrlHostDelimeter );

    // Check if the delimeter is found,if yes then validate the scheme

    // & host name with the allowed values,else only validate the hostname 

    if( urlHostDelimeterPosition != KErrNotFound )

        {

        // Extract the scheme part of the Url

        parsedUriScheme.Set( iUrlHost.Mid( 0, urlHostDelimeterPosition ) );

        // Extract the host name

        parsedUriHost.Set( iUrlHost.Mid( urlHostDelimeterPosition+KHostDelimeterLength,

                           iUrlHost.Length() - 

                           ( urlHostDelimeterPosition+KHostDelimeterLength ) ) );

        // validate the uri scheme by Comparing with the allowed values for Url Scheme, 

        // if it does not match then leave with KErrPosLmUnknownFormat

        if( ( parsedUriScheme.CompareC( KUrlSchemeHttp ) ) &&

            ( parsedUriScheme.CompareC( KUrlSchemeHttps ) ) )

            {

            User::Leave( KErrPosLmUnknownFormat );

            }

        // validate the uri host by Comparing with the allowed values for Url Host, 

        // if it does not match then leave with KErrPosLmUnknownFormat

        if( ( parsedUriHost.CompareC( KUrlHostFull ) ) &&

            ( parsedUriHost.CompareC( KUrlHost ) ) )

            {

            User::Leave( KErrPosLmUnknownFormat );

            }

        }

    else

        {

        // validate the uri host by Comparing with the allowed values for Url Host, 

        // if it does not match then leave with KErrPosLmUnknownFormat

        if( ( iUrlHost.CompareC( KUrlHostFull ) ) &&

            ( iUrlHost.CompareC( KUrlHost ) ) )

            {

            User::Leave( KErrPosLmUnknownFormat );

            }

        }

    }

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

// CPosLmUrlParser::ParseUrlLocationL

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

//

void CPosLmUrlParser::ParseUrlLocationL()

    {

    // Holds the extracted location info

    TPtrC8 parsedUrlLocation;

    // Get the location delimeter position

    TInt locationDelimeterPosition = iUrlLocation.Find( KUrlLocationDelimeter );

    // Continue parsing till the next delimeter is not found

    if( locationDelimeterPosition != KErrNotFound )

        {

        // Reset the URL parameters

        ResetUrlParameters();

        // Extract the location information for a single landmark

        parsedUrlLocation.Set( iUrlLocation.Mid( 0, locationDelimeterPosition ) );

        // Remove the extracted location from iUrlLocation

        iUrlLocation.Set( iUrlLocation.Mid( locationDelimeterPosition+KLocationDelimeterLength,  

                       ( iUrlLocation.Length() -

                       ( locationDelimeterPosition+KLocationDelimeterLength ) ) ) );

        // parse the url parameters for the extracted location