/*

* 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: Parser implementation for KML format.

*

*

*/

#include <utf.h>

#include <gulutil.h>

#include <bautils.h>

#include <xml/xmlparsererrors.h>

#include <lbs.h>

#include <EPos_PosLmImplExtension.h>

#include <EPos_LandmarksErrors.h>

#include "EPos_CPosLmXmlParser.h"

#include "EPos_CPosLmXmlParserOperation.h"

#include "EPos_CPosLmCollectionData.h"

#include "EPos_CPosLmParsedLmBuffer.h"

#include "EPos_PosLmConverterUtils.h"

#include "EPos_LmConverter.h"

#include "EPos_CPosLmKmlParser.h"

#include "EPos_PosLmUnzipUtil.h"

// Maximum and Minimum values for Lat, Long

//as defined in KML reference Document

const TReal KPosLmParserMinLatitude = -90.0;

const TReal KPosLmParserMaxLatitude = 90.0;

const TReal KPosLmParserMinLongitude = -180.0;

const TReal KPosLmParserMaxLongitude = 180.0;

//kmz mime type - defiend in KML reference doc

_LIT8(KPosKmzMimetype,       "application/vnd.google-earth.kmz");

const TUint KPosXmlCommaSeparator = ',';

const TInt KMaxDirName = 256;

const TInt KMaxPostalCode = 10;

_LIT(KExtractZipPath, "extracts\\");

_LIT(KFindKmlExtension, "*.kml");

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

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

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

//

CPosLmKmlParser::CPosLmKmlParser(TAny* aType)

    {

    	//is it KMZ file? check the mime type

       	HBufC8* aMimeType =(HBufC8*)aType;

	    TPtrC8 aPointer = aMimeType->Des();

	    if(aPointer.CompareF(KPosKmzMimetype) == 0)

	    {

	    	iIsKmzFile = ETrue;

	    }

    }

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

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

//

CPosLmKmlParser* CPosLmKmlParser::NewL(TAny* aType)

    {

	    CPosLmKmlParser* self = new (ELeave) CPosLmKmlParser(aType);

	    return self;

    }

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

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

//

CPosLmKmlParser::~CPosLmKmlParser()

    {

     iCategoryArray.ResetAndDestroy();

     iCategoryAdded.Reset();

     iCategoryAdded.Close();

     if(iKmlFileList)

     	delete iKmlFileList;

     ClearParserData();

    }

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

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

//

void CPosLmKmlParser::OnStartDocumentL(

    const Xml::RDocumentParameters& aDocParam, 

    TInt aErrorCode)

    {

    CPosLmXmlParser::OnStartDocumentL( aDocParam, aErrorCode );

    }

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

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

//

void CPosLmKmlParser::GetNextAllowedTagsL( RArray<TPosXmlTagType>& aChildTags )

    {

    switch ( CurrentTree() )

        {

        case EPosXmlNothing:

            {

            aChildTags.AppendL( EPosXmlRoot );

            break;

            }

        case EPosXmlRoot:

            {

            const TPosXmlTagType rootChildren[] = { 

                EPosXmlLandmark,EPosXmlDocument,EPosXmlLandmark,EPosXmlFolder,

                EPosXmlDocument,EPosXmlFolder, EPosXmlLandmark,EPosXmlLandmark,

                EPosXmlDocument,EPosXmlFolder //multiple documents, Folders & landmark possible 

                };

            const TInt rootChildrenSize = sizeof( rootChildren ) / sizeof( TPosXmlTagType );

            GenValidSequenceL( rootChildren, rootChildrenSize, aChildTags );

            break;

            }

        case EPosXmlDocument:

            {

            const TPosXmlTagType documentChildren[] = { 

                EPosXmlLmCollName,EPosXmlDocument,EPosXmlFolder, 

                EPosXmlLandmark,EPosXmlLandmark, // landmark can be repeated

                 EPosXmlFolder,EPosXmlDocument//Folder& Document can be repeated

                };

            const TInt documentChildrenSize = sizeof( documentChildren ) / sizeof( TPosXmlTagType );

            GenValidSequenceL( documentChildren, documentChildrenSize, aChildTags );

            break;

            }    

         case EPosXmlFolder:

            {

            const TPosXmlTagType folderChildren[] = { 

                EPosXmlLmCollName,EPosXmlDocument,EPosXmlFolder,

                EPosXmlLandmark,EPosXmlLandmark, // landmark can be repeated

                EPosXmlFolder,EPosXmlDocument//Folder& Document can be repeated

                };

            const TInt folderChildrenSize = sizeof( folderChildren ) / sizeof( TPosXmlTagType );

            GenValidSequenceL( folderChildren, folderChildrenSize, aChildTags );

            break;

            }       

        case EPosXmlLandmark:

            {

            const TPosXmlTagType landmarkChildren[] = { 

                EPosXmlLmName,EPosXmlAddress,EPosXmlPhoneNumber,EPosXmlLmDescription,

                 EPosXmlpoint

                };

            const TInt landmarkChildrenSize = sizeof( landmarkChildren ) / sizeof( TPosXmlTagType );

                GenValidSequenceL( landmarkChildren, landmarkChildrenSize, aChildTags );

            break;

            }

          case EPosXmlpoint:

            {

            const TPosXmlTagType pointChildren[] = { 

                EPosXmlpointcoordinates

                };

            const TInt pointChildrenSize = sizeof( pointChildren ) / sizeof( TPosXmlTagType );

                GenValidSequenceL( pointChildren, pointChildrenSize, aChildTags );

            break;

            }  

        default:

            break;

        }

    }

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

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

