/*

* Copyright (c) 2006-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:  ?Description

*

*/

#include <f32file.h>

#include <parser.h>

#include <utf.h>

#include "iradvertisement.h"

#include "irbrowsecatagoryitems.h"

#include "irbrowsechannelitems.h"

#include "ircachemgmt.h"

#include "irdebug.h"

#include "irisdspreset.h"

#include "irparserobserver.h"

#include "irotaupdate.h"

#include "irxmlcontenthandler.h"

#include "irxmlelements.h"

const TInt KLargeArraySize = 256;

const TUint8 KAttributeBufferSize = 100;

const TUint8 KBitRateCounterValue0 = 0;

const TUint8 KBitRateCounterValue1 = 1;

const TUint8 KBitRateCounterValue2 = 2;

const TUint8 KCategoriesItemSelect = 0;

const TUint8 KChannelItemSelect = 1;

const TUint8 KPresetItemSelect = 2;

const TUint8 KOTAUpdateItemSelect = 3;

const TUint8 KIRIDSelect = 4;

const TUint8 KTen = 10; 

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

// Gets the Filepath of the XML file

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

//

EXPORT_C void CIRXMLContentHandler::ParseXmlL(const TDesC& aFilePath,

  											   const TDesC& aCachePath,

											   const CIRHttpResponseData& aResponseHeaders)

    { 

    IRLOG_DEBUG( "CIRXMLContentHandler::ParseXmlL" );

    iFileToCache.Zero();

    iFileToCache.Copy(aCachePath);     

    RFs fs;

    CleanupClosePushL(fs);

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

    Xml::ParseL(*iParser,fs,aFilePath);

    CleanupStack::PopAndDestroy(&fs);

    //! Error in the Document

    if(iEOD != KErrNone )

		{

        ResetValues();

        iParseObserver.ParseError( iEOD ); 

		}

    else

		{    

		if(iCategories)

			{

			TRAP_IGNORE(iCache->CacheCategoryItemsL(*iPtrCategory, 

				iFileToCache ,aResponseHeaders))

            ResetValues();    

            iParseObserver.ParsedStructureL(KCategoriesItemSelect);

			}

		if(iChan)            

			{        

            if(iFileToCache.Length()!=0)

				{

				TRAP_IGNORE(iCache->CacheChannelItemsL(*iPtrChannel, 

					iFileToCache ,aResponseHeaders))

				}

            ResetValues();

            iParseObserver.ParsedStructureL(KChannelItemSelect);

			}

		if(iPresets)

			{

			if( 0 < iPtrPreset->Count() )

				{

				TRAP_IGNORE(iCache->CachePresetItemL(*iPtrPreset,

					iFileToCache,aResponseHeaders))

	            ResetValues();

	            iParseObserver.ParsedStructureL(KPresetItemSelect);     

				}			   

			}  

		if(iOTAUpdate)

			{

			TRAP_IGNORE(iCache->CacheOtaInfoL(*iOTA,

					iFileToCache,aResponseHeaders))

            ResetValues();

            iParseObserver.ParsedStructureL(KOTAUpdateItemSelect);

			} 

		if(iIRID)

			{

            ResetValues();

            iParseObserver.ParsedStructureL(KIRIDSelect);

			}      

		if( iTimeStamp )

			{

			//session log response is obtained

			ResetValues();

			iParseObserver.ParsedStructureL(KSessionLogResponse);		

			}

		}

    IRLOG_DEBUG( "CIRXMLContentHandler::ParseXmlL - Exiting." );		

	}  

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

// CIRXMLContentHandler ::NewL

// Constructor

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

// 

EXPORT_C CIRXMLContentHandler* CIRXMLContentHandler ::NewL(MIRParserObserver 

	&aObserver,MIRCacheObserver &aCacheObserver)

    {    

    IRLOG_DEBUG( "CIRXMLContentHandler::NewL" );

    CIRXMLContentHandler* self = new (ELeave) CIRXMLContentHandler(aObserver,

    	aCacheObserver);    

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    IRLOG_DEBUG( "CIRXMLContentHandler::NewL - Exiting." );

    return(self); 

    }

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

