/*
* 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:   CXcapUriParser
*
*/




// INCLUDES
#include <f32file.h>
#include "XdmNamespace.h"
#include "XcapUriParser.h"
#include "XcapHttpOperation.h"
#include "XcapEngineDefines.h"
#include "XdmNodeAttribute.h"
#include "XcapOperationFactory.h"

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

// ---------------------------------------------------------
// C++ constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------
//
CXcapUriParser::CXcapUriParser( CXdmDocument& aTargetDoc,
                                CXcapOperationFactory& aOperationFactory ) :
                                iTargetDoc( aTargetDoc ),
                                iNodeType( EXdmElementUnspecified ),
                                iOperationFactory( aOperationFactory )
    {
    }

// ---------------------------------------------------------
// Two-phased constructor.
//
// ---------------------------------------------------------
//
CXcapUriParser* CXcapUriParser::NewL( CXdmDocument& aTargetDoc,
                                      CXcapOperationFactory& aOperationFactory )
    {
    CXcapUriParser* self = new ( ELeave ) CXcapUriParser( aTargetDoc, aOperationFactory );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// ---------------------------------------------------------
// Destructor
//
// ---------------------------------------------------------
//
CXcapUriParser::~CXcapUriParser()
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( "CXcapUriParser::~CXcapUriParser()" ) );  
    #endif
    delete iUriBuffer;
    delete iCompleteUri;
    iNamespaceMappings.ResetAndDestroy();
    iNamespaceMappings.Close();
    }
    
// ---------------------------------------------------------
// CXcapUriParser::ConstructL
//
// ---------------------------------------------------------
//
void CXcapUriParser::ConstructL()
    {
    }

// ---------------------------------------------------------
// CXcapUriParser::AddNamespaceMappingL
//
// ---------------------------------------------------------
//
void CXcapUriParser::AddNamespaceMappingL( const TDesC8& aUri, const TDesC8& aPrefix )
    {
    CXdmNamespace* ns = CXdmNamespace::NewL( aUri, aPrefix );
    CleanupStack::PushL( ns );
    User::LeaveIfError( iNamespaceMappings.Append( ns ) );
    CleanupStack::Pop();  //ns
    }

// ---------------------------------------------------------
// CXcapUriParser::AppendNamespaceMappingsL
//
// ---------------------------------------------------------
//
void CXcapUriParser::AppendNamespaceMappingsL()
    {
    CXdmNamespace* ns = NULL;
    const TInt count = iNamespaceMappings.Count();
    iUriBuffer->InsertL( iBufferPosition, KXcapUriQMark );
    iBufferPosition = iBufferPosition + KXcapUriQMark().Length();
    for( TInt i = 0;i < count;i++ )
        {
        ns = iNamespaceMappings[i];
        iUriBuffer->InsertL( iBufferPosition, KXcapUriXmlns );
        iBufferPosition = iBufferPosition + KXcapUriXmlns().Length();
        TPtrC8 prefix( ns->Prefix() );
        iUriBuffer->InsertL( iBufferPosition, prefix );
        iBufferPosition = iBufferPosition + prefix.Length();
        iUriBuffer->InsertL( iBufferPosition, KXcapUriEquals );
        iBufferPosition = iBufferPosition + KXcapUriEquals().Length();
        TPtrC8 uri( ns->Uri() );
        iUriBuffer->InsertL( iBufferPosition, uri );
        iBufferPosition = iBufferPosition + uri.Length();
        iUriBuffer->InsertL( iBufferPosition, KXcapUriQuote );
        iBufferPosition = iBufferPosition + KXcapUriQuote().Length();
        iUriBuffer->InsertL( iBufferPosition, KXcapParenthClose );
        iBufferPosition = iBufferPosition + KXcapParenthClose().Length();
        }
    }
    
// ---------------------------------------------------------
// CXcapUriParser::FinaliseL
//
// ---------------------------------------------------------
//
void CXcapUriParser::FinaliseL()
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( "CXcapUriParser::FinaliseL()" ) );  
    #endif
    delete iCompleteUri;
    iCompleteUri = NULL;
    iCompleteUri = HBufC8::NewL( iUriBuffer->Size() );
    TPtr8 pointer( iCompleteUri->Des() );
    iUriBuffer->Read( 0, pointer, iUriBuffer->Size() );
    iUriBuffer->Reset();
    delete iUriBuffer;
    iUriBuffer = NULL;
    }

