/*

* 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 <escapeutils.h>

#include <tinternetdate.h>

#include <utf.h>

#include "irbrowsecatagoryitems.h"

#include "irbrowsechannelitems.h"

#include "ircachemgmt.h"

#include "irdataprovider.h"

#include "irdataproviderconstants.h"

#include "irdebug.h"

#include "irhttprequestdata.h"

#include "irotaupdate.h"

#include "irsessionlogger.h"

#include "irsettings.h"

#include "irxmlcontenthandler.h"

#include "isdsclientdll.h"

#include "misdsresponseobserver.h"

#include "irisdspreset.h"

const TInt KChannelidMaxLength = 25;

const TInt KTwo = 2;

/*const TInt KDays = 7;

const TInt KHour = 24;

const TInt KMinute = 60;

const TInt KSecond = 60;*/

const TInt KUrlPassMaxLength = 124;

const TInt KChidMaxLength = 6;

const TInt KCopyOfTimeMaxLength = 32;

const TInt KMaxLength = 256;

const TInt KFour = 4;

_LIT(KBrowseUrl,"/do/directory/browse?type=");

_LIT(KChannelnSearchUrl,"/do/directory/browse?type=channels&searchText=");

_LIT(KGetIRIDUrl,"/do/service/getIrid");

_LIT(KGenres,"genres");

_LIT(KLanguages,"languages");

_LIT(KCountries,"countries");

_LIT(KHotpicks,"hotpicks");

_LIT(KOtaUpdateUrl,"/do/service/otaUpdate?irid=");

_LIT(KLogUsageUrl,"/do/service/logUsage");

_LIT(KSearchUrl,"&start=1&size=50");

_LIT(KMultiSearchUrl, "/do/directory/browse?type=channels&genreID=%S&countryID=%S&languageID=%S&searchText=");

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

// CIRIsdsClient::NewL(MIsdsResponseObserver& aobserver)

// Used by UI to create instance of CIRIsdsClient.

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

//

EXPORT_C CIRIsdsClient* CIRIsdsClient::NewL( MIsdsResponseObserver& aobserver,

    const TDesC& aISDSBaseUrl )

    {

    IRLOG_DEBUG( "CIRIsdsClient::NewL - Entering" );

    CIRIsdsClient* self = CIRIsdsClient::NewLC( aobserver, aISDSBaseUrl );

    CleanupStack::Pop( self );

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

    return self;

    }

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

// CIRIsdsClient::NewLC(MIsdsResponseObserver& aobserver)

// Creates instance of CIRIsdsClient.

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

//

CIRIsdsClient* CIRIsdsClient::NewLC( MIsdsResponseObserver& aobserver,

                                     const TDesC& aISDSBaseUrl )

    {

    IRLOG_DEBUG( "CIRIsdsClient::NewLC - Entering" );

    CIRIsdsClient* self = new ( ELeave ) CIRIsdsClient( aobserver );

    CleanupStack::PushL( self );

    self->ConstructL( aISDSBaseUrl );

    IRLOG_DEBUG( "CIRIsdsClient::NewLC - Exiting." );

    return self;

    }

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

// CIRIsdsClient::ConstructL()

// Symbian two phased constructor

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

//

void CIRIsdsClient::ConstructL( const TDesC& aISDSBaseUrl )

    {

    //!Construsting the DataproviderDLL instance

    IRLOG_DEBUG( "IRIsdsClient::ConstructL - Entering" );

    iSettings = CIRSettings::OpenL();

    iISDSBaseUrl = aISDSBaseUrl.AllocL();

    //Base URL required to browse through the category

    iCatgoryURL.Zero();

    iCatgoryURL.Copy( *iISDSBaseUrl );

    iCatgoryURL.Append( KBrowseUrl );

    //Base URL required to search isds 

    iSearchURL.Zero();

    iSearchURL.Copy( *iISDSBaseUrl );

    iSearchURL.Append( KChannelnSearchUrl );

    //Base URL required to get IRID

    iGetIridUrl.Zero();

    iGetIridUrl.Copy( *iISDSBaseUrl );

    iGetIridUrl.Append( KGetIRIDUrl );

    //creates DataProvider

    iDataProvider = CIRDataProvider::NewL( *this );

    //creates XML Parser

    iXmlReader = CIRXMLContentHandler::NewL( *this, *this );

    //creates Cache manager

    iCache = CIRCacheMgmt::OpenL( *this );

    iCache->AddObserverL( this );

    //Session Log

    iBrowseReport = CIRReportGenerator::OpenL();

    // Retrive the current language and set it as an Accept Language

    TLanguage currentLanguage = User::Language();

    iShortLanguageCode = IRLanguageMapper::MapLanguage( currentLanguage );

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

    }

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

