// Copyright (c) 2003-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:

//

#include <ecom/ecom.h>

#include <xml/contentprocessor.h>

#include <xml/contenthandler.h>

#include <xml/matchdata.h>

#include <xml/stringdictionarycollection.h>

#include <xml/xmlframeworkconstants.h>

#include <xml/xmlframeworkerrors.h>

#include "XmlFrameworkPanics.h"

#include <xml/plugins/charsetconverter.h>

#include <xml/plugins/contentprocessorinitparams.h>

#include <xml/plugins/parserinitparams.h>

#include <xml/plugins/parserinterface.h>

#include "parserimpl.h"

/** 

Indicates the custom resolver implementation for XML parser framework. 

@internalComponent

*/

const TUid KCustomResolverUid			= {0x10273862};

using namespace Xml;

void TParserImpl::DestroyContentProcessorPtrMapping(TAny* aPtr)

/**

Tidy memory associated with this object.

@param				aPtr The ContentProcessor pointer.

*/

	{

	TDtorContentProcessorPtrMapping* ptr = static_cast<TDtorContentProcessorPtrMapping*>(aPtr);

	if (ptr->iDtorKey != KNullUid && ptr->iContentProcessor)

		{

		// Tell ECom to destroy its plugin details

		REComSession::DestroyedImplementation(ptr->iDtorKey);

		// Free memory

		ptr->iContentProcessor->Release();

		}

	delete (ptr);

	}

TParserImpl::TParserImpl()

/**

Default constructor

@post				This object is properly constructed.

*/

:	iParser(NULL),

	iCharSetConverter(NULL),

	iStringDictionaryCollection(NULL)

	{

	}

void TParserImpl::OpenL(const CMatchData& aCriteria, MContentHandler& aCallback) 

/**

This method opens and sets all the objects contents.

The StringDictionaryCollection is created and Opened.

@pre				The object has just been constructed and no other values have been set.

@post				The objects members have been set to the values given.

@param				aCriteria Detailed criteria for parser resolution.

@param				aCallback client to pass data to.

*/

	{

	Close();

	if (!iCharSetConverter)

		iCharSetConverter = CCharSetConverter::NewL();

	if (!iStringDictionaryCollection)

		{

		iStringDictionaryCollection = new(ELeave) RStringDictionaryCollection();

		iStringDictionaryCollection->OpenL();

		}

	//verify mime type 

	if (aCriteria.MimeType() != KNullDesC8)

		{

		// Create and remember the current mime type

		iCurrentParserMatchData = aCriteria;

		}

	else

		User::Leave(KErrArgument);

	iDefParserMatchData = aCriteria;

	iParser = ConstructParserL(aCriteria, aCallback);

	iClient = &aCallback;

	}

void TParserImpl::Close()

/**

This method cleans up the object before destruction. It releases all resources in

accordance to the R Class pattern.

The framework will Close the StringDictionaryCollection and if owned will

delete it.

@post				This object may be allowed to go out of scope.

*/

	{

	// Close any remaining RStrings owned by iElementStack. This will prevent a

	// memory leak from occuring when parsing a document that is not complete AND

	// ParseEndL is NOT called before destroying the CParser object.

	for (TInt i=0;i<iElementStack.Count();i++)

		iElementStack[i].Close();

	iElementStack.Close();

	// Destroy the chain of plugins

	DestroyChain();

	if (iParser)

		{

		// Delete the Parser

		REComSession::DestroyedImplementation(iParserDtorKey);

		iParser->Release();

		iParser = NULL;

		}

	delete iCharSetConverter;

	iCharSetConverter = NULL;

	if (iStringDictionaryCollection)

		{

		iStringDictionaryCollection->Close();

		delete iStringDictionaryCollection;

		iStringDictionaryCollection = NULL;

		}

	iClient = NULL;

	REComSession::FinalClose();

	}

void TParserImpl::ParseChunkL(const TDesC8& aChunk)

/**

This method starts the parser parsing a descriptor.

The descriptor does not contain the last part of the document. 

@pre				OpenL has been called

@param				aChunk the chunk to parse - not the last chunk

*/

	{

	iParser->ParseChunkL(aChunk);

	}

void TParserImpl::ParseLastChunkL(const TDesC8& aFinalChunk)