// ---------------------------------------------------------
// CXcapUriParser::ParseL
//
// ---------------------------------------------------------
//
void CXcapUriParser::ParseL( const TPtrC8& aHttpUri )
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( "CXcapUriParser::ParseL()" ) );  
    #endif
    iHttpUri = CONST_CAST( TPtrC8*, &aHttpUri );
    if( iNodeType != EXdmElementUnspecified )
        {
        HBufC8* path = DocSubsetPathL();
        CleanupStack::PushL( path );
        iBufferPosition = CreateBasicNodeUriL( path );
        CleanupStack::PopAndDestroy();  //path
        iNodeType == EXdmElementAttribute ? FormatAttributeUriL() : FormatNodeUriL();
        if( iNamespaceMappings.Count() > 0 )
            AppendNamespaceMappingsL();
        FinaliseL();
        #ifdef _DEBUG
            TPtr8 desc( iCompleteUri->Des() );
            iOperationFactory.WriteToLog( _L8( " Context: %S" ), &desc );  
        #endif
        }
    else
        {
        #ifdef _DEBUG
            iOperationFactory.WriteToLog( _L8( " Context is a whole document" ) );  
        #endif
        iCompleteUri = HBufC8::NewL( iHttpUri->Length() );
        iCompleteUri->Des().Copy( *iHttpUri );
        }
    }

// ----------------------------------------------------------
// CXcapDocumentNode::DocSubsetPathL
// 
// ----------------------------------------------------------
//
HBufC8* CXcapUriParser::DocSubsetPathL()
    {
    HBufC8* ret = NULL;
    CXdmDocumentNode* current = iDocumentSubset->Parent();
    CBufFlat* buffer = CBufFlat::NewL( 256 );
    CleanupStack::PushL( buffer );
    while( current != NULL )
        {   
        buffer->InsertL( 0, FormatOnePathElementLC( current )->Des() );
        CleanupStack::PopAndDestroy();  //FormatOnePathElementLC
        current = current->Parent();
        }
    TInt length = buffer->Size();
    ret = HBufC8::NewL( length );
    TPtr8 pointer( ret->Des() );
    buffer->Read( 0, pointer, length );
    CleanupStack::PopAndDestroy();  //buffer 
    return ret;
    }

// ---------------------------------------------------------
// CXcapUriParser::FormatAttributeUriL
//
// ---------------------------------------------------------
//
HBufC8* CXcapUriParser::FormatOnePathElementLC( const CXdmDocumentNode* aPathElement ) 
    {
    #ifdef _DEBUG
        HBufC8* name8 = aPathElement->EightBitNodeNameLC();
        TPtrC8 elemName( name8->Des() );
        TPtrC8 elemPref( aPathElement->Prefix() );
        iOperationFactory.WriteToLog( _L8( "CXcapUriParser::FormatOnePathElementL()" ) );
        if( elemPref.Length() > 0 )
            iOperationFactory.WriteToLog( _L8( "  Prefix: %S" ), &elemName );
        iOperationFactory.WriteToLog( _L8( "  Name:   %S" ), &elemName );  
        CleanupStack::PopAndDestroy();  //name8
    #endif
    TInt position = 0;
    CBufFlat* buffer = CBufFlat::NewL( 50 );
    CleanupStack::PushL( buffer );
    buffer->InsertL( position, KXCAPPathSeparator );
    position = position + KXCAPPathSeparator().Length();
    TPtrC8 prefix = aPathElement->Prefix();
    if( prefix.Length() > 0 )
        {
        buffer->InsertL( position, prefix );
        position = position + prefix.Length();
        buffer->InsertL( position, KXcapUriColon );
        position = position + KXcapUriColon().Length();
        }
    TPtrC8 name = aPathElement->EightBitNodeNameLC()->Des();
    buffer->InsertL( position, name );
    position = position + name.Length();
    CleanupStack::PopAndDestroy();  //EightBitNodeNameLC 
    if( aPathElement->AttributeCount() > 0 &&
        !( iNodeType == EXdmElementAttribute && aPathElement == iDocumentSubset->Parent() ) )
        AppendPredicatesL( position, buffer, aPathElement );
    HBufC8* retBuf = HBufC8::NewL( buffer->Size() );
    TPtr8 pointer( retBuf->Des() );
    buffer->Read( 0, pointer, buffer->Size() );
    CleanupStack::PopAndDestroy();  //buffer
    CleanupStack::PushL( retBuf );
    return retBuf;
    }