// CIRXMLContentHandler ::CIRXMLContentHandler

// Default Constructor

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

//

CIRXMLContentHandler ::CIRXMLContentHandler(MIRParserObserver &aObserver,

	MIRCacheObserver &aCacheObserver):iParseObserver(aObserver),

	iCacheObserver(aCacheObserver)

    {

    IRLOG_DEBUG( "CIRXMLContentHandler::CIRXMLContentHandler" );

    }

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

// CIRXMLContentHandler ::ConstructL

// Two-Phase Constructor

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

//

void CIRXMLContentHandler ::ConstructL()

    {

    IRLOG_DEBUG( "CIRXMLContentHandler::ConstructL" );

    ResetValues();    

    TIRXMLElementFormat::OpenStringPoolL(iStringPool);

    iPtrCategory = new (ELeave) CArrayPtrFlat<CIRBrowseCatagoryItems>(

    	KLargeArraySize);

    iPtrChannel = new (ELeave) CArrayPtrFlat<CIRBrowseChannelItems>(

    	KLargeArraySize);

    iPtrPreset = new (ELeave) CArrayPtrFlat<CIRIsdsPreset>(KLargeArraySize);

    iParser = CParser::NewL(KFile,*this);

    iCache = CIRCacheMgmt::OpenL(iCacheObserver);

    iBufGetOperation = HBufC::NewL(0);

    iSize = HBufC::NewL(0);

    IRLOG_DEBUG( "CIRXMLContentHandler::ConstructL - Exiting." );

    }

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

// CIRXMLContentHandler::~CIRXMLContentHandler()

// Destructing the object

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

//

CIRXMLContentHandler::~CIRXMLContentHandler()

    {    

	IRLOG_DEBUG( "CIRXMLContentHandler::~CIRXMLContentHandler." );           

	TRAP_IGNORE(TIRXMLElementFormat::CloseStringPoolL(iStringPool))

	delete iParser;

	if(iUrlContentForAds)

		{

		delete iUrlContentForAds;

    	iUrlContentForAds = NULL;

		}

	if(iPtrPreset)

		{

	    iPtrPreset->ResetAndDestroy();    

		}

    delete iPtrPreset;

	if(iPtrCategory)

	    {

	    iPtrCategory->ResetAndDestroy();

		}       

    delete iPtrCategory;

	if(iPtrChannel)

	    {

	    iPtrChannel->ResetAndDestroy();

	    }

    delete iPtrChannel;

    delete iOTA;

    delete iAdv;

    if (iCache)

        {

        iCache->Close();

        }

    delete iPreset;

    delete iCategory;

    delete iChannel;

    delete iBufGetOperation;

    delete iSize;

	IRLOG_DEBUG( "CIRXMLContentHandler::~CIRXMLContentHandler - Exiting." );       

	}

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

// CIRXMLContentHandler::ResetValues

// Reseting the Values

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

//

void CIRXMLContentHandler::ResetValues()

	{

    IRLOG_DEBUG( "CIRXMLContentHandler::ResetValues" );

    iFlag = 1;

    iPresets = EFalse;

    iCategories=EFalse;

    iCat=EFalse;

    iChannels=EFalse;

    iChan=EFalse;

    iAdvertisement=EFalse;

    iOTAUpdate=EFalse;

    iIRID = EFalse;

    iTimeStamp = EFalse;

    iChannel = NULL;

    iCategory = NULL;

    iAdvts = EFalse;

	iAdvertisementTagFlag = EFalse;   

    IRLOG_DEBUG( "CIRXMLContentHandler::ResetValues - Exiting." );

	}    

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

// CIRXMLContentHandler:: OnStartDocumentL

// This method is a callback to indicate the start of the document

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

//   

void CIRXMLContentHandler:: OnStartDocumentL(const Xml::RDocumentParameters& 

	/*aDocParam*/ , TInt /*aErrorCode*/ )

    {                

    IRLOG_DEBUG( "CIRXMLContentHandler::OnStartDocumentL" );

    iEOD = KErrNone;

    }

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

// CIRXMLContentHandler::OnEndDocumentL

// This method is a callback to indicate the end of the document

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