/**

This method starts the parser parsing a descriptor.

The descriptor contains the last part of the document. 

@pre				OpenL has been called

@param				aFinalChunk the final chunk to parse

*/

	{		

	iParser->ParseLastChunkL(aFinalChunk);

	}

void TParserImpl::SetContentHandler(MContentHandler& aCallback)

/**

Allows the user to set/change the client for this parse session.

@pre				OpenL has been called

@param				aCallback the client at the end of the callback

					chain that is to receive the parsed document information.

*/

	{

	iClient = &aCallback;

	MContentSource* prev;

	if (iDtorKeyAndPluginList.Count())

		{

		// set the last plugin to point to the client

		prev = iDtorKeyAndPluginList[iDtorKeyAndPluginList.Count()-1]->iContentProcessor;

		}

	else

		{

		// set the parser to point to the client as there is no chain

		prev = iParser;

		}

	prev->SetContentSink(*iClient);

	}

void TParserImpl::SetProcessorChainL(const RContentProcessorUids& aPlugins)

/**

Allows the user to change the client and set the plugin chain for 

this parse session.

@pre				OpenL has been called

@param				aCallback the client at the end of the callback

					chain that is to receive the parsed document information.

@param				aPlugins a list of plugin implementation uids that

					make up the callback chain.

*/

	{

	// If there is an existing chain delete all but the parser

	DestroyChain();

	// Rebuild the chain.

	MContentHandler* callback = BuildChainL(*iClient, aPlugins);

	iParser->SetContentSink(*callback);

	}

void TParserImpl::ResetMimeTypeL()

	{

	if ( !(iCurrentParserMatchData == iDefParserMatchData) )

		{

		SetMimeTypeL(iDefParserMatchData);

		}

	}

void TParserImpl::SetMimeTypeL(const CMatchData& aCriteria)

/**

Allows the user to set/change the parser mime type used for 

this parse session.

@pre				OpenL has been called

@param				aParserMimeType the mime type of the requested parser

*/

	{

	// Check if we are already using this parser

	if (aCriteria == iCurrentParserMatchData)

		{

		// There is no change to the parser. 

		return;

		}

	// Delete the Parser

	if (iParser)

		{

		REComSession::DestroyedImplementation(iParserDtorKey);

		iParser->Release();

		iParser = NULL;

		}

	MContentHandler* next;

	if (iDtorKeyAndPluginList.Count())

		{

		// point the parser to the first plugin in the chain

		next = iDtorKeyAndPluginList[0]->iContentProcessor;

		}

	else

		{

		// point the parser to the client as there is no chain

		next = iClient;

		}

	// Create the new parser and point to the next plugin

	iParser = ConstructParserL(aCriteria, *next);

	// Remember what parser we are using.

	iCurrentParserMatchData = aCriteria;

	}

TInt TParserImpl::EnableFeature(TInt aParserFeature)

	{

	__ASSERT_ALWAYS(iParser, Panic(EXmlFrameworkPanicUnexpectedLogic));

	return iParser->EnableFeature(aParserFeature);

	}

TInt TParserImpl::DisableFeature(TInt aParserFeature)

	{

	__ASSERT_ALWAYS(iParser, Panic(EXmlFrameworkPanicUnexpectedLogic));

	return iParser->DisableFeature(aParserFeature);

	}

TBool TParserImpl::IsFeatureEnabled(TInt aParserFeature) const

	{

	__ASSERT_ALWAYS(iParser, Panic(EXmlFrameworkPanicUnexpectedLogic));

	return iParser->IsFeatureEnabled(aParserFeature);

	}

void TParserImpl::AddPreloadedDictionaryL(const TDesC8& aPublicId)

	{

	iStringDictionaryCollection->OpenDictionaryL(aPublicId);   

	}

RStringPool& TParserImpl::StringPool()

	{

	return iStringDictionaryCollection->StringPool();

	}

RStringDictionaryCollection& TParserImpl::StringDictionaryCollection()

	{

	return *iStringDictionaryCollection;

	}

MContentHandler* TParserImpl::BuildChainL(MContentHandler& aCallback, 

										  const RContentProcessorUids& aPlugins)

/**

This method builds the chain of plugins, so that information may flow down

the chain.

The first in the chain is the parser, the last is the client.

@param				aCallback client to pass data to.

@param				aPlugins the list of plugins in the chain.

@return				the first plugin in the chain. If there is no chain

					the client is returned.

*/

	{

	// Start with the last plugin first and point it to the callback passed.

	// Then work you way up the chain, ending with the Parser calling the first plugin.

	TInt count = aPlugins.Count();

    MContentHandler* callback = &aCallback;

	while (count>0)

		{

		callback = ConstructPluginInReverseL(aPlugins[--count], *callback);

		}

	return (callback);

	}