// ---------------------------------------------------------
// CXcapUriParser::FormatAttributeUriL
//
// ---------------------------------------------------------
//
void CXcapUriParser::FormatAttributeUriL() 
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( " CXcapUriParser::FormatAttributeUriL()" ) );  
    #endif
    iUriBuffer->InsertL( iBufferPosition, KXCAPAttributeIdentifier );
    iBufferPosition = iBufferPosition + KXCAPAttributeIdentifier().Length();
    iUriBuffer->InsertL( iBufferPosition, iDocumentSubset->EightBitNodeNameLC()->Des() );
    CleanupStack::PopAndDestroy();  //EightBitNodeNameLC
    HBufC8* newUri = HBufC8::NewLC( iUriBuffer->Size() );
    TPtr8 pointer( newUri->Des() );
    iUriBuffer->Read( 0, pointer, iUriBuffer->Size() );
    #ifdef _DEBUG
        DumpUriL( newUri );
    #endif
    CleanupStack::PopAndDestroy();  //newUri
    }

// ---------------------------------------------------------
// CXcapUriParser::FormatNodeUriL
//
// ---------------------------------------------------------
//
void CXcapUriParser::FormatNodeUriL() 
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( " CXcapUriParser::FormatNodeUriL()" ) );  
    #endif
    iNodeType = EXdmElementNode;
    TPtrC8 prefix = iDocumentSubset->Prefix();
    if( prefix.Length() > 0 )
        {
        iUriBuffer->InsertL( iBufferPosition, prefix );
        iBufferPosition = iBufferPosition + prefix.Length();
        iUriBuffer->InsertL( iBufferPosition, KXcapUriColon );
        iBufferPosition = iBufferPosition + KXcapUriColon().Length();
        }
    TPtrC8 name = iDocumentSubset->EightBitNodeNameLC()->Des();
    iUriBuffer->InsertL( iBufferPosition, name );
    iBufferPosition = iBufferPosition + name.Length();
    CleanupStack::PopAndDestroy();  //EightBitNodeNameLC
    if( iDocumentSubset->AttributeCount() > 0 )
        AppendPredicatesL( iBufferPosition, iUriBuffer, iDocumentSubset );
    //For now, do not put a trailing '/' to the node path. This may have to be changed, though.
    //iUriBuffer->InsertL( iBufferPosition, KXCAPPathSeparator );
    //iBufferPosition = iBufferPosition + TPtrC8( KXCAPPathSeparator ).Length();
    HBufC8* newUri = HBufC8::NewLC( iUriBuffer->Size() );
    TPtr8 pointer2( newUri->Des() );
    iUriBuffer->Read( 0, pointer2, iUriBuffer->Size() );
    #ifdef _DEBUG
        DumpUriL( newUri );
    #endif
    CleanupStack::PopAndDestroy();  //newUri
    }

