/*

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

*

*/

// INCLUDE FILES

#include <utf.h>

#include <f32file.h>

#include "XcapAppUsageDef.h"

#include "XdmProtocol.h"

#include "XcapDocument.h"

#include "XcapProtocol.h"

#include "XcapAppUsage.h"

#include "XcapRetrieval.h"

#include "XcapDirectory.h"

#include "XdmXmlParser.h"

#include "XcapHttpReqGet.h"

#include "XdmDocumentNode.h"

#include "XdmNodeAttribute.h"

#include "XcapHttpTransport.h"

#include "XdmOperationFactory.h"

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

// CXcapDirectory::CXcapDirectory

// 

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

//

CXcapDirectory::CXcapDirectory( CXdmDocument*& aDirectoryDoc,

                                CXdmEngine& aXdmEngine,

                                CXcapProtocol& aXcapProtocol ) :

                                CXdmDirectory( aXdmEngine ),

                                iDirectoryDoc( ( CXcapDocument* )aDirectoryDoc ),

                                iXcapProtocol( aXcapProtocol )                                             

    { 

    }

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

// CXcapDirectory::NewL

// 

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

//

CXcapDirectory* CXcapDirectory::NewL( const TDesC& aAUID,

                                      CXdmEngine& aXdmEngine,

                                      CXdmDocument*& aDirectoryDoc,

                                      CXcapProtocol& aXcapProtocol )

    {

    CXcapDirectory* self = new ( ELeave ) CXcapDirectory( aDirectoryDoc, aXdmEngine, aXcapProtocol );

    CleanupStack::PushL( self );

    self->ConstructL( aAUID );

    CleanupStack::Pop();

    return self;

    }

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

// CXcapDirectory::~CXcapDirectory

// 

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

//

CXcapDirectory::~CXcapDirectory()

    {

    #ifdef _DEBUG

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

    #endif

    Cancel();

    delete iAUID;

    delete iDirectoryDoc;

    delete iHttpRetrieval;

    iUpdateList.Close();

    iDocumentList.Close();

    }

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

// CXcapDirectory::ConstructL

// 

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

//

void CXcapDirectory::ConstructL( const TDesC& aAUID )

    {

    if( aAUID.Length() > 0 )

        {

        _LIT( KNodePath,    "xcap-directory/folder" );

        iAUID = HBufC::NewL( aAUID.Length() );

        iAUID->Des().Copy( aAUID );

        CXdmDocumentNode* node = iDirectoryDoc->DocumentSubsetL( KNodePath );

        CleanupStack::PushL( node );

        CXdmNodeAttribute* auid = node->CreateAttributeL( KAuidAttribute );

        CleanupStack::PushL( auid );

        auid->SetAttributeValueL( aAUID );

        iDirectoryDoc->FetchDataL( node );

        //Set the option that prohibits caching

        iDirectoryDoc->SetOption( KXdmOption3 );

        CleanupStack::Pop( 2 );  //auid, node

        }

    else iDirectoryDoc->FetchDataL();

    CActiveScheduler::Add( this );

    }

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

// CXcapDirectory::StartUpdateL

// 

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

//

void CXcapDirectory::StartUpdateL()

    {

    #ifdef _DEBUG

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

    #endif

    switch( iUpdatePhase )

        {

        case EDirPhaseIdle:

            User::RequestComplete( iClientStatus, KErrArgument );

            break;

        case EUpdateDocumentList:

            HandleDocumentListRequestL();

            break;

        case ERefreshDocuments:

            HandleRefreshRequestL();

            break;

        default:

            break;

        } 

    }

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

// CXcapDirectory::SaveRequestData

// 

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

//

void CXcapDirectory::SaveRequestData( TDirUpdatePhase aUpdatePhase,

                                      TRequestStatus& aClientStatus )

    {

    iUpdatePhase = aUpdatePhase;

    iClientStatus = &aClientStatus;

    }

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

// CXcapDirectory::HandleDocumentListRequestL

// 

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

//

void CXcapDirectory::HandleDocumentListRequestL()

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDirectory::HandleDocumentListRequestL()" ) );

    #endif

    if( !IsActive() )

        {

        CXcapDocument* doc = ( CXcapDocument* )iDirectoryDoc;

        doc->StartInternalL( iStatus );

        iUpdatePhase = EUpdateDocumentList;

        SetActive();

        }

    }

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

// CXcapDirectory::HandleRefreshRequestL

// 

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

//

void CXcapDirectory::HandleRefreshRequestL()

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDirectory::HandleRefreshRequestL()" ) );

    #endif

    if( iUpdatePhase == EUpdateDocumentList )

        {

        if( iUpdateList.Count() > 0 )

            {

            iUpdateIndex = -1;

            iHttpRetrieval = iXcapProtocol.Transport().GetL( TPtrC() );

            UpdateNextDocumentL();

            iUpdatePhase = ERefreshDocuments;

            }

        else

            {

            #ifdef _DEBUG

                iXcapProtocol.WriteToLog( _L8( "  All documents are up to date" ) );

            #endif

            User::RequestComplete( iClientStatus, KErrNone );

            }

        }

    else

        {

        #ifdef _DEBUG

            iXcapProtocol.WriteToLog( _L8( "  Wrong state [%d]" ), iUpdatePhase );

        #endif

        User::RequestComplete( iClientStatus, KErrNotReady );

        }

    }

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