// CIRIsdsClient::CIRIsdsClient(MIsdsResponseObserver& aobserver)

// Default constructor

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

//

CIRIsdsClient::CIRIsdsClient( MIsdsResponseObserver& aobserver )

 : iIsdsResponseObserver( aobserver )

    {

    IRLOG_DEBUG( "CIRIsdsClient::CIRIsdsClient" );

    //No implementation

    }

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

// CIRIsdsClient::~CIRIsdsClient()

// Destructor

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

//

CIRIsdsClient::~CIRIsdsClient()

    {

    IRLOG_DEBUG( "CIRIsdsClient::~CIRIsdsClient - Entering" );

    delete iDataProvider;

    delete iXmlReader;

    if ( iSendPreset )

        {

        iSendPreset->ResetAndDestroy();

        }

    delete iSendPreset;

    if ( iCache )

        {

        iCache->RemoveObserver( this );

        iCache->Close();

        }

    if ( iSettings )

        {

        iSettings->Close();

        }

    delete iISDSBaseUrl;

    if ( iBrowseReport )

        {

        iBrowseReport->Close();

        }

    if ( iTempRequestObject )

        {

        delete iTempRequestObject;

        iTempRequestObject = NULL;

        }

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

    }

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

// CIRIsdsClient::IRIsdsIsCategoryCachedL

// Destructor

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

//

EXPORT_C TBool CIRIsdsClient::IRIsdsIsCategoryCachedL(

             TIRIsdsclientInterfaceIDs aISDSClientRequest)

    { 

    iForceGet=EFalse;  

    TInt res = 0;

    iCacheReqMade = EFalse;

    switch( aISDSClientRequest )

        {

            //When genre data is requested by user

        case EGenre:

            {

            //set the request type for subsiquent Use           

            iCachePath.Zero();

            iCachePath.Copy( KGenres );            

            iCache->CheckCacheL( 0, KGenres, iForceGet, res );       

            }

        break;

        //When Language data is requested by user                       

        case ELanguages:

            {

            iCachePath.Zero();

            iCachePath.Copy( KLanguages );            

            iCache->CheckCacheL( 0, KLanguages, iForceGet, res );          

            }

        break;

        //When Country data is requested by user                                                    

        case  ECountries:

            {

            iCachePath.Zero();

            iCachePath.Copy( KCountries );          

            iCache->CheckCacheL( 0, KCountries, iForceGet, res );          

            }

        break;

            //When hotpics data is requested by user                                                        

        case  Ehotpicks:

            {

            //set the request type for subsiquent Use            

            iCachePath.Zero();

            iCachePath.Copy( KHotpicks );

            iCache->CheckCacheL( 1, KHotpicks, iForceGet, res );

            }

            break;   

        default:

            break;    

    }

    if ( res == CIRCacheMgmt::ECacheUseable )

        {

        return ETrue;

        }

    return EFalse; 

    }

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

// void CIRIsdsClientInteface(TIRIsdsclientInterfaceIDs aISDSClientRequest)

// Called by UI to make request to ISDS for catogories

// @param :ENUM value depending on catogory which user wants to explore

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

//

