/*
* Copyright (c) 2005 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:   CXcapRetrieval
*
*/




// INCLUDES
#include "XcapCache.h"
#include "XcapAppUsage.h"
#include "XcapDocument.h"
#include "XcapProtocol.h"
#include "XcapRetrieval.h"
#include "XcapUriParser.h"
#include "XdmXmlParser.h"
#include "XcapHttpReqGet.h"
#include "XcapHttpTransport.h"
#include "XcapOperationFactory.h"

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

// ---------------------------------------------------------
// C++ constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------
//
CXcapRetrieval::CXcapRetrieval( CXcapDocument& aParentDoc,
                                CXcapDocumentNode* aTargetNode,
                                CXcapOperationFactory& aOperationFactory ) :
                                CXcapHttpOperation( aParentDoc, aTargetNode, aOperationFactory ),
                                iCacheOperation( EFalse ),
                                iOperationType( aTargetNode == NULL ?
                                EXdmDocument : EXdmPartialDocument )                                  
    {
    }

// ---------------------------------------------------------
// CXcapRetrieval::NewL
//
// ---------------------------------------------------------
//
CXcapRetrieval* CXcapRetrieval::NewL( CXcapDocument& aParentDoc,
                                      CXcapDocumentNode* aTargetNode,
                                      CXcapOperationFactory& aOperationFactory )
    {
    CXcapRetrieval* self = new ( ELeave ) CXcapRetrieval( aParentDoc, aTargetNode, aOperationFactory );
    CleanupStack::PushL( self );
    self->BaseConstructL();
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// ---------------------------------------------------------
// CXcapRetrieval::ConstructL
//
// ---------------------------------------------------------
//
void CXcapRetrieval::ConstructL()
    {
#ifdef _DEBUG
    iOperationFactory.WriteToLog( _L8( "-> CXcapRetrieval::ConstructL" ) );  
#endif
    CXcapHttpReqGet* request = Transport().GetL( iTargetDoc.Name() );
    CleanupStack::PushL( request );
    User::LeaveIfError( iRequestQueue.Append( request ) );
    request->SetExpiryTimeL( NULL, KDefaultHttpRequestTimeout * 1000000 );
    CleanupStack::Pop();  //request
    if( iOperationType != EXdmDocument && iDocumentSubset != NULL )
        {
        iUriParser->SetDocumentSubset( iDocumentSubset );
        //Add namespace mappings
        User::LeaveIfError( iTargetDoc.ApplicationUsage().Validate(
                            *iDocumentSubset, iUriParser, ETrue ) );
        }
#ifdef _DEBUG
    iOperationFactory.WriteToLog( _L8( "<- CXcapRetrieval::ConstructL" ) );  
#endif
    }

// ---------------------------------------------------------
// CXcapRetrieval::ExecuteL
//
// ---------------------------------------------------------
//
void CXcapRetrieval::ExecuteL()
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( "CXcapRetrieval::ExecuteL()" ) );  
    #endif
    TPtrC8 eTag = iTargetDoc.ETag();
    if( eTag.Length() > 0 )
        {
        #ifdef _DEBUG
            iOperationFactory.WriteToLog( _L8( " Using ETag \"%S\" - Length: %d" ),
                                               &eTag, eTag.Length() );  
        #endif
        //iActiveRequest->SetHeaderL( KHttpHeaderIfNoneMatch, eTag );
        }
    TRAPD( error, iUriParser->ParseL( iActiveRequest->RequestUriL() ) );
    if( error == KErrNone )
        {
        TPtrC8 uri = iUriParser->DesC8();
        HBufC8* escape = CXcapHttpOperation::EscapeLC( uri );
        iActiveRequest->UpdateRequestUriL( escape->Des() );
        CleanupStack::PopAndDestroy();  //escape
        #ifdef _DEBUG
            iOperationFactory.WriteToLog( _L8( " New URI: %S" ), &uri );  
        #endif
        }
    }
        
// ---------------------------------------------------------
// CXcapRetrieval::OperationCompleteL
//
/* const TDesC8& aETag, 
   const TDesC& aDocumentName,
   const TDesC8& aRootLocation,
   const TDesC8& aResponseData*/
// ---------------------------------------------------------
//
void CXcapRetrieval::OperationCompleteL()
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( "CXcapRetrieval::OperationCompleteL()" ) );  
    #endif
    TInt generalErr = ReinterpretStatus( iRequestData->iHttpStatus );
    if( generalErr == KErrNone )
        {
        #ifdef _DEBUG
            iOperationFactory.WriteToLog( _L8( " No general errors found" ) );  
        #endif
        iCacheOperation ? HandleCacheOperationL() : HandleNetworkOperationL();
        }
    else
        {
        #ifdef _DEBUG
            iOperationFactory.WriteToLog( _L8( " General errors found - Status: %d  Error: %d" ),
                                                   iRequestData->iHttpStatus, generalErr );  
        #endif
        iCompleted = ETrue;
        iResult = generalErr;
        }
    }

// ---------------------------------------------------------
// CXcapRetrieval::HandleCacheOperationL
//
// ---------------------------------------------------------
//
void CXcapRetrieval::HandleCacheOperationL()
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( "CXcapRetrieval::HandleCacheOperationL() - Operation type: %d  Target node: %x" ),
                                           iOperationType, iDocumentSubset );  
    #endif
    TPtrC8 responseData = Descriptor( iRequestData->iResponseData );
    iOperationType == EXdmDocument && iDocumentSubset == NULL ? 
        iXmlParser->ParseDocumentL( &iTargetDoc, responseData ) :
        iXmlParser->ParseDocumentL( &iTargetDoc, responseData, iDocumentSubset );
    iCompleted = ETrue;
    }
    