// 

void CIRXMLContentHandler::OnEndDocumentL(TInt /*aErrorCode*/)

    {

    //No Implementation

    IRLOG_DEBUG( "CIRXMLContentHandler::OnEndDocumentL" );

	return;

    }

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

// CIRXMLContentHandler::OnStartElementL

// This method is a callback to indicate an element has been parsed. 

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

//

void CIRXMLContentHandler::OnStartElementL(const Xml::RTagInfo &aElement, 

			const Xml::RAttributeArray &aAttributes, TInt /*aErrorCode*/)

    {     

    IRLOG_DEBUG( "CIRXMLContentHandler::OnStartElementL" );     

    //Compare the element name to identify the type - //TO DO String Pool        

    TInt genre = (aElement.LocalName().DesC()).Compare(KGenre);

    TInt lang = (aElement.LocalName().DesC()).Compare(KLanguage);

    TInt country = (aElement.LocalName().DesC()).Compare(KCountry);

    TInt channel = (aElement.LocalName().DesC()).Compare(KChannel);

    TInt preset = (aElement.LocalName().DesC()).Compare(KPreset);

    TInt advertisements = (aElement.LocalName().DesC()).Compare(KAdvertisements);

    TInt ad = (aElement.LocalName().DesC()).Compare(KAd);

    TInt genres = (aElement.LocalName().DesC()).Compare(KCatGenre);

    TInt countries = (aElement.LocalName().DesC()).Compare(KCatCountry);

    TInt languages = (aElement.LocalName().DesC()).Compare(KCatLang);

    TInt channels = (aElement.LocalName().DesC()).Compare(KChannels);

    TInt presets = (aElement.LocalName().DesC()).Compare(KPresets);

    TInt IRID = (aElement.LocalName().DesC()).Compare(KIRID);

    TInt timestamp = (aElement.LocalName().DesC()).Compare(KTimeStamp);

    TInt irappversion = (aElement.LocalName().DesC()).Compare(KIRVersion);

    TInt adv = (aElement.LocalName().DesC()).Compare(KAdv);

    TInt banner = (aElement.LocalName().DesC()).Compare(KBanner);

    if(iUrlContentForAds)

		{

		delete(iUrlContentForAds);

		iUrlContentForAds = NULL;

		}

    TInt bufSize(KTen);

    iUrlContentForAds = HBufC::NewL( bufSize );//this is because, the OnContentL method gives chunck by chunck

	if(ad == 0)

        {   

    	//We want to take the first Ad only so if an Ad has already been created

    	//iChannel and iCategory will not be NULL hence the new Ad should not be added

    	if( !iChannel && !iCategory )

    	{

   			iChannel = CIRBrowseChannelItems::NewL();  

			iCategory = CIRBrowseCatagoryItems::NewL();  

    	}

		}

    if(advertisements == 0 )

        { 

        iAdvertisementTagFlag = ETrue;   

        }

     if(iAdvertisementTagFlag && banner == 0)

		{

		iAdvts = ETrue;

		}

    // Creates the instance of the class Browse by Genre/Language/Country

    if(iFlag)

        {

        if(genre == 0 || lang == 0 || country == 0)

			{

			//If there are ads then destroy the list and put the ads

			//as ads will the first in the xml

			if((iAdvts)  && (iCategory))

				{	

				iPtrCategory->ResetAndDestroy();

				iPtrCategory->AppendL(iCategory);

				iCategory = NULL;

				delete iChannel; 

				iChannel = NULL;

				iAdvts = EFalse;

				}

            iCategory = CIRBrowseCatagoryItems::NewL();

            iCat = ETrue;                

            }

        }

    if(iFlag)

        {

		// In case of browse by genres, country and lanaguages

         if(genres == 0 || countries == 0 || languages == 0)

            { 

            if(iAdvts == EFalse)

            	{

            	iPtrCategory->ResetAndDestroy();

            	}

            if(genres == 0)

				{

				iFileToCache.Zero();

				iFileToCache.Copy(KCatGenre);

                }

			if(countries == 0)                        

				{

				iFileToCache.Zero();

				iFileToCache.Copy(KCatCountry);

				}

			if(languages == 0)                        

				{      

				iFileToCache.Zero();

				iFileToCache.Copy(KCatLang);

				}

	        iCategories = ETrue;                           

            }

        }

    // Creates the instance of the class Channel

    if(channel == 0)

        {

        	//If there are ads then destroy the list and put the ads

			//as ads will the first in the xml

			if((iAdvts)   && (iChannel)) 

			{	iPtrChannel->AppendL(iChannel);

				iChannel = NULL;

				delete iCategory; 

				iCategory = NULL;

				iAdvts = EFalse;

			}

		iChannel = CIRBrowseChannelItems::NewL();    

		iChannels = ETrue;

		iBitrateCounter = 0;

        }

    if(channels == 0 )

        { 

        iPtrChannel->ResetAndDestroy();   

        iChan = ETrue;

		iChannelFlag = 0;    

        }

    // Creates the instance of the class for Preset Data

    if(preset == 0)

        {    

         iPreset = CIRIsdsPreset::NewL();    

         iPresets = ETrue;           

        }

    if(presets == 0)

        {     

        iPtrPreset->ResetAndDestroy();  

        iFlag = 0;

        }

    if(IRID == 0)

        {

        iIRID = ETrue;    

        }

    if(timestamp == 0)

        {

		//time stamp is obtained when session log is obtained in isds 

		iTimeStamp = ETrue;

        }

    if(irappversion == 0)

        {

		iOTA = CIROTAUpdate::NewL();

		iOTAUpdate = ETrue;

        }

    if(adv == 0)

        {

		iAdv = CIRAdvertisement::NewL();

		iAdvertisement = ETrue;

        }

    TBuf<KAttributeBufferSize> BufParam1;

    TBuf<KAttributeBufferSize> BufParam2; 

    // Parses the attributes and the value of the element

     TInt nAttributes = aAttributes.Count();

     for (TInt indexofattribute = 0; indexofattribute < nAttributes; 

     											++indexofattribute )

         {

		const RAttribute& attribute = aAttributes[indexofattribute];

		const RTagInfo& nameInfo = attribute.Attribute();

		//!Gets the elementId from the Pool for the specified attributename

		TIRXMLElement ATTelementId = TIRXMLElementFormat::GetElementIdL(

								(nameInfo.LocalName().DesC()),iStringPool); 

        HBufC* converted = CnvUtfConverter::ConvertToUnicodeFromUtf8L( attribute.Value().DesC() );

		CleanupStack::PushL(converted);

        switch(ATTelementId) 

			{

            case EGetOperation: 

				{

				delete iBufGetOperation;

				iBufGetOperation = NULL;

				iBufGetOperation = converted->Des().AllocL();

                }

                break;

            case EName:

				{

				//if name is parsed

				if(iCat)

					{                                                                    

					//if category

					iCategory->SetGetOperation(*iBufGetOperation);                                          

					BufParam1.Copy(*converted);                

					}

			   if(iChannels)

					{

				   //if channel

					iChannel->SetGetOperationL(*iBufGetOperation);

					iChannel->SetSize(*iSize);

					BufParam1.Copy(*converted);

					} 

				if(iPresets)

					{

					if((aElement.LocalName().DesC()) == KPreset)

						{

						//for preset

						iPreset->SetName(*converted);

						}                                

					BufParam1.Copy(*converted);

					}                        

                 }

                 break;    

            case EID:

                {

			    //getting id

                if(iCat)

				    {

				    //for category

				    iCategory->SetTextL(BufParam1,*converted);    

				    }

                if(iChannels)

				    {

				    //for channel

					BufParam2.Copy(*converted);          

				    }     

				if(iPresets)

					{

				    //for preset

					iPreset->SetGenreInfo(*converted,BufParam1);

					}  

				if(iIRID)

					{

				    //ir id

					iRID.Copy(*converted);

					}

                }

                break;

            case ESize: 

                {

                delete iSize;

			    iSize = NULL;

			    iSize = converted->Des().AllocL();

				if(iCat)

				    {

					iCategory->SetSize(*iSize);

					}                       

                }

                break;

              case EShortDesC:

                    {