// Copyright (c) 2006-2009 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:
// XML XOP Deserializer implementation
//

#include "xmlengdeserializerxop.h"
#include <xml/dom/xmlengerrors.h>
#include "xmlengcontenthandler.h"
#include <xml/utils/xmlengxestd.h>
#include <xml/utils/xmlengxestrings.h>
#include <xml/dom/xmlengserializeerrors.h>

#include <xml/parser.h>
#include <xml/parserfeature.h>
#include <xml/matchdata.h>
#include <bafl/multipartparser.h>
#include <bafl/bodypart.h>
#include <f32file.h>

_LIT8(KXmlMimeType, "text/xml");
_LIT8(KParserType,"libxml2");

// Implemented according to XOP Spec (http://www.w3.org/TR/xop10/)
_LIT8(KMultipartMixed, "multipart/mixed");
_LIT8(KBoundary1, "MIME_boundary"); 
_LIT(KUrlStub, "http://url_stub");  

using namespace Xml;

// --------------------------------------------------------------------------------------
// Creates an instance of CXMLDEDeserializerXOP
// --------------------------------------------------------------------------------------
//
CXmlEngDeserializerXOP* CXmlEngDeserializerXOP::NewL( MContentHandler& aContentHandler,
	 											TBool aCleanXOPInfoset ) 
    {	    
	CXmlEngDeserializerXOP* deserializerXop = new (ELeave) CXmlEngDeserializerXOP(aCleanXOPInfoset);
	CleanupStack::PushL( deserializerXop ); 	
	deserializerXop->ConstructL( aContentHandler );
	CleanupStack::Pop(); //deserializerXop
	return deserializerXop;
    }

// --------------------------------------------------------------------------------------
// Enables CParser feature
// --------------------------------------------------------------------------------------
//
EXPORT_C TInt CXmlEngDeserializerXOP::EnableFeature(TInt aParserFeature)
	{
	if(aParserFeature == EConvertTagsToLowerCase)
		{
		iParserMode |= aParserFeature;
		return KErrNone;		
		}
	return CXmlEngDeserializer::EnableFeature(aParserFeature);
	}
	
// --------------------------------------------------------------------------------------
// Disables CParser feature
// --------------------------------------------------------------------------------------
//
EXPORT_C TInt CXmlEngDeserializerXOP::DisableFeature(TInt aParserFeature)
	{
	if(aParserFeature == EConvertTagsToLowerCase)
		{
		iParserMode &= ~aParserFeature;
		return KErrNone;		
		}	
	return CXmlEngDeserializer::DisableFeature(aParserFeature);
	}

// --------------------------------------------------------------------------------------
// Checks if a feature is enabled
// --------------------------------------------------------------------------------------
//	
EXPORT_C TBool CXmlEngDeserializerXOP::IsFeatureEnabled(TInt aParserFeature) const
	{
	if(aParserFeature == EConvertTagsToLowerCase)
		{
		return iParserMode & aParserFeature;		
		}	
	return iParser->IsFeatureEnabled(aParserFeature);
	}
    
// --------------------------------------------------------------------------------------
// Deserializes document
// --------------------------------------------------------------------------------------
//
void CXmlEngDeserializerXOP::DeserializeL()
    {
	switch(iSerializationOutput)
		{
		case EDeserializeFromFile:
			{
			RFs fs;
			User::LeaveIfError(fs.Connect());
			CleanupClosePushL(fs); 
		    DeserializeL(fs, iInputFileName->Des(), iParsingOptions);
		    CleanupStack::PopAndDestroy(&fs); //fs
		    break;
			}
		case EDeserializeFromBuffer:
			{
			if(iBuffer.Length() == 0)
				{
				User::Leave(KXmlEngErrNoParameters);
				}
			DeserializeL(iBuffer, iParsingOptions);
			break;
			}
		case EDeserializeFromStream:
			{
			// Currently this feature is not supported. Implement when need arises or remove.			
			User::Leave(KErrNotSupported);
			}
		default:
			{
			User::Leave(KErrNotSupported);
			break;
			}						
		}   
    }

// --------------------------------------------------------------------------------------
// Deserialize document
// --------------------------------------------------------------------------------------
//
void CXmlEngDeserializerXOP::DeserializeL( const TDesC& aFileName,
										   const TXmlEngParsingOptions& aOptions ) 
    {
	RFs fs;
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs); 
	DeserializeL(fs, aFileName, aOptions);
	CleanupStack::PopAndDestroy(&fs); //fs
	}

// --------------------------------------------------------------------------------------
// Deserialize document
// --------------------------------------------------------------------------------------
//
void CXmlEngDeserializerXOP::DeserializeL( RFs& aRFs, 
										const TDesC& aFileName,
										const TXmlEngParsingOptions& aOptions ) 
    {
	iBodyPartArray.ResetAndDestroy();     
	if(iData)
	   	{
	   	delete iData;
	   	iData = NULL;
	   	}
	iData = ReadFileL( aRFs, aFileName );
	TPtrC8 dataPtr = iData->Des();
	CXmlEngDeserializerXOP::DeserializeL( dataPtr, aOptions );	
	}

