/*

* Copyright (c) 2006 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:    Simple Engine

*

*/

// INCLUDE FILES

#include <e32def.h>           // First to avoid NULL redefine warning (no #ifndef NULL).

#include <e32std.h>

#include <string.h>

#include <imcvcodc.h>

// #include <e32std.h>

#include <s32strm.h>

#include <SenBaseElement.h>

#include <SenBaseAttribute.h>

#include <SenXmlUtils.h>

#include <SenXmlReader.h>

#include <SenDomFragment.h>

#include <multipartparser.h>

#include <bodypart.h>

// own simple

#include "simplecommon.h"

#include "simpleelement.h"

#include "simplenamespace.h"

#include "simpleattribute.h"

#include "simpledocument.h"

#include "simplebasedocument.h"

#include "simpleutils.h"

#include "simplecontent.h"

_LIT8 ( KSimpleEntity, "entity");

// Multipart CONSTANTS

const char Multipart_CRLF_Text[] = {"\r\n"};

const char Multipart_DoubleCRLF_Text[] = {"\r\n\r\n"};

// MACROS

#define MULTIPART_CONTENT_LOCATION_LENGTH           17

#define MULTIPART_CONTENT_TYPE_LENGTH               13

#define MULTIPART_CONTENT_TRANSFER_ENCODING_LENGTH  26

// violates RFC2045; but upon vodafone request

#define MULTIPART_CONTENT_ENCODING_LENGTH           17

#define MULTIPART_CONTENT_LENGTH_LENGTH             15

#define MULTIPART_LAST_MODIFIED_LENGTH              14

#define MULTIPART_CONTENT_ID_LENGTH                 11

#define MULTIPART_CONTENT_LOCATION           2

#define MULTIPART_CONTENT_TRANSFER_ENCODING  3

#define MULTIPART_CONTENT_TYPE               4

#define MULTIPART_CONTENT_ID                 5

#define MULTIPART_INTERNET_DATE_STRING_LENGTH       29

#define SLASH_CHAR    '/'

#define DOT_CHAR      '.'

#define AT_CHAR       '@'

#define COLON_CHAR    ':'

// <scheme>://

// #define SCHEME_SEPARATOR_LENGTH               3

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

//

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

// CSimpleDocument::CSimpleDocument

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

//

CSimpleDocument::CSimpleDocument( )

: CSimpleBaseDocument()

    {

    }

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

// CSimpleDocument::~CSimpleDocument

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

//

CSimpleDocument::~CSimpleDocument()

    {

    iContents.ResetAndDestroy();

    iContents.Close();

    }

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

// CSimpleDocument::ConstructL

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

//

void CSimpleDocument::ConstructL(

    const TDesC8& aNsUri,

    const TDesC8& aLocalName )

    {

    BaseConstructL(aNsUri, aLocalName);

    }

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

// CSimpleDocument::ConstructMultiPartL

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

//

void CSimpleDocument::ConstructMultiPartL(

    const TDesC8& aData, const TDesC8& aBoundary, const TDesC8& aStart )

    {    

    _LIT(KUrl, "http://dummy.com/d1/d.html");

    // body part array

    RPointerArray<CBodyPart> bodyPartArray;

    TCleanupItem clItem( ResetAndDestroy, &bodyPartArray  );

    CleanupStack::PushL( clItem );

    // remove "..." characters from boundary if needed

    TPtrC8 pUnQuoted = aBoundary;

    TInt quoted = aBoundary.Locate('"');

    if (!quoted)

        {

        pUnQuoted.Set( aBoundary.Mid( 1, aBoundary.Length() - 2 ));

        } 

    // parse

    MultipartParser::ParseL( aData, KSimpleMultipartType, pUnQuoted, KUrl, bodyPartArray  );    

    DoConstructL( bodyPartArray, aStart );

    CleanupStack::PopAndDestroy( ); // bodyPartArray     

    }    

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

// CSimpleDocument::ConstructL

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

//

void CSimpleDocument::ConstructL(

    const TDesC8& aXml )

    {

    BaseConstructL( aXml );

    }

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

// CSimpleDocument::NewL

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

//