// ---------------------------------------------------------
// CXcapUriParser::AppendPredicatesL
//
// ---------------------------------------------------------
//
void CXcapUriParser::AppendPredicatesL( TInt& aPosition,
                                        CBufBase* aBuffer,
                                        const CXdmDocumentNode* aPathElement )
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( " CXcapUriParser::AppendPredicatesL()" ) );  
    #endif
    TInt count = aPathElement->AttributeCount();
    for( TInt i = 0;i < count;i++ )
        {
        CXdmNodeAttribute* attribute = aPathElement->Attribute( i );
        //Namespaces cannot be used as attributes
        if( attribute->NodeName().Find( _L( "xmlns" ) ) < 0 )
            {
            aBuffer->InsertL( aPosition, KHTTPBracketOpen );
            aPosition = aPosition + KHTTPBracketOpen().Length();
            aBuffer->InsertL( aPosition, KXCAPAttributeIdentifier );
            aPosition = aPosition + KXCAPAttributeIdentifier().Length();
            TPtrC8 name = attribute->EightBitNodeNameLC()->Des();
            aBuffer->InsertL( aPosition, name );
            aPosition = aPosition + name.Length();
            CleanupStack::PopAndDestroy();  //EightBitNodeNameLC
            aBuffer->InsertL( aPosition, KXCAPEquality );
            aPosition = aPosition + KXCAPEquality().Length();
            aBuffer->InsertL( aPosition, KHTTPQuotationMark );
            aPosition = aPosition + KHTTPQuotationMark().Length();
            TPtrC8 value = attribute->EightBitValueLC()->Des();
            aBuffer->InsertL( aPosition, value );
            aPosition = aPosition + value.Length();
            CleanupStack::PopAndDestroy();  //EightBitValueLC
            aBuffer->InsertL( aPosition, KHTTPQuotationMark );
            aPosition = aPosition + KHTTPQuotationMark().Length();
            aBuffer->InsertL( aPosition, KHTTPBracketClose );
            aPosition = aPosition + KHTTPBracketClose().Length();
            }
        }
    }

// ---------------------------------------------------------
// CXcapUriParser::CreateBasicNodeUriL
//
// ---------------------------------------------------------
//
TInt CXcapUriParser::CreateBasicNodeUriL( HBufC8* aNodePath )
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( " CXcapUriParser::CreateBasicNodeUriL()" ) );  
    #endif
    TInt position = 0;
    TPtr8 pointer( aNodePath->Des() );
    iUriBuffer = CBufFlat::NewL( 256 );
    iUriBuffer->InsertL( position, *iHttpUri );
    position = iHttpUri->Length();
    if( iHttpUri->LocateReverseF( KXcapPathSeparatorChar ) != iHttpUri->Length() - 1 )
        {
        iUriBuffer->InsertL( position, KXCAPPathSeparator );
        position = position + KXCAPPathSeparator().Length();
        }
    iUriBuffer->InsertL( position, KXCAPNodeSeparator ); //"~~"
    position = position + KXCAPNodeSeparator().Length();
    iUriBuffer->InsertL( position, pointer );            
    position = position + pointer.Length();
    iUriBuffer->InsertL( position, KXCAPPathSeparator );
    position = position + KXCAPPathSeparator().Length();
    return position;
    }



// ---------------------------------------------------------
// CXcapUriParser::SetDocumentSubset
//
// ---------------------------------------------------------
//
void CXcapUriParser::SetDocumentSubset( const CXdmDocumentNode* aDocumentSubset )
    {
    #ifdef _DEBUG
        iOperationFactory.WriteToLog( _L8( "CXcapUriParser::SetDocumentSubset() - Type: %d" ),
                                            aDocumentSubset->ElementType() );  
    #endif
    __ASSERT_DEBUG( aDocumentSubset != NULL, User::Panic( _L( "CXcapUriParser" ), 1 ) );
    iDocumentSubset = CONST_CAST( CXdmDocumentNode*, aDocumentSubset );
    iNodeType = iDocumentSubset->ElementType();
    }

// ---------------------------------------------------------
// CXcapUriParser::DesC8
//
// ---------------------------------------------------------
//
TPtrC8 CXcapUriParser::DesC8() const 
    {
    return iCompleteUri != NULL ? iCompleteUri->Des() : TPtrC8();
    }

// ---------------------------------------------------------
// CXcapUriParser::NodeType
//
// ---------------------------------------------------------
//
TXdmElementType CXcapUriParser::NodeType() const 
    {
    return iNodeType;
    }
    
#ifdef _DEBUG        
// ---------------------------------------------------------
// CXcapUriParser::DumpUriL
//
// ---------------------------------------------------------
//
void CXcapUriParser::DumpUriL( HBufC8* aNodePath ) 
    {
    RFile file;
    RFs session;
    TPtr8 pointer( aNodePath->Des() );
    _LIT( KFilePath, "C:\\logs\\XDM\\Dump.txt" );
    User::LeaveIfError( session.Connect() );
    TInt error = file.Replace( session, KFilePath, EFileWrite );
    if( error == KErrNone )
        {
        file.Write( pointer );
        file.Close();
        }
    session.Close();
    }
#endif
//  End of File