/*

* 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: CXcapDocument

*

*/

// INCLUDE FILES

#include <f32file.h>

#include <XdmErrors.h>

#include "XdmOperationFactory.h"

#include "XcapProtocol.h"

#include "XcapDocument.h"

#include "XcapAppUsage.h"

#include "XdmXmlParser.h"

#include "XdmNamespace.h"

#include "CommonDefines.h"

#include "XcapDocumentNode.h"

#include "XcapHttpRequest.h"

#include "XcapHttpOperation.h"

#include "XcapHttpTransport.h"

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

//

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

// CXcapDocument::CXcapDocument

// 

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

//

CXcapDocument::CXcapDocument( TXdmDocType aDocumentType,

                              const CXdmEngine& aXdmEngine,

                              const CXcapProtocol& aXcapProtocol ) :

                              CXdmDocument( CONST_CAST( CXdmEngine&, aXdmEngine ) ),

                              iDocumentType( aDocumentType ),

                              iXcapProtocol( CONST_CAST( CXcapProtocol&, aXcapProtocol ) )

    { 

    }

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

// CXcapDocument::NewL

// 

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

//

CXcapDocument* CXcapDocument::NewL( TXdmDocType aDocumentType,

                                    const TDesC& aDocumentName,

                                    const CXdmEngine& aXdmEngine,

                                    const CXcapProtocol& aXcapProtocol )

    {

    CXcapDocument* self = new ( ELeave ) CXcapDocument( aDocumentType, aXdmEngine, aXcapProtocol );

    CleanupStack::PushL( self );

    self->BaseConstructL( KXcapOperationFactory, aDocumentName );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CXcapDocument::NewL

// 

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

//

CXcapDocument* CXcapDocument::NewL( TXdmDocType aDocumentType,

                                    const TDesC8& aDocumentName,

                                    const CXdmEngine& aXdmEngine,

                                    const CXcapProtocol& aXcapProtocol )

    {

    CXcapDocument* self = new ( ELeave ) CXcapDocument( aDocumentType, aXdmEngine, aXcapProtocol );

    CleanupStack::PushL( self );

    self->ConstructL( aDocumentName );

    CleanupStack::Pop();

    return self;

    }

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

// CXcapDocument::ConstructL

// 

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

//

void CXcapDocument::ConstructL( const TDesC8& aDocumentName )

    {

    BaseConstructL( KXcapOperationFactory, aDocumentName );

    ConstructL();

    }

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

// CXcapDocument::ConstructL

// 

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

//

void CXcapDocument::ConstructL()

    {

    InstallAppUsageL();

    iErrorRoot = CXcapDocumentNode::NewL( iXdmEngine, iXcapProtocol );

    TPtrC8 root( iXcapProtocol.Transport().RootUri() );

    #ifdef _DEBUG

        HBufC8* buf = HBufC8::NewLC( iDocumentName->Des().Length() );

        buf->Des().Copy( iDocumentName->Des() );

        TPtr8 nameDesc( buf->Des() );

        iXcapProtocol.WriteToLog( _L8( "CXcapDocument::ConstructL()" ) );

        iXcapProtocol.WriteToLog( _L8( "  Root URI:   %S" ), &root );

        iXcapProtocol.WriteToLog( _L8( "  Document:   %S" ), &nameDesc );

        CleanupStack::PopAndDestroy();  //buf

    #endif

    RXcapCache* cache = iXcapProtocol.Cache();

    if( cache )

        UpdateDocumentInfoL( cache );

    else

        {

        #ifdef _DEBUG

            iXcapProtocol.WriteToLog( _L8( "  Cache disabled, no info for the document" ) );

        #endif

        }

    CActiveScheduler::Add( this );

    }

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

// CXcapDocument::~CXcapDocument

// 

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

//

CXcapDocument::~CXcapDocument()

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDocument::~CXcapDocument()" ) );

    #endif

    Cancel();

    delete iTempCopy;

    delete iEightBitName;

    delete iDocumentRoot;

    delete iErrorRoot;

    delete iAppUsage;

    iNamespaces.ResetAndDestroy();

    iNamespaces.Close();

    }

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

// CXcapDocument::ResetContents

// 

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

//

void CXcapDocument::ResetContents()

    {

    iOptions = 0;

    delete iDocumentRoot;

    iDocumentRoot = NULL;

    delete iErrorRoot;

    iErrorRoot = NULL;

    delete iTempCopy;

    iTempCopy = NULL;

    iNamespaces.ResetAndDestroy();

    }

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

// CXcapDocument::UpdateDocumentInfoL

// 

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

//