// ---------------------------------------------------------
// CXcapRetrieval::HandleNetworkOperationL
//
// ---------------------------------------------------------
//
void CXcapRetrieval::HandleNetworkOperationL()
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( "CXcapRetrieval::HandleNetworkOperationL()" ) );  
    #endif
    TPtrC name = iTargetDoc.Name();
    TPtrC8 root = Transport().RootUri();
    switch( iRequestData->iHttpStatus )
        {
        case 200:           //ETag was stale
            {
            #ifdef _DEBUG
                iOperationFactory.WriteToLog( _L8( " Status 200 - ETag was stale" ) );  
            #endif
            TPtrC8 responseData = Descriptor( iRequestData->iResponseData );
            if( responseData.Length() <= 0 )
                break;
            if( iOperationType == EXdmDocument )
                {
                TPtrC8 eTag = Descriptor( iRequestData->iETag );
                //If the ETag has not changed, server should return
                //304 (Not modified), but just in case, let's check the 
                //ETag value, anyway.
                if( eTag.Length() > 0 && eTag.Compare( iTargetDoc.ETag() ) != 0 )
                    {
                    iTargetDoc.SetETag( eTag );
                    RXcapCache* cache = iTargetDoc.Protocol().Cache();
                    if( cache && !( iOptionFlags & KNoCache ) )
                        cache->Store( iTargetDoc.ETag(), name, root, responseData  );
                    }
                else
                    {
                    #ifdef _DEBUG
                        iOperationFactory.WriteToLog( _L8( " ETag values match, do not update cache" ) );  
                    #endif
                    }
                iXmlParser->ParseDocumentL( &iTargetDoc, responseData );
                }
            else if( iOperationType == EXdmPartialDocument )
                {
                #ifdef _DEBUG  
                    iOperationFactory.WriteToLog( _L8( " Parse a partial document" ) );  
                #endif
                //The target node must be emptied before inserting new content
                iDocumentSubset->SetEmptyNode( ETrue );
                iDocumentSubset->SetEmptyNode( EFalse );
                iXmlParser->ParseDocumentL( responseData, iDocumentSubset );
               	}
            iCompleted = ETrue;
            }
            break;
        case 304:
            {
            RXcapCache* cache = iTargetDoc.Protocol().Cache();
            if( cache )
                {
                #ifdef _DEBUG   //ETag is up to date - cache still valid
                    iOperationFactory.WriteToLog( _L8( " Status 304 - Cached version is valid" ) );  
                #endif
                TInt length = iTargetDoc.DataLength();
                __ASSERT_DEBUG( length > 0, User::Panic( _L( "CXcapRetrieval" ), 1 ) );
                delete iRequestData->iResponseData;
                iRequestData->iResponseData = NULL;
                iRequestData->iResponseData = HBufC8::NewL( length );
                TPtr8 desc( iRequestData->iResponseData->Des() );
                cache->FetchDocumentContent( desc, name, root );
                if( iOperationType == EXdmDocument && !iTargetDoc.DocumentRoot() )
                	{
                	#ifdef _DEBUG  
                    	iOperationFactory.WriteToLog( _L8( " No content => parse cached document" ) );  
                	#endif
					iXmlParser->ParseDocumentL( &iTargetDoc, desc );
                	}
               	else if( iOperationType == EXdmPartialDocument )
               		{
               		#ifdef _DEBUG  
                    	iOperationFactory.WriteToLog( _L8( " Parse a partial document" ) );  
                	#endif
					iXmlParser->ParseDocumentL( &iTargetDoc, desc, iDocumentSubset );
               		}
                }
            iCompleted = ETrue;
            }
            break;
        default:
            #ifdef _DEBUG
                iOperationFactory.WriteToLog( _L8( " Default case - Status: %d" ),
                                                   iRequestData->iHttpStatus );  
            #endif
            iCompleted = ETrue;
            break;
        }
    }
  
// ---------------------------------------------------------
// CXcapRetrieval::OperationFailedL
//
// ---------------------------------------------------------
//
void CXcapRetrieval::OperationFailedL()
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( "CXcapRetrieval::OperationFailedL() - Error: %d" ),
                                        iStatus.Int() );  
    #endif
    if( iStatus.Int() >= KErrNone )
        {
        TInt status = iActiveRequest->ResponseData()->iHttpStatus;
        TInt completion = iActiveRequest->ResponseData()->iCompletion;
        iResult = status < KErrNone || completion < KErrNone ? status : ReinterpretStatus( status );
        }
    else iResult = iStatus.Int();
    iCompleted = ETrue;
    }
    
// ---------------------------------------------------------
// CXcapRetrieval::Result
//
// ---------------------------------------------------------
//
TInt CXcapRetrieval::Result() const
    {
    return iRequestData->iCompletion;
    }

// ---------------------------------------------------------
// CXcapRetrieval::~CXcapRetrieval
//
// ---------------------------------------------------------
//
CXcapRetrieval::~CXcapRetrieval()
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( "CXcapRetrieval::~CXcapRetrieval()" ) );  
    #endif
    }

//  End of File