EXPORT_C TBool CIRIsdsClient::IRIsdsClientIntefaceL(

                                TIRIsdsclientInterfaceIDs aISDSClientRequest )

    {

    //cancels any pending request

    IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Entering" );

    CIRHttpRequestData * requestData = new ( ELeave ) CIRHttpRequestData;

    CleanupStack::PushL( requestData );

    requestData->iAcceptLanguage.Copy( iShortLanguageCode );

    //Sets the Htpp method to GET

    requestData->iMethod = EIRHttpGET;

    //check for valid cache

    iForceGet = EFalse;

    TInt res = 0;

    switch ( aISDSClientRequest )

        {

        //When genre data is requested by user

        case EGenre:

            {

            //set the request type for subsiquent Use

            iRequestType = 0;

            iDataFrom = EFalse;

            iCachePath.Zero();

            iCachePath.Copy( KGenres );

            iCacheReqMade = ETrue;

            iCache->CheckCacheL( 0, KGenres, iForceGet, res );

            if ( res == 0 )//if cache is not available

                {

                requestData->iUri.Copy( iCatgoryURL );

                requestData->iUri.Append( KGenres );

                iConditonalGet = EFalse;

                //issues request for Genre data

                IRHttpIssueRequestL( *requestData );

                iBrowseUrl.Zero();

                iBrowseUrl.Copy( requestData->iUri );

                iBrowseReport->BrowseUrl( iBrowseUrl, 0 );

                iDataFrom = ETrue;

                }

            if ( res == -1 )//i cache is stale

                {

                iConditonalGet = ETrue;

                requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

                requestData->isIfModifiedSet = ETrue;

                requestData->iUri.Copy( iCatgoryURL );

                requestData->iUri.Append( KGenres );

                IRHttpIssueRequestL( *requestData );

                iBrowseUrl.Zero();

                iBrowseUrl.Copy( requestData->iUri );

                iBrowseReport->BrowseUrl( iBrowseUrl, 0 );

                iDataFrom = ETrue;

                }

            if ( res == 1 )

                {

                requestData->iUri.Copy( iCatgoryURL );

                requestData->iUri.Append( KGenres );

                iBrowseUrl.Zero();

                iBrowseUrl.Copy( requestData->iUri );

                iBrowseReport->BrowseUrl( iBrowseUrl, 0 );

                }

            }

            break;

            //When Language data is requested by user

        case ELanguages:

            {

            //set the request type for subsiquent Use

            iRequestType = 0;

            iDataFrom = EFalse;

            iCachePath.Zero();

            iCachePath.Copy( KLanguages );

            iCacheReqMade = ETrue;

            iCache->CheckCacheL( 0, KLanguages, iForceGet, res );

            if ( res == 0 )//if cache is not available

                {

                requestData->iUri.Copy( iCatgoryURL );

                requestData->iUri.Append( KLanguages );

                //Isuues request for language data

                IRHttpIssueRequestL( *requestData );

                iConditonalGet = EFalse;

                iBrowseUrl.Zero();

                iBrowseUrl.Copy( requestData->iUri );

                iBrowseReport->BrowseUrl( iBrowseUrl, 0 );

                iDataFrom = ETrue;

                }

            if ( res == -1 )//i cache is stale

                {

                iConditonalGet = ETrue;

                requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

                requestData->isIfModifiedSet = ETrue;

                requestData->iUri.Copy( iCatgoryURL );

                requestData->iUri.Append( KLanguages );

                //Isuues request for language data if cache isnt valid

                IRHttpIssueRequestL( *requestData );

                iBrowseUrl.Zero();

                iBrowseUrl.Copy( requestData->iUri );

                iBrowseReport->BrowseUrl( iBrowseUrl, 0 );

                iDataFrom = ETrue;

                }

            if ( res == 1 )

                {

                requestData->iUri.Copy( iCatgoryURL );

                requestData->iUri.Append( KLanguages );

                iBrowseUrl.Zero();

                iBrowseUrl.Copy( requestData->iUri );

                iBrowseReport->BrowseUrl( iBrowseUrl, 0 );

                }

            }

            break;

            //When Country data is requested by user

        case ECountries:

            {

            //set the request type for subsiquent Use

            iRequestType = 0;

            iDataFrom = EFalse;

            iCachePath.Zero();

            iCachePath.Copy( KCountries );

            iCacheReqMade = ETrue;

            iCache->CheckCacheL( 0, KCountries, iForceGet, res );

            if ( res == 0 )//if cache is not available

                {

                requestData->iUri.Copy( iCatgoryURL );

                requestData->iUri.Append( KCountries );

                //Isuues request for country data

                IRHttpIssueRequestL( *requestData );

                iConditonalGet = EFalse;

                iBrowseUrl.Zero();

                iBrowseUrl.Copy( requestData->iUri );

                iBrowseReport->BrowseUrl( iBrowseUrl, 0 );

                iDataFrom = ETrue;

                }

            if ( res == -1 )//i cache is stale

                {

                iConditonalGet = ETrue;

                requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

                requestData->isIfModifiedSet = ETrue;

                requestData->iUri.Copy( iCatgoryURL );

                requestData->iUri.Append( KCountries );

                //Isuues request for country data if cache isnt valid

                IRHttpIssueRequestL( *requestData );

                iBrowseUrl.Zero();

                iBrowseUrl.Copy( requestData->iUri );

                iBrowseReport->BrowseUrl( iBrowseUrl, 0 );

                iDataFrom = ETrue;

                }

            if ( res == 1 )

                {

                requestData->iUri.Copy( iCatgoryURL );

                requestData->iUri.Append( KCountries );

                iBrowseUrl.Zero();

                iBrowseUrl.Copy( requestData->iUri );

                iBrowseReport->BrowseUrl( iBrowseUrl, 0 );

                }

            }

            break;

            //When hotpics data is requested by user

        case Ehotpicks:

            {

            //set the request type for subsiquent Use

            iRequestType = 1;

            iCacheReqMade = ETrue;

            iCache->CheckCacheL( 1, KHotpicks, iForceGet, res );

            iCachePath.Zero();

            iCachePath.Copy( KHotpicks );

            iDataFrom = EFalse;

            if ( res == 0 )//if cache is not available

                {

                requestData->iUri.Copy( iCatgoryURL );

                requestData->iUri.Append( KHotpicks );

                //Isuues request for hotpics data

                IRHttpIssueRequestL( *requestData );

                iConditonalGet = EFalse;

                iBrowseUrl.Zero();

                iBrowseUrl.Copy( requestData->iUri );

                iBrowseReport->BrowseUrl( iBrowseUrl, 0 );

                iDataFrom = ETrue;

                }

            if ( res == -1 )//i cache is stale

                {

                iConditonalGet = ETrue;

                requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

                requestData->isIfModifiedSet = ETrue;

                requestData->iUri.Copy( iCatgoryURL );

                requestData->iUri.Append( KHotpicks );

                //Isuues request for hotpics data if cache isnt valid

                IRHttpIssueRequestL( *requestData );

                iBrowseUrl.Zero();

                iBrowseUrl.Copy( requestData->iUri );

                iBrowseReport->BrowseUrl( iBrowseUrl, 0 );

                iDataFrom = ETrue;

                }

            if ( res == 1 )

                {

                requestData->iUri.Copy( iCatgoryURL );

                requestData->iUri.Append( KHotpicks );

                iBrowseUrl.Zero();

                iBrowseUrl.Copy( requestData->iUri );

                iBrowseReport->BrowseUrl( iBrowseUrl, 0 );

                }

            }

            break;

        }

    CleanupStack::PopAndDestroy( requestData );

    IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Exiting." );

    return iDataFrom;

    }//end of function

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

