/*
* 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:  DM Tree module
*
*/


// ------------------------------------------------------------------------------------------------
// Includes
// ------------------------------------------------------------------------------------------------

#include <utf.h>
#include <nsmldmiapmatcher.h>
#include <smldmadapter.h>
#include <featmgr.h>

// ------------------------------------------------------------------------------------------------
// CNSmlDMIAPMatcher* CNSmlDMIAPMatcher::NewL( MSmlDmCallback* aDmCallback )
// ------------------------------------------------------------------------------------------------
EXPORT_C CNSmlDMIAPMatcher* CNSmlDMIAPMatcher::NewL( 
	MSmlDmCallback* aDmCallback )
    {
    CNSmlDMIAPMatcher* self = CNSmlDMIAPMatcher::NewLC( aDmCallback );	
    CleanupStack::Pop();
    return self;
    }

// ------------------------------------------------------------------------------------------------
// CNSmlDMIAPMatcher* CNSmlDMIAPMatcher::NewLC( MSmlDmCallback* aDmCallback )
// ------------------------------------------------------------------------------------------------
EXPORT_C CNSmlDMIAPMatcher* CNSmlDMIAPMatcher::NewLC(
	MSmlDmCallback* aDmCallback )
    {
    CNSmlDMIAPMatcher* self = new( ELeave ) CNSmlDMIAPMatcher;
    CleanupStack::PushL( self );
    self->ConstructL( aDmCallback );
    return self;
    }

// ------------------------------------------------------------------------------------------------
// void CNSmlDMIAPMatcher::ConstructL( MSmlDmCallback* aDmCallback )
// ------------------------------------------------------------------------------------------------
void CNSmlDMIAPMatcher::ConstructL( MSmlDmCallback* aDmCallback )
    {
    iCallback = aDmCallback;
    FeatureManager::InitializeLibL();
    iFeatMgrInitialized = ETrue;
    }

// ------------------------------------------------------------------------------------------------
// CNSmlDMIAPMatcher::~CNSmlDMIAPMatcher()
// ------------------------------------------------------------------------------------------------
CNSmlDMIAPMatcher::~CNSmlDMIAPMatcher()
    {
    	if(iFeatMgrInitialized)
    		{
    			FeatureManager::UnInitializeLib();
    		}
    }

// ------------------------------------------------------------------------------------------------
// TInt CNSmlDMIAPMatcher::IAPIdFromURIL( const TDesC8& aURI )
// ------------------------------------------------------------------------------------------------
EXPORT_C TInt CNSmlDMIAPMatcher::IAPIdFromURIL( const TDesC8& aURI )
    {
    TInt iapId(KErrNotFound);

	MSmlDmAdapter::TError status;
	CBufBase* allIAPs = CBufFlat::NewL(16);
	CleanupStack::PushL(allIAPs);
	iCallback->FetchLinkL( GetConRef(), *allIAPs, status );
	TPtrC8 uriSlash = RemoveDotSlash(aURI);
	TPtrC8 uri = RemoveExtraChar(uriSlash);
	
    if( status == MSmlDmAdapter::EOk &&
        uri.Find(GetConRef()) == 0 &&
        allIAPs->Ptr(0).Find(LastURISeg(uri))>=0)
        {
        HBufC8* luid = iCallback->GetLuidAllocL( uri ); 

        if ( luid->Length() )
            {
            iapId = DesToInt(*luid);
            } 
        delete luid;
        }

    CleanupStack::PopAndDestroy(allIAPs);
    
    return iapId;
    }