// CXcapDirectory::UpdateNextDocumentL

// 

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

//

void CXcapDirectory::UpdateNextDocumentL()

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDirectory::UpdateNextDocumentL()" ) );

    #endif

    iUpdateIndex++;

    if( iUpdateIndex < iUpdateList.Count() )

        {

        CXdmDocumentNode* node = iUpdateList[iUpdateIndex];

        #ifdef _DEBUG

            iXcapProtocol.WriteToLog( _L8( "  Index: %d  Document: %x" ), iUpdateIndex, node );

        #endif

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

        TPtrC docUri( ExtractDocumentUriL( root, node ) );

        HBufC* uri = HBufC::NewLC( root.Length() + docUri.Length() );

        uri->Des().Copy( root );

        uri->Des().Append( docUri );

        iHttpRetrieval->ResetUriL( uri->Des() );

        iHttpRetrieval->SetExpiryTimeL( NULL, KDefaultHttpRequestTimeout * 1000000 );

        iHttpRetrieval->DispatchRequestL( iStatus );

        CleanupStack::PopAndDestroy();  //uri

        SetActive();

        }

    else

        {

        #ifdef _DEBUG

            iXcapProtocol.WriteToLog( _L8( "  Directory sync complete" ) );

        #endif

        User::RequestComplete( iClientStatus, KErrNone );

        }

    }

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

// CXcapDirectory::RunL()

// 

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

//

void CXcapDirectory::RunL()

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDirectory::RunL() - Request: %d" ), iStatus.Int() );

    #endif

    if( iStatus == KErrNone )

        {

        switch( iUpdatePhase )

            {

            case EUpdateDocumentList:

                {

                iDocumentCount = iDirectoryDoc->Find( KDirectoryEntry, iDocumentList );

                if( iDocumentCount > 0 )

                    {

                    TInt index = 0;

                    while( index < iDocumentCount )

                        {

                        TBool uptodate = CheckLocalCopyL( iDocumentList[index] );

                        #ifdef _DEBUG

                            iXcapProtocol.WriteToLog( _L8( "  Cache: %d" ), uptodate );

                        #endif

                        if( !uptodate )

                            User::LeaveIfError( iUpdateList.Append( iDocumentList[index] ) );

                        index++;

                        }

                    }

                User::RequestComplete( iClientStatus, iStatus.Int() );

                }

                break;

            case ERefreshDocuments:

                {

                CXdmDocumentNode* node = iUpdateList[iUpdateIndex];

                #ifdef _DEBUG

                    iXcapProtocol.WriteToLog( _L8( "  Index:    %d" ), iUpdateIndex );

                    iXcapProtocol.WriteToLog( _L8( "  Document: %x" ), node );

                    iXcapProtocol.WriteToLog( _L8( "  Error:    %d" ), iStatus.Int() );

                #endif

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

                TPtrC docName = ExtractDocumentUriL( root, node );

                TXdmCompletionData* data = iHttpRetrieval->ResponseData();

                TPtrC8 responseData( data->iResponseData->Des() );

                TPtrC8 eTag( data->iETag->Des() );

                RXcapCache* cache = iXcapProtocol.Cache();

                cache->Store( eTag, docName, root, responseData  );

                iHttpRetrieval->ReleaseResponseData();

                UpdateNextDocumentL();

                }

                break;

            default:

                #ifdef _DEBUG

                    iXcapProtocol.WriteToLog( _L8( "  Default case, unknown state %d - Status: %d" ),

                                               iUpdatePhase, iStatus.Int() );

                #endif

                if( iClientStatus != NULL )

                    User::RequestComplete( iClientStatus, KErrUnknown );  

                break;

            }   

        }

    else

        {

        #ifdef _DEBUG

            iXcapProtocol.WriteToLog( _L8( "  Operation failed with %d" ), iStatus.Int() );

        #endif

        User::RequestComplete( iClientStatus, iStatus.Int() );

        }

    }

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

// CXcapDirectory::CheckLocalCopyL

// 

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

//

TBool CXcapDirectory::CheckLocalCopyL( const CXdmDocumentNode* aDocumentNode )

    {

    /*#ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDirectory::CheckLocalCopyL()" ) );

    #endif*/

    TBool ret = EFalse;

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

    TPtrC docName = ExtractDocumentUriL( root, aDocumentNode );

    TPtrC etag( aDocumentNode->Attribute( KDocumentETag )->AttributeValue() );

    HBufC8* etag8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( etag );

    CleanupStack::PushL( etag8 );

    RXcapCache* cache = iXcapProtocol.Cache();

    ret = cache != NULL ? cache->IsCurrent( etag8->Des(), docName, root ) == KErrNone : ETrue;

    CleanupStack::PopAndDestroy();  //etag8

    return ret;

    }

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

// CXcapDirectory::ExtractDocumentUriL

// 

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

//