void CXcapDocument::UpdateDocumentInfoL( RXcapCache* aCacheClient )

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDocument::UpdateDocumentInfo()" ) );

    #endif

    iETagBuffer.Zero();

    TCacheEntryInfo cacheEntryInfo;

    TPtrC8 root( iXcapProtocol.Transport().RootUri() );

    TInt error = aCacheClient->FetchDocumentInfo( 

                 iETagBuffer, iDocumentName->Des(), root, cacheEntryInfo );    

    if( error == KErrNone )

        {

        iLastAccess = cacheEntryInfo.iLastAccess;

        iLastModification = cacheEntryInfo.iLastUpdate;

        iDataLength = cacheEntryInfo.iDataLength;

        #ifdef _DEBUG

            const TInt KDateTimeMaxSize = 100;

            TBuf8<KDateTimeMaxSize> printBuffer;

            TBuf<KDateTimeMaxSize> dateTimeBuffer;

            _LIT( KDateTimeFormat, "%D%M%Y%/0%1%/1%2%/2%3%/3 %:0%H%:1%T%:2%S");

            iLastModification.FormatL( dateTimeBuffer, KDateTimeFormat );

            printBuffer.Copy( dateTimeBuffer );

            iXcapProtocol.WriteToLog( _L8( "  ETag:        %S" ), &iETagBuffer );

            iXcapProtocol.WriteToLog( _L8( "  Size:        %d bytes" ), iDataLength );

            iXcapProtocol.WriteToLog( _L8( "  Time stamp:  %S" ), &printBuffer );

        #endif

        }

    else

        {

        #ifdef _DEBUG

            iXcapProtocol.WriteToLog( _L8( "  Cache read complete - Error: %d" ), error );

        #endif

        }

    }

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

// CXcapDocument::InstallAppUsageL

// 

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

//

void CXcapDocument::InstallAppUsageL()

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDocument::InstallAppUsageL()" ) );

    #endif  

    HBufC8* docName = NULL;

    iAppUsage = CXcapAppUsage::NewL( iXdmEngine, iDocumentType );

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDocument::InstallAppUsageL() type = %d" ), iDocumentType );

    #endif  

    TPtrC8 auid = iAppUsage->AUID();

    if( IsGlobalTree( auid ) )

        {

        docName = HBufC8::NewLC( auid.Length() + KGlobalDirName().Length() + 

                                 KXcapGlobalDocName().Length() );

        docName->Des().Copy( auid );

        docName->Des().Append( KGlobalDirName );

        docName->Des().Append( KXcapGlobalDocName );

        delete iDocumentName;

        iDocumentName = NULL;

        iDocumentName = HBufC::NewL( docName->Des().Length() );

        iDocumentName->Des().Copy( docName->Des() );

        CleanupStack::PopAndDestroy();  //docName

        }

    else

        {

        TPtrC8 user = iXcapProtocol.UserName();

        docName = HBufC8::NewLC( auid.Length() + user.Length() + 

                                 KUserDirName().Length() + 1 /*'/'*/ + 

                                 iDocumentName->Des().Length() );

        docName->Des().Copy( auid );

        docName->Des().Append( KUserDirName );

        docName->Des().Append( user );

        docName->Des().Append( KSlash );

        docName->Des().Append( iDocumentName->Des() );

        delete iDocumentName;

        iDocumentName = NULL;

        iDocumentName = HBufC::NewL( docName->Des().Length() );

        iDocumentName->Des().Copy( docName->Des() );

        CleanupStack::PopAndDestroy();  //docName

        }

    }

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

// CXcapDocument::IsGlobalTree

// 

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

//

TBool CXcapDocument::IsGlobalTree( const TDesC8& aAuid )

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDocument::IsGlobalTree()" ) );

    #endif

    TBool found = EFalse;

    //Update this array when necessary

    const TPtrC8 KGlobalTreeAuids[] = { TPtrC8( KXdmCapabilityUsageAUID ) };

    const TInt count = sizeof( KGlobalTreeAuids ) / sizeof( KGlobalTreeAuids[0] );

    for( TInt i = 0;!found && i < count;i++ )

        found = aAuid.Compare( KGlobalTreeAuids[i] ) == 0;

    return found;

    }

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

// CXcapDocument::CreateTempCopyL

// 

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

//

void CXcapDocument::CreateTempCopyL()

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDocument::CreateTempCopyL()" ) );

    #endif

    CXdmDocument* copy = iXdmEngine.CreateDocumentModelL( Name(), iDocumentType );

    iTempCopy = ( CXcapDocument* )copy;

    }

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

// CXcapDocument::TempCopyL

// 

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

//

EXPORT_C CXcapDocument* CXcapDocument::TempCopyL()

    {

    return CXcapDocument::NewL( iDocumentType, Name(), iXdmEngine, iXcapProtocol );

    }

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

// CXcapDocument::CreateRootL

// 

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

//

CXdmDocumentNode* CXcapDocument::CreateRootL()

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXdmDocument::CreateRootL()" ) );

    #endif

    delete iDocumentRoot;

    iDocumentRoot = NULL;

    iDocumentRoot = CXcapDocumentNode::NewL( iXdmEngine, iXcapProtocol );

    return iDocumentRoot;

    }

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

// CXcapDocument::AppendPathPartL

// 

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

//