// CIRIsdsClient::GetDataProvider

// 

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

//

EXPORT_C CIRDataProvider* CIRIsdsClient::GetDataProvider()

    {

    IRLOG_DEBUG( "CIRIsdsClient::GetDataProvider" );

    return iDataProvider;

    }

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

// void IRHttpContentNotChanged()

// this is call back funtion called by Dataprovider in case 

// HTTP content isnt changed by ISDS 

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

//

void CIRIsdsClient::IRHttpResponseCodeReceived( TInt aResponseCode,

                CIRHttpResponseData& aResponseHeaders )

    {

    IRLOG_INFO2( "CIRIsdsClient::IRHttpResponseCodeReceived (%d)", aResponseCode );

    TInt res = KErrNotFound;

    switch ( aResponseCode )

        {

        case KNotFound://404

            {

            //make channel user defined.

            if ( iSyncRequest )

                {

                iSyncRequest = EFalse;

                //make the preset user-defined

                TRAP_IGNORE(iIsdsResponseObserver.IsdsPresetRemovedL(

                                                    iPresetToBeSynced))

            }

            /*if(iOtaReqFrom)

             {

             TRAP_IGNORE(PurgeOtaInfoL())

             }*/

            }

            break;

        case KNotModified://304

            {

            if ( iConditonalGet )

                {

                //update the trust period 

                //no problem if it leaves

                TRAP_IGNORE( iCache->UpdateTrustPeriodL( iRequestType,iCachePath,

                                                    aResponseHeaders ) )

                //do a forced get because the data is notmodifed in isds and 

                //trustable

                iForceGet = ETrue;

                iCacheReqMade = ETrue;

                TRAP_IGNORE( iCache->CheckCacheL( iRequestType,iCachePath,

                                                    iForceGet,res ) )

                }

            /*if(iOtaReqFrom)

             {

             TRAP_IGNORE(PurgeOtaInfoL())