// --------------------------------------------------------------------------------------
// Deserialize document
// --------------------------------------------------------------------------------------
//
void CXmlEngDeserializerXOP::DeserializeL( const TDesC8& aBuffer,
										   const TXmlEngParsingOptions& aOptions ) 
    {
    TXmlEngParsingOptions originalOpts = iParsingOptions;
    iParsingOptions = aOptions;

    if( iCleanXOPInfoset )
    	{
		Xml::ParseL(*iParser, aBuffer);
		}
	else
		{
	    if(!aBuffer.Length())
	    	{
	    	User::Leave(KXmlEngErrNoParameters);
	    	}
	    if(iBodyPartArray.Count())
	        iBodyPartArray.ResetAndDestroy();   	
	    
	   	MultipartParser::ParseL( aBuffer, KMultipartMixed, KBoundary1, KUrlStub, iBodyPartArray );    	

		// get xml document
		CBodyPart* bodyPart = NULL;
		if(iBodyPartArray.Count() > 0)	
			{
			bodyPart = iBodyPartArray[0];		
			}
		else
			{
			//The multipart document wasn't parsed correctly
			User::Leave(KXmlEngErrBadMultipart);
			}
		Xml::ParseL(*iParser, bodyPart->Body());		
		}
	iParsingOptions = originalOpts;
	iBodyPartArray.ResetAndDestroy();
    }        

// --------------------------------------------------------------------------------------
// Retrieves pointer to data referenced by CID from parsed multipart package
// --------------------------------------------------------------------------------------
//
TInt CXmlEngDeserializerXOP::GetData(const TDesC8& aCid, TPtrC8& aData)
	{
	for(TInt i = 0; i < iBodyPartArray.Count(); i++)
		{
		TPtrC8 cid = iBodyPartArray[i]->ContentID();
		if(iBodyPartArray[i]->ContentID() == aCid)
			{
			TInt size = iBodyPartArray[i]->Body().Size();
			iDataPtr.Set(iBodyPartArray[i]->Body());
			aData.Set(iDataPtr);
			return KErrNone;
			}
		}
	return KErrNotFound;
	}
  
// --------------------------------------------------------------------------------------
// Default Constructor
// --------------------------------------------------------------------------------------
//
CXmlEngDeserializerXOP::CXmlEngDeserializerXOP( TBool aCleanXOPInfoset ) 
	 : iData(NULL), iCleanXOPInfoset(aCleanXOPInfoset)
    {
    }
    
// --------------------------------------------------------------------------------------
// Destructor
// --------------------------------------------------------------------------------------
//
CXmlEngDeserializerXOP::~CXmlEngDeserializerXOP()
    {
    if(iData)
    	{
    	delete iData;
    	}
    iBodyPartArray.ResetAndDestroy();
    delete iInternalHandler;  
    }

// --------------------------------------------------------------------------------------
// 2nd phase constructor
// --------------------------------------------------------------------------------------
//
void CXmlEngDeserializerXOP::ConstructL( MContentHandler& aContentHandler )
    {
    if(iInternalHandler)
    	{
    	delete iInternalHandler;
    	iInternalHandler = NULL;
    	}    
    iInternalHandler = CXmlEngContentHandler::NewL(this, &aContentHandler);

    if(iParser)
    	{
    	delete iParser;
    	iParser = NULL;
    	}

    CMatchData* matchData = CMatchData::NewLC();
    matchData->SetMimeTypeL(KXmlMimeType);
    matchData->SetVariantL(KParserType); 
    iParser = CParser::NewL(*matchData, *iInternalHandler);
    CleanupStack::PopAndDestroy(matchData);
    }

// --------------------------------------------------------------------------------------
// Read file
// --------------------------------------------------------------------------------------
//
HBufC8* CXmlEngDeserializerXOP::ReadFileL( RFs& aRFs, const TDesC& aFileName)
    {
    RFile file;
    User::LeaveIfError(file.Open(aRFs, aFileName, EFileRead));
    CleanupClosePushL(file);
    TInt size;
    User::LeaveIfError(file.Size(size));
    HBufC8* buf = HBufC8::NewLC(size);
    TPtr8 bufPtr(buf->Des());
    User::LeaveIfError(file.Read(bufPtr));
    CleanupStack::Pop(buf); // buf
    CleanupStack::PopAndDestroy(&file); // file
    return buf;
    }

/*
// --------------------------------------------------------------------------------------
// SerializationOutput
// --------------------------------------------------------------------------------------
//
TXmlEngDeserializationSource CXmlEngDeserializerXOP::SerializationOutput()
    {
    return iSerializationOutput;
    }
*/