void CXcapDocument::AppendPathPartL( const TDesC& aString )

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDocument::PathPartL()" ) );

    #endif

    if( iDocumentRoot != NULL )

        {

        CXdmDocumentNode* node = NULL;

        CXdmDocumentNode* parent = iDocumentRoot;

        while( parent->NextNode() != NULL )

            parent = parent->NextNode();

        node = CXcapDocumentNode::NewL( iXdmEngine, aString, iXcapProtocol, parent );

        parent->SetNextNode( node );

        }

    else iDocumentRoot = CXcapDocumentNode::NewL( iXdmEngine, aString, iXcapProtocol );

    }

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

// CXcapDocument::CurrentExtent

// 

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

//

CXdmDocumentNode* CXcapDocument::CurrentExtent() const

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXdmDocument::CurrentExtent()" ) );

    #endif

    CXdmDocumentNode* ret = NULL;

    if( iDocumentRoot != NULL )

        {

        CXdmDocumentNode* node = iDocumentRoot;

        while( node->NextNode() != NULL )

            node = node->NextNode();

        ret = node;

        }

    else

        {

        #ifdef _DEBUG

            iXcapProtocol.WriteToLog( _L8( " This document does not yet have a root, leave with KErrGeneral" ) );

        #endif

        User::Leave( KErrGeneral );

        }

    return ret;

    }

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

// CXcapDocument::DocumentRoot

// 

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

//

CXdmDocumentNode* CXcapDocument::DocumentRoot() const

    {

    return iDocumentRoot;

    }     

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

// CXcapDocument::ErrorRoot

// 

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

//

CXdmDocumentNode* CXcapDocument::ErrorRoot()

    {

    if( !iErrorRoot )

        {

        iErrorRoot = CXcapDocumentNode::NewL( iXdmEngine, iXcapProtocol );

        }

    return iErrorRoot;

    }

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

// CXcapDocument::ResetSubset

// 

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

//

EXPORT_C void CXcapDocument::ResetSubset()

    {

    CXdmDocument::ResetSubset();

    delete iDocumentRoot;

    iDocumentRoot = NULL;

    iOptions = 0;

    }

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

// CXcapDocument::ETag

// 

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

//

EXPORT_C TDesC8& CXcapDocument::ETag()

    {

    return iETagBuffer;

    }

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

// CXcapDocument::SetETag

// 

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

//     

EXPORT_C void CXcapDocument::SetETag( const TDesC8& aETagDesc )

    {

    iETagBuffer.Zero();

    iETagBuffer.Copy( aETagDesc );

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDocument::SetETag()" ) );

        iXcapProtocol.WriteToLog( _L8( "  New ETag: %S" ), &iETagBuffer );

    #endif

    }

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

// CXcapDocument::DataLength

// 

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

//

EXPORT_C TInt CXcapDocument::DataLength() const

    {

    return iDataLength;

    }

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

// CXcapDocument::ApplicationUsage

// 

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

//

EXPORT_C CXcapAppUsage& CXcapDocument::ApplicationUsage() const

    {

    return *iAppUsage;

    }

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

// CXcapDocument::Protocol

// 

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

//

EXPORT_C CXcapProtocol& CXcapDocument::Protocol() const

    {

    return iXcapProtocol;

    }

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

// CXcapDocument::RemoveData

// 

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

//

EXPORT_C void CXcapDocument::RemoveData( CXcapDocumentNode* aDocumentNode )

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDocument::RemoveData()" ) );

    #endif

    CXcapDocumentNode* parent = ( CXcapDocumentNode* )aDocumentNode->Parent();

    if( parent != NULL )

        parent->RemoveNode( aDocumentNode );

    }

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

// CXcapDocument::StartUpdateL

// 

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

//

void CXcapDocument::StartUpdateL()

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDocument::StartUpdateL()" ) );

    #endif

    TInt resolverError = 0;

    if( iXcapProtocol.IsSimRequestPending( resolverError ) )

        {

        #ifdef _DEBUG

            iXcapProtocol.WriteToLog( _L8( "  IMS Resolver pending => add to queue" ) );

        #endif

        iXcapProtocol.AppendNotifyeeL( this );

        }

    else

        {

        if( resolverError == KErrNone && !IsActive() && iChangeRequests.Count() > 0 )

            {

            iUpdateIndex = 0;

            iDocumentState = EXdmDocUpdating;

            iOperationCount = iChangeRequests.Count();

            ActivateOperationL();

            }

        else

            {

            #ifdef _DEBUG

                iXcapProtocol.WriteToLog( _L8(

                 "  Already active, no operations or IMS resolver failed => complete with error" ) );

            #endif

            TInt error = resolverError == KErrNone ? KErrNotReady : resolverError; 

            User::RequestComplete( iClientStatus, error );

            }

        }

    }

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

// CXcapDocument::StartInternalL

// 

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

//

void CXcapDocument::StartInternalL( TRequestStatus& aStatus )

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDocument::StartInternalL()" ) );

    #endif

    aStatus = KRequestPending;

    iClientStatus = &aStatus;

    StartUpdateL();

    }

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