TPtrC CXcapDirectory::ExtractDocumentUriL( const TDesC8& aRootUri,

                                           const CXdmDocumentNode* aDocumentNode )

    {

    /*#ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDirectory::ExtractDocumentUri()" ) );

    #endif*/

    const TUint8 KHttpHostSeparator = 47;

    _LIT8( KHttpDoubleHostSeparator,  "//" );

    TPtrC uri( aDocumentNode->Attribute( KDocumentUri )->AttributeValue() );

    if( uri[0] == KHttpHostSeparator ) //Relative URI

        return uri;

    else

        {

        TInt index = aRootUri.Find( KHttpDoubleHostSeparator );

        TPtrC8 root( aRootUri.Right( aRootUri.Length() - index - 2 ) );

        HBufC8* uri8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( uri );

        CleanupStack::PushL( uri8 );

        TPtr8 desc( uri8->Des() );

        index = desc.Find( root );

        CleanupStack::PopAndDestroy();  //uri8

        return index >= 0 ? uri.Right( uri.Length() - root.Length() - index ) : TPtrC();

        }

    }

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

// CXcapDirectory::DocumentCount

// 

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

//

TInt CXcapDirectory::DocumentCount()

    {

    return iDocumentCount;

    }

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

// CXcapDirectory::DocumentType

// 

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

//

TXdmDocType CXcapDirectory::DocumentTypeL( TInt aIndex ) const

    {

    TXdmDocType type = EXdmDocGeneral;

    if( iUpdatePhase <= EDirPhaseIdle )

        User::Leave( KErrNotReady );

    else if( iDocumentCount > 0 && ( aIndex >= 0 && aIndex < iDocumentCount ) )

        type = FindAUID( *iDocumentList[aIndex] );

    return type;

    } 

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

// CXcapDirectory::FindAUID

// 

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

//

TXdmDocType CXcapDirectory::FindAUID( const CXdmDocumentNode& aEntryNode ) const

    {

    TXdmDocType documentType = EXdmDocGeneral;

    HBufC8* buf = aEntryNode.Attribute( KDocumentUri )->EightBitValueLC();

    if( buf )

        {

        TPtrC8 uri( buf->Des() );

        if( uri.Find( KXdmCapabilityUsageAUID ) >= 0 )

            documentType = EXdmCapabilities;

        else if( uri.Find( KXdmPocUserAccessUsageAUID ) >= 0 )

            documentType = EXdmPoCUserAccessPolicy;

        else if( uri.Find( KXdmPocGroupUsageAUID ) >= 0 )

            documentType = EXdmPoCGroup;

        else if( uri.Find( KXdmResourceListsUsageAUID ) >= 0 )

            documentType = EXdmResourceLists;

        else if( uri.Find( KXdmOmaPresRulesUsageAUID ) >= 0 )

            documentType = EXdmIetfPresenceRules;

        else if( uri.Find( KXdmDirectoryUsageAUID ) >= 0 )

            documentType = EXdmDirectory;

        else if( uri.Find( KXdmSharedXDMUsageAUID ) >= 0 )

            documentType = EXdmSharedXdm;

        else if( uri.Find( KXdmRlsServicesUsageAUID ) >= 0 )

            documentType = EXdmRlsServices;

        CleanupStack::PopAndDestroy();  //EightBitValueLC()

        }

    return documentType;

    }

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

// CXcapDirectory::Document

// 

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

//

TPtrC CXcapDirectory::Document( TInt aIndex ) const

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDirectory::Document() - Index: %d" ), aIndex );

    #endif

    TChar slash = 47;

    if( aIndex >= 0 && aIndex < iDocumentList.Count() ) 

        {

        TPtrC ret;

        TPtrC uri = iDocumentList[aIndex]->Attribute( KDocumentUri )->AttributeValue();

        TInt index = uri.LocateReverse( slash );

        index > 0 ? ret.Set( uri.Right( uri.Length() - index - 1 ) ) : ret.Set( uri );

        return ret;

        }

    else return TPtrC();

    }

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

// CXcapDirectory::DirectoryPath

// 

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

//

TPtrC CXcapDirectory::DirectoryPath() const

    {

    return iAUID != NULL ? iAUID->Des() : TPtrC();

    }

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

// CXcapDirectory::CancelUpdate

// 

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

//

void CXcapDirectory::CancelUpdate()

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDirectory::CancelUpdate()" ) );

    #endif

    Cancel();

    }

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

// CXcapDirectory::DoCancel

// 

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

//

void CXcapDirectory::DoCancel()

    {

    #ifdef _DEBUG

        iXcapProtocol.WriteToLog( _L8( "CXcapDirectory::DoCancel()" ) );

    #endif

    switch( iUpdatePhase )

        {

        case EDirPhaseIdle:

            break;

        case EUpdateDocumentList:

            {

            CXcapDocument* doc = ( CXcapDocument* )iDirectoryDoc;

            doc->CancelUpdate();

            }

            break;

        case ERefreshDocuments:

            iHttpRetrieval->CancelRequest();

            break;

        default:

            break;

        }

    User::RequestComplete( iClientStatus, KErrCancel );

    }