//

void CPosLmKmlParser::CheckMandatoryTagsL( TPosXmlTagType /*aTreeType */ )

    {

    }

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

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

//

void CPosLmKmlParser::SetContentL( TPosXmlTagType aTag, const TDesC& aContent )

    {

    switch (aTag)

        {

        case EPosXmlLmCollName: // Folder/Document names will be taken as category

        	iCategoryArray.Append(aContent.Left( KPosLmMaxCategoryNameLength ).AllocL());

        	iCategoryAdded[iFolderCount-1] = ETrue;

            break;

        case EPosXmlLandmark: // landmark Tags

        {

            HBufC* buf= HBufC::NewLC(KPosLmMaxTextFieldLength);

            TPtrC name = buf->Des();

            iWorkingLandmark->GetLandmarkName(name);

            //Landmark name is mendatory field in landmark

            PosLmConverterUtils::AssertL( !(name == KNullDesC));

            if ( !Math::IsNaN( iParsedLatitude ) && !Math::IsNaN( iParsedLongitude ) )

	                {

	                TLocality loc(

	                    TCoordinate(

	                        iParsedLatitude, 

	                        iParsedLongitude,

	                        iParsedAltitude), 

	                    0, //horizontal accuracy 0

	                    0); //vertiacal accuracy 0

	                iWorkingLandmark->SetPositionL(loc);

	                }

	                else

	                {

	                	if(!Math::IsNaN( iParsedLatitude ) || !Math::IsNaN( iParsedLongitude ))

	                	{

	                		User::Leave(KErrPosLmUnknownFormat); // Long and lat both are mendatory. If only one is available - leave

	                	}

	                }

				//Set category for current landmark if any.

	           if(iCategoryArray.Count()>0)

	           {

	            if (iCategoryArray[iCategoryArray.Count()-1]->Length() > 0 )

	            {

	            	CPosLandmarkCategory* category = CPosLandmarkCategory::NewLC();

	            	PosLmImplExtension::SetCategoryIdL( *category, iWorkingItemId );

	            	category->SetCategoryNameL( iCategoryArray[iCategoryArray.Count()-1]->Left( KPosLmMaxCategoryNameLength ) );

	            	iWorkingLandmark->AddCategoryL( iWorkingItemId++ );

	            	User::LeaveIfError( iCategories.Append( category ) );

	            	CleanupStack::Pop(category);//buf

	            	category = NULL;

	            }

	           }

            HandleLandmarkParsedL();

            CleanupStack::PopAndDestroy(buf);//buf

        break;

        }

        case EPosXmlLmName:

            iWorkingLandmark->SetLandmarkNameL( aContent.Left( KPosLmMaxTextFieldLength ) );

            break;

        case EPosXmlLmDescription:

            iWorkingLandmark->SetLandmarkDescriptionL( aContent.Left( KPosLmMaxDescriptionLength ) );

            break;

        case EPosXmlAddress: //extracting address field

        {

	       HBufC* Buf= HBufC::NewLC(KPosLmMaxTextFieldLength);

	       TPtrC Pointer = Buf->Des();

	       TPtrC contentBuf;

				TInt aLength=aContent.Length();

				TInt column = 0;

				TInt addressField[] = {EPositionFieldStreet, EPositionFieldCity, EPositionFieldPostalCode, EPositionFieldState, EPositionFieldCountry };

				//extracting street information

				//if '<' found in address string then till the first comma after the '<'

				//will be considered as Stree name.

				TInt anglePosition1 = aContent.Locate('<');

				TInt aCount =0;

				if(anglePosition1 > 0)

				{

					//First comma position after '<'

					TInt commaPosition = aContent.Mid(anglePosition1 + 1).Locate(KPosXmlCommaSeparator);

					commaPosition +=anglePosition1 + 1;

					//Set street name.

					iWorkingLandmark->SetPositionFieldL(addressField[0],aContent.Left(commaPosition));

					column++;

					contentBuf.Set(aContent.Right(aLength-(commaPosition+1)));

				}

				else

				{

					contentBuf.Set(aContent);

				}

				while (TextUtils::ColumnText(Pointer,aCount,&contentBuf,KPosXmlCommaSeparator) != KErrNotFound )

				{

					if(addressField[column] == EPositionFieldPostalCode)

					{

						if(!(IsNumber(Pointer.Left( KMaxPostalCode ))))

						 column++; // if it is not number then set it to state

					}

					if( addressField[column] == EPositionFieldCountry)

				 	{

				 		if(IsNumber(Pointer.Left( KMaxPostalCode )))

						   column = 2; //if it is number then set it to postal code

				 	}

					iWorkingLandmark->SetPositionFieldL(addressField[column],Pointer.Left( KPosLmMaxTextFieldLength ));

					if(column == 2)

						column+=2; //If it is postal code then next should be country so add 2

					else

						column++;

					aCount++;

					if(aCount >= 4 || column>=5)	

						break;		

				}

				CleanupStack::PopAndDestroy();

        }

        break;

        case EPosXmlPhoneNumber:   

        	 iWorkingLandmark->SetPositionFieldL(EPositionFieldBuildingTelephone,aContent.Left( KPosLmMaxTextFieldLength ) );

             break;   

        case EPosXmlpointcoordinates:

        {

        	HBufC* aBuf= HBufC::NewLC(KPosLmMaxTextFieldLength);

          TPtrC aPoints = aBuf->Des();

					TInt count = 0;

					while (TextUtils::ColumnText(aPoints,count,&aContent,KPosXmlCommaSeparator) != KErrNotFound )

						{

							switch(count)

							{

								case 0:

									PosLmConverterUtils::DesToRealL(aPoints, iParsedLongitude);

									// Ensure longtitude is in valid range

									PosLmConverterUtils::AssertL((iParsedLongitude <= KPosLmParserMaxLongitude &&

					                iParsedLongitude >= KPosLmParserMinLongitude) ||

					                Math::IsNaN(iParsedLongitude));

								break;

								case 1:

									PosLmConverterUtils::DesToRealL(aPoints,iParsedLatitude );

									// Ensure latitude is in valid range

									PosLmConverterUtils::AssertL(

					                (iParsedLatitude <= KPosLmParserMaxLatitude &&

					                iParsedLatitude >= KPosLmParserMinLatitude) ||

					                Math::IsNaN(iParsedLatitude));

				                break;

								case 2:

									PosLmConverterUtils::DesToRealL(aPoints,iParsedAltitude );

								default:

								break;

							}

							count++;		

						}

					CleanupStack::PopAndDestroy();	

		}

     break;

    default:

            break;

        }

    }

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

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