CSimpleDocument* CSimpleDocument::NewL( )

    {

    CSimpleDocument* self = new (ELeave) CSimpleDocument( );

    CleanupStack::PushL( self );

    self->ConstructL( KSimpleNsDefault, KDocumentLocalName );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSimpleDocument::NewL

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

//

CSimpleDocument* CSimpleDocument::NewL( const TDesC8& aXml )

    {

    CSimpleDocument* self = new (ELeave) CSimpleDocument( );

    CleanupStack::PushL( self );

    self->ConstructL( aXml );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSimpleDocument::NewInMultiPartL

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

//

CSimpleDocument* CSimpleDocument::NewInMultiPartL( 

    const TDesC8& aData, const TDesC8& aBoundary, const TDesC8& aStart )

    {

    CSimpleDocument* self = new (ELeave) CSimpleDocument( );

    CleanupStack::PushL( self );

    self->ConstructMultiPartL( aData, aBoundary, aStart );

    CleanupStack::Pop( self );

    return self;

    } 

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

// CSimpleDocument::GetDirectContentsL

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

//

void CSimpleDocument::GetDirectContentsL( 

    RPointerArray<MSimpleContent>& aContents )

    {

    aContents.Reset();

    TInt myCount = iContents.Count();

    for ( TInt i = 0; i<myCount; i++ )

        {

        User::LeaveIfError( aContents.Append( iContents[i] ));

        }               

    }

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

// CSimpleDocument::AddDirectContentL

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

//    

void CSimpleDocument::AddDirectContentL( 

    MSimpleContent& aContent,

    TBool aCopyContent )

    {

    CSimpleContent* content = CSimpleContent::NewLC(

        aContent.ContentID(), aContent.ContentType());

    User::LeaveIfError( iContents.Append( content ));

    CleanupStack::Pop( content );

    if ( aCopyContent )

        {

        content->CopyBodyL( aContent.Body() );

        }

    else

        {

        content->SetBody( aContent.GiveBodyOwnerShip() );

        }                       

    }

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

// CSimpleDocument::ValidateXmlL

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

//

void CSimpleDocument::ValidateXmlL( const TDesC8& aName )

    {

    if ( aName.CompareF( KDocumentLocalName ) )

        {

        User::Leave( KErrCorrupt );

        }

    }

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

// CSimpleDocument::EntityURI

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

//

const TDesC8* CSimpleDocument::EntityURI()

    {

    return Root()->AttrValue( KSimpleEntity );

    }

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

// CSimpleDocument::SetEntityURIL

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

//

void CSimpleDocument::SetEntityURIL( const TDesC8& aValue )

    {

    Root()->AddAttr8L( KSimpleEntity, aValue );

    }

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

// CSimpleDocument::DefaultNamespace

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

//

TPtrC8 CSimpleDocument::DefaultNamespace()

    {

    return CSimpleBaseDocument::DefaultNamespace();

    }

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

// CSimpleDocument::AddNamespaceL

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

//

void CSimpleDocument::AddNamespaceL(

    const TDesC8& aPrefix,

    const TDesC8& aUri )

    {

    CSimpleBaseDocument::AddNamespaceL( aPrefix, aUri );

    }

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

// CSimpleDocument::NamespacesL

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

//

RPointerArray<MSimpleNamespace>& CSimpleDocument::NamespacesL()

    {

    return CSimpleBaseDocument::NamespacesL();

    }

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

// CSimpleDocument::ExternalizeL

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

//

void CSimpleDocument::ExternalizeL( RWriteStream& aStream )

    {

    // notice: check the max message size 

    if ( !iContents.Count() )

        {            

        // single pidf+xml    

        CSimpleBaseDocument::ExternalizeL( aStream );

        }

    else

        {

        RPointerArray<CBodyPart> bodyPartsArray;

        RPointerArray<HBufC8> bufferArray;

        TRAPD( err, DoExternalizeMultiPartL( bodyPartsArray, bufferArray, aStream ) );                      

        bufferArray.ResetAndDestroy();        

        bodyPartsArray.ResetAndDestroy();         

        bufferArray.Close();        

        bodyPartsArray.Close();        

        User::LeaveIfError( err );                                                                          

        }                                                

    }

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

// CSimpleDocument::Close

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

//

void CSimpleDocument::Close()

    {

    CSimpleBaseDocument::Close();

    }

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

// CSimpleDocument::LocalName

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

//

const TDesC8& CSimpleDocument::LocalName()

    {

    return CSimpleBaseDocument::LocalName();

    }

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

// CSimpleDocument::DefNamespaceL

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

//

MSimpleNamespace* CSimpleDocument::DefNamespaceL()

    {

    return CSimpleBaseDocument::DefNamespaceL();

    }

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

// CSimpleDocument::HasContent

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

//

TBool CSimpleDocument::HasContent()

    {

    return CSimpleBaseDocument::HasContent();

    }

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

// CSimpleDocument::ContentUnicodeL

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

//

HBufC* CSimpleDocument::ContentUnicodeL()

    {

    return CSimpleBaseDocument::ContentUnicodeL();

    }

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

// CSimpleDocument::SetContentUnicodeL

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

//

void CSimpleDocument::SetContentUnicodeL( const TDesC& aContent )

    {

    CSimpleBaseDocument::SetContentUnicodeL( aContent );

    }

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

// CSimpleDocument::SimpleElementsL

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

//

TInt CSimpleDocument::SimpleElementsL( RPointerArray<MSimpleElement>& aElementArray )

    {

    return CSimpleBaseDocument::SimpleElementsL( aElementArray );

    }

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

// CSimpleDocument::AttrValueLC

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

//

HBufC* CSimpleDocument::AttrValueLC( const TDesC8& aName )

    {

    return CSimpleBaseDocument::AttrValueLC( aName );

    }

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

// CSimpleDocument::AttrValue

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

//

const TDesC8* CSimpleDocument::AttrValue( const TDesC8& aName )

    {

  return CSimpleBaseDocument::AttrValue( aName );

    }

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

// CSimpleDocument::AddAttrL

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

//

void CSimpleDocument::AddAttrL( const TDesC8& aName, const TDesC& aValue )

    {

    CSimpleBaseDocument::AddAttrL( aName, aValue );

    }

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

// CSimpleDocument::SimpleAttributesL

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

//

TInt CSimpleDocument::SimpleAttributesL( RPointerArray<MSimpleAttribute>& aArray )

    {

    return CSimpleBaseDocument::SimpleAttributesL( aArray );

    }

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

// CSimpleDocument::SimpleParentL

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

//

MSimpleElement* CSimpleDocument::SimpleParentL()

    {

    return NULL;

    }

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

// CSimpleDocument::DetachSimpleL

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

//

void CSimpleDocument::DetachSimpleL()

    {

    User::Leave( KErrNotFound );

    }

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

// CSimpleDocument::AddSimpleElementL

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

//

MSimpleElement* CSimpleDocument::AddSimpleElementL(

    const TDesC8& aNsUri,

    const TDesC8& aLocalName )

    {

    return CSimpleBaseDocument::AddSimpleElementL( aNsUri, aLocalName );

    }

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

// CSimpleDocument::AddSimpleElementL

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

//

MSimpleElement* CSimpleDocument::AddSimpleElementL(

    const TDesC8& aLocalName )

    {

    return CSimpleBaseDocument::AddSimpleElementL( aLocalName );

    }

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

// CSimpleDocument::RemoveSimpleElement

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

//

void CSimpleDocument::RemoveSimpleElement(

    const TDesC8& aNsUri,

    const TDesC8& aLocalName )

    {

    CSimpleBaseDocument::RemoveSimpleElement( aNsUri, aLocalName );

    }

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

// CSimpleDocument::ResetAndDestroy

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

//

void CSimpleDocument::ResetAndDestroy( TAny* aPtrArray )

    {

    RPointerArray<CBodyPart>* array =

    	static_cast<RPointerArray<CBodyPart>*>( aPtrArray );

    array->ResetAndDestroy();

    array->Close();	

    }   

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

// CSimpleDocument::DoConstructL

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

//    

void CSimpleDocument::DoConstructL( 

    RPointerArray<CBodyPart>& aParts, const TDesC8& aStart )

    {

    // Handle body parts one by one

    TInt size = aParts.Count();

    TInt i;

    CBodyPart* cp = NULL;

    TPtrC8 boundary;

    TPtrC8 start;

    TBool pidfOk ( EFalse );

    for (i = 0; i < size; i++)

        {

        cp = aParts[i];      

        if ( (( aStart.Length() > 0 && !aStart.Compare( cp->ContentID()) ) || 

                !pidfOk ) && 

             !cp->ContentType().Left(sizeof(KSimpleDocumentType)).CompareF( KSimpleDocumentType ))

            {

            // Multipart root is in the pidf+xml format

            BaseConstructL( cp->Body() );

            pidfOk = ETrue;

            }

        else 

            {

            // Direct contents, as a separate MIME multipart parts                           

            CSimpleContent* cd = CSimpleContent::NewL( 

                cp->ContentID(), cp->ContentType() );

            cd->CopyBodyL( cp->Body() );                 

            CleanupStack::PushL( cd );           

            User::LeaveIfError( iContents.Append( cd ) );

            CleanupStack::Pop( cd );           

            }                  

        }   

    }    

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

// CSimpleDocument::DoComposeMultiPartL

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