/*

* 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:  The implementation for presentation elements.

*

*/

#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;

    // if XML Parsing error occurred, maybe iChannel wasn't deleted 

    if ( iChannel )

        {

        delete iChannel;

        }

    iChannel = NULL;

    // if XML Parsing error occurred, maybe iCategory wasn't deleted     

    if ( iCategory )

        {

        delete iCategory;

        } 

    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->SetNameL( *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->SetGenreInfoL( *converted, BufParam1 );

                    }  

                if( iIRID)

                    {

                      //ir id

                    iRID.Copy( *converted );

                    }

                }

                break;

            case ESize: 

                {