//

TBool CPosLmKmlParser::IsLandmarkStarted( TPosXmlTagType aTag )

    {

    return ( aTag == EPosXmlLandmark );

    }

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

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

//

TBool CPosLmKmlParser::IsCategoryStarted( TPosXmlTagType aTag )

    {

    return ( aTag == EPosXmlCategoryName );

    }

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

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

//

TBool CPosLmKmlParser::IsTreeTag( TPosXmlTagType aTag )

    {

    __ASSERT_DEBUG( aTag != EPosXmlNothing, Panic( KPosLmConverterPanic, KErrGeneral ) );

    __ASSERT_DEBUG( aTag != EPosXmlUnknown, Panic( KPosLmConverterPanic, KErrGeneral ) );

    return ( aTag >= EPosXmlLmLastTree ) ? ETrue : EFalse;

    }

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

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

//

TPosXmlTagType CPosLmKmlParser::AttributeTypeL( TPosXmlTagType /*aParent*/, const Xml::RTagInfo& /*aElement*/ )

    {

    TPosXmlTagType tagType = EPosXmlUnknown;

    return tagType;

    }

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

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

//

TPosXmlTagType CPosLmKmlParser::TagTypeL( const Xml::RTagInfo& aElement )

    {

    TPosXmlTagType tagType = EPosXmlUnknown;

    TPosXmlTagType treeType = CurrentTree();

    TPtrC8 tagName = aElement.LocalName().DesC();

    if ( treeType == EPosXmlNothing )

        {

        if ( EqualsTagL( tagName, KPosXmlKmlRoot ) )

            {

            tagType = EPosXmlRoot;

            }

        }

    else if ( MatchesRootNamespace( aElement ) )

        {

        switch ( treeType )

            {

            case EPosXmlRoot:

                {

                if ( EqualsTagL( tagName, KPosXmlKmlMetadata ) )

                    {

                    tagType = EPosXmlMetadata;

                    }

                else if ( EqualsTagL( tagName, KPosXmlKmlDocument ) )

                    {

                    tagType = EPosXmlDocument;

                    }  

                else if ( EqualsTagL( tagName, KPosXmlKmlFolder ) )

                    {

                    tagType = EPosXmlFolder;

                    }        

                else if ( EqualsTagL( tagName, KPosXmlKmlPlacemark ) )

                    {

                    tagType = EPosXmlLandmark;

                    }

                else if ( EqualsTagL( tagName, KPosXmlKmlCollName ) ) 

                    {

                    tagType = EPosXmlLmCollName;

                    }

                else if ( EqualsTagL( tagName, KPosXmlKmlRoot ) )

                    {

                    User::Leave( EXmlRecursiveEntity );

                    }

                }

                break;

            case EPosXmlDocument:

            	 if ( EqualsTagL( tagName, KPosXmlKmlPlacemark ) )

                    {

                    tagType = EPosXmlLandmark;

                    }

                 else if ( EqualsTagL( tagName, KPosXmlKmlFolder ) )

                    {

                    tagType = EPosXmlFolder;

                    }   

                 else if ( EqualsTagL( tagName, KPosXmlKmlDocument ) )

                    {

                    //User::Leave( EXmlRecursiveEntity );

                    tagType = EPosXmlDocument;

                    }

                 else if ( EqualsTagL( tagName, KPosXmlKmlCollName ) ) 

                    {

                    tagType = EPosXmlLmCollName;

                    }     

                break;

             case EPosXmlFolder:

            	 if ( EqualsTagL( tagName, KPosXmlKmlPlacemark ) )

                    {

                    tagType = EPosXmlLandmark;

                    }

                 else if ( EqualsTagL( tagName, KPosXmlKmlDocument ) )

                    {

                    tagType = EPosXmlDocument;

                    }     

                 else if ( EqualsTagL( tagName, KPosXmlKmlFolder ) )

                    {

                  //  User::Leave( EXmlRecursiveEntity );

                  	tagType = EPosXmlFolder;

                    }

                else if ( EqualsTagL( tagName, KPosXmlKmlCollName ) ) 

                {

                tagType = EPosXmlLmCollName;

                }      

                break;   

            case EPosXmlMetadata:

                {

                if ( EqualsTagL( tagName, KPosXmlKmlCollName ) ) 

                    {

                    tagType = EPosXmlLmCollName;

                    }

                else if ( EqualsTagL( tagName, KPosXmlKmlMetadata ) )

                    {

                    User::Leave( EXmlRecursiveEntity );

                    }

                }

                break;

            case EPosXmlLandmark:

                {

                if ( EqualsTagL( tagName, KPosXmlKmlLmName ) )