// Copyright (c) 1997-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:
// Implements the default CDefaultResolver class.
// 
//

/**
 @file
 @internalComponent
*/

#include <ecom/ecom.h>
#include <ecom/ecomerrorcodes.h>
#include <ecom/ecomresolverparams.h>
#include <ecom/implementationinformation.h>

#include "TestUtilities.h"	// For __FILE__LINE__
#include "DefaultResolver.h"

CDefaultResolver* CDefaultResolver::NewL(MPublicRegistry& aRegistry)
	{
	return new(ELeave) CDefaultResolver(aRegistry);
	}

// Default d'tor

CDefaultResolver::~CDefaultResolver()
	{
	}

// Default c'tor

CDefaultResolver::CDefaultResolver(MPublicRegistry& aRegistry)
: CResolver(aRegistry)
	{
	// Do nothing here
	}


TUid CDefaultResolver::IdentifyImplementationL(TUid aInterfaceUid, 
											   const TEComResolverParams& aAdditionalParameters) const
	{
	RImplInfoArray* implementationsInfo = ListAllL(aInterfaceUid, aAdditionalParameters);
	TUid found = Resolve(*implementationsInfo, aAdditionalParameters);
	implementationsInfo->Reset();
	delete implementationsInfo;
	return found;
	}


TUid CDefaultResolver::Resolve(const RImplInfoArray& aImplementationsInfo, 
							   const TEComResolverParams& aAdditionalParameters) const
	{
	// Place to store the result if we get a wildcard match
	TUid wildMatched = KNullUid;
	TInt wildConfidence = KErrNotFound;
	const TDesC8& matchType = aAdditionalParameters.DataType();

	// Loop through the implementations matching on type
	const TInt count = aImplementationsInfo.Count();
	TBool isGenericMatch=aAdditionalParameters.IsGenericMatch();
	for(TInt index = 0; index < count; ++index)
		{
		const CImplementationInformation& impData = *aImplementationsInfo[index];
		const TDesC8& dataType = impData.DataType();

		// As soon as we get a match on the datatype then return uid of the 
		// implementation found.
		if(Match(dataType,	// The Datatype of this implementation
				 matchType,	// The type we are trying to find
				 EFalse))	// Don't use wildcards first
			{
			// We have got an exact match so return this
			return impData.ImplementationUid();
			}
		else if(isGenericMatch) // If the client wants us to use wildcards
			{
			if(Match(dataType,
					 matchType,
					 ETrue))
				{
				// We have matched using wildcards so work out a confidence value
				TInt confidence = 0;
				TInt length = Min(matchType.Length(), dataType.Length());
				while((matchType[confidence] == dataType[confidence]) && 
					  (++confidence < length))
					{
					}
				if(confidence > wildConfidence)
					{
					wildConfidence = confidence;
					wildMatched = impData.ImplementationUid();
					}
				}
			}
		}

	return wildMatched;
	}

void CloseAndDeleteRArray(TAny* aObject)
	{
	RImplInfoArray* array=reinterpret_cast<RImplInfoArray*>(aObject);
	if (array)
		array->Close();
	delete array;
	}


RImplInfoArray* CDefaultResolver::ListAllL(TUid aInterfaceUid, 
										   const TEComResolverParams& aAdditionalParameters) const
	{
	// Use the member var to create the array so that we get proper cleanup behaviour
	RImplInfoArray* retList = new (ELeave) RImplInfoArray;
	
	CleanupStack::PushL(TCleanupItem(CloseAndDeleteRArray,retList));
	RImplInfoArray& fullList = iRegistry.ListImplementationsL(aInterfaceUid);

	const TBool useWildcards = aAdditionalParameters.IsGenericMatch();
	const TDesC8& matchType = aAdditionalParameters.DataType();
	const TInt numImps = fullList.Count();
	for(TInt index = 0; index < numImps; ++index)
		{	
		if(Match(fullList[index]->DataType(), matchType, useWildcards))
			{
			User::LeaveIfError(retList->Append(fullList[index]));
			}
		}

	// Reset the member variable because we are passing ownership back
	CleanupStack::Pop();
	return retList;
	}

TBool CDefaultResolver::Match(const TDesC8& aImplementationType, 
							  const TDesC8& aMatchType, 
							  TBool aUseWildcards) const
	{
	// In this function if allowing wildcards then TDesC8::Match is used which returns 
	// the position of the match or KErrNotFound
	// If not allowing wildcards then TDesC8::Compare is used which returns a TInt which
	// indicates if one descriptor is bigger than the other (0 if they are identical)

	TBool gotMatch = ETrue;
	
	if(aMatchType.Length()!=0)
	{
		gotMatch = EFalse;
		
		_LIT8(dataSeparator, "||");
		const TInt separatorLength = dataSeparator().Length();

		// Look for the section separator marker '||'
		TInt separatorPos = aImplementationType.Find(dataSeparator);
		if(separatorPos == KErrNotFound)
			{
			// Match against the whole string
			if(aUseWildcards)
				gotMatch = aMatchType.Match(aImplementationType) != KErrNotFound;
			else
				gotMatch = aMatchType.Compare(aImplementationType) == 0;
			}
		else
			{
			// Find the first section, up to the separator
			TPtrC8 dataSection = aImplementationType.Left(separatorPos);
			TPtrC8 remainingData = aImplementationType.Mid(separatorPos + separatorLength);
			// Match against each section in turn
			while(separatorPos != KErrNotFound)
				{
				// Search this section
				if(aUseWildcards)
					gotMatch = aMatchType.Match(dataSection) != KErrNotFound;
				else
					gotMatch = aMatchType.Compare(dataSection) == 0;

				// If we found it then no need to continue, so return
				if(gotMatch)
					return ETrue;

				// Move on to the next section
				separatorPos = remainingData.Find(dataSeparator);
				if(separatorPos != KErrNotFound)
					{
					dataSection.Set(remainingData.Left(separatorPos));
					remainingData.Set(remainingData.Mid(separatorPos + separatorLength));
					}
				else
					dataSection.Set(remainingData);
				}

			// Check the final part
			if(aUseWildcards)
				gotMatch = aMatchType.Match(dataSection) != KErrNotFound;
			else
				gotMatch = aMatchType.Compare(dataSection) == 0;
			}
		}
		return gotMatch;
	}