// ------------------------------------------------------------------------------------------------
// HBufC8* CNSmlDMIAPMatcher::URIFromIAPIdL( TInt aIAPId )
// ------------------------------------------------------------------------------------------------
EXPORT_C HBufC8* CNSmlDMIAPMatcher::URIFromIAPIdL( TInt aIAPId )
    {
    CBufBase *allIAPs = CBufFlat::NewL(16);
	CleanupStack::PushL(allIAPs);
    MSmlDmAdapter::TError status;

    iCallback->FetchLinkL( GetConRef(), *allIAPs, status );

    if ( status == MSmlDmAdapter::EOk )
        {   
        TInt index(0);
        TInt segStart(0);

        while ( index != KErrNotFound)
            {                
            TPtrC8 allIAPsptr = allIAPs->Ptr(segStart).Mid(0);
            index = allIAPsptr.Locate('/');
            HBufC8* uriSeg = 0;

            if ( index == KErrNotFound )
                {
                TPtrC8 uriSeg8Ptr = allIAPs->Ptr(segStart);
                uriSeg = uriSeg8Ptr.AllocLC();
                }
            else
                {
                TPtrC8 uriSeg8Ptr = allIAPs->Ptr(segStart).Mid( 0, index );
                uriSeg = uriSeg8Ptr.AllocLC();
                }

            HBufC8* uri = HBufC8::NewLC( GetConRef().Length() + 1 +
            	uriSeg->Length() );
            	
			TPtr8 uriPtr = uri->Des();
			uriPtr.Format( GetConRef());
			uriPtr.Append( KNSmlDMSeparator8 );
			uriPtr.Append( *uriSeg );
			HBufC8* luid = iCallback->GetLuidAllocL( uriPtr );
			CleanupStack::PushL(luid);

			if ( luid->Length() > 0 )
				{				
				TInt iapId = DesToInt(luid->Des());
				if ( iapId == aIAPId )
					{
		            CleanupStack::PopAndDestroy();  //luid
		            CleanupStack::Pop();  //uri
		            CleanupStack::PopAndDestroy(2);  //uriSeg, allIAPs
		            return uri;
					}
				}
            CleanupStack::PopAndDestroy(3); // luid, uri, uriSeg

            segStart += index + 1;
            }        
        }

    CleanupStack::PopAndDestroy(); // allIAPs

    return 0;
    }

// ------------------------------------------------------------------------------------------------
// TInt CNSmlDMIAPMatcher::DesToInt(const TDesC& aLuid)
// ------------------------------------------------------------------------------------------------
TInt CNSmlDMIAPMatcher::DesToInt(const TDesC8& aLuid)
	{
	TLex8 lex(aLuid);
	TInt value = 0;
	lex.Val(value);
	return value;
	}

// ------------------------------------------------------------------------------------------------
// TPtrC8 CNSmlDMIAPMatcher::RemoveDotSlash(const TDesC8& aURI) const
// ------------------------------------------------------------------------------------------------
TPtrC8 CNSmlDMIAPMatcher::RemoveDotSlash(const TDesC8& aURI) const
	{
	if(aURI.Find(KNSmlDMIAPUriDotSlash)==0)
		{
		return aURI.Right( aURI.Length()-KNSmlDMIAPUriDotSlash().Length() );
		}
	else
		{
		return aURI;
		}
	}

// ------------------------------------------------------------------------------------------------
// TPtrC8 CNSmlDMIAPMatcher::RemoveExtraChar(const TDesC8& aURI) const
// ------------------------------------------------------------------------------------------------
TPtrC8 CNSmlDMIAPMatcher::RemoveExtraChar(const TDesC8& aURI) const
	{
	const TUint8 KNSmlDMUriSeparator = '/';
	const TUint8 KNSmlDMUriDot = '.';	
	
	TInt len = aURI.Length();
	if(len > 0)
	{
	if((aURI[0]==KNSmlDMUriSeparator) || (aURI[0]==KNSmlDMUriDot))
	{
		if((aURI[aURI.Length()-1]==KNSmlDMUriSeparator) && (len > 2))
		{
			return aURI.Mid(1,len-2);
		}
		else
			return aURI.Right(len-1);
	}
	else if(aURI[aURI.Length()-1]==KNSmlDMUriSeparator)
		{
		return aURI.Left( len -1 );
		}
	else
		return aURI;			
	}
	else
		return aURI;
	}

// ------------------------------------------------------------------------------------------------
// CNSmlDMIAPMatcher::TPtrC8 LastURISeg(const TDesC8& aURI)
// Returns only the last uri segemnt
// ------------------------------------------------------------------------------------------------
TPtrC8 CNSmlDMIAPMatcher::LastURISeg(const TDesC8& aURI) const
	{
	TInt i;
	for(i=aURI.Length()-1;i>=0;i--)
		{
		if(aURI[i]==KNSmlDMSlash)
			{
			break;
			}
		}
	if(i==0)
		{
		return aURI;
		}
	else
		{
		return aURI.Mid(i+1);
		}
	}

// ------------------------------------------------------------------------------------------------
// CNSmlDMIAPMatcher::const TDesC8& GetConRef()
// Returns the connection reference
// ------------------------------------------------------------------------------------------------
const TDesC8& CNSmlDMIAPMatcher::GetConRef()
	{
	if(FeatureManager::FeatureSupported(KFeatureIdFfDmConnmoAdapter))
		{
			return KNSmlDMConnMOIAPUri();
		}
	else
		{
			return KNSmlDMIAPUri();
		}	
  }	

// End of file