void TParserImpl::DestroyChain()

/**

Destroys the client and the chain of plugins not including the parser.

@post				The chain and client are destroyed and parsing

					cannot take place.

*/

	{

	TInt count = iDtorKeyAndPluginList.Count();

	while (count)

		{

		DestroyContentProcessorPtrMapping(iDtorKeyAndPluginList[--count]);

		}

	iDtorKeyAndPluginList.Reset();

	}

MParser* TParserImpl::ConstructParserL(const CMatchData& aCriteria, 

							   		   MContentHandler& aCallback)

/**

This method constructs a MParser derived object.

@return				A pointer to the parser found.

@leave				KErrXmlParserPluginNotFound If ECom fails to find 

					the object a leave occurs.

@leave				KErrArgument If CMatchData is lacking mandatory mime type field.

@param				aCriteria Detailed criteria for parser resolution.

@param				aCallback client to pass data to.

*/

	{

	TInt err;

	HBufC8* stream = NULL;

	// Check entry criteria

	if (aCriteria.MimeType() == KNullDesC8)

		{

		User::Leave(KErrArgument);

		}

	// Set resolving parameters to find a plug-in with a matching parser

	TEComResolverParams resolverParams;

	resolverParams.SetWildcardMatch(ETrue);

	stream = aCriteria.PackToBufferL();

	CleanupStack::PushL(stream);

	resolverParams.SetDataType(*stream);

	// Package up the parameters to pass

	TParserInitParams initParams;

	initParams.iCharSetConverter = iCharSetConverter;

	initParams.iContentHandler = &aCallback;

	initParams.iStringDictionaryCollection = iStringDictionaryCollection;

	initParams.iElementStack = &iElementStack;

	// do this for now until I work out what to do with the other params

	TAny* any = NULL;

	TRAP(err, any = REComSession::CreateImplementationL(KParserInterfaceUid,

													iParserDtorKey, 

													(TAny*)&initParams, 

													resolverParams,

													KCustomResolverUid));

	CleanupStack::PopAndDestroy(stream);

	if (err != KErrNone)

		{

		if (err == KErrNotFound)

			{

			User::Leave(KErrXmlParserPluginNotFound);

			}

		User::Leave(err);

		}

	MParser* object = static_cast<MParser*>(any);

	return object;

	}

MContentProcessor* TParserImpl::ConstructPluginInReverseL(const TUid& aImplementationUid, 

														 MContentHandler& aCallback)

/**

This method constructs a CContentProcessor and places it in reverse order in the chain.

@return				A pointer to the plugin found.

@leave				KErrXmlPluginNotFound If ECom fails to find 

					the object a leave occurs.

@param				aImplementationUid The implementation uid of the plugin.

@param				aCallback client to pass data to.

*/

	{

	TDtorContentProcessorPtrMapping* mapping = new(ELeave) TDtorContentProcessorPtrMapping;

	mapping->iDtorKey = KNullUid;

	mapping->iContentProcessor = NULL;

	CleanupStack::PushL(TCleanupItem(DestroyContentProcessorPtrMapping, mapping));

	// Package up the parameters to pass

	TContentProcessorInitParams initParams;

	initParams.iContentHandler = &aCallback;

	initParams.iStringDictionaryCollection = iStringDictionaryCollection;

	initParams.iElementStack = &iElementStack;

	// Client knows specific implementation.

	// Pass the callback object of the next thing in the chain.

	TAny* any = NULL;

	TRAPD(err, any = REComSession::CreateImplementationL(aImplementationUid,

														 mapping->iDtorKey,

														 &initParams));

	if (err != KErrNone)

		{

		if (err == KErrNotFound)

			{

			User::Leave(KErrXmlPluginNotFound);

			}

		User::Leave(err);

		}

	mapping->iContentProcessor = static_cast<MContentProcessor*>(any);

	// We insert at the start as we are building the chain backwards, last till first.

	User::LeaveIfError(iDtorKeyAndPluginList.Insert(mapping, 0));

	CleanupStack::Pop(mapping);

	return (mapping->iContentProcessor); 

	}