/*
 * 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
 *
 */

#include "nsmldmiapmatcher.h"

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

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

// -----------------------------------------------------------------------------
// CNSmlDMIAPMatcher* CNSmlDMIAPMatcher::NewLC( MSmlDmCallback* aDmCallback )
// -----------------------------------------------------------------------------
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;
    }

// -----------------------------------------------------------------------------
// CNSmlDMIAPMatcher::~CNSmlDMIAPMatcher()
// -----------------------------------------------------------------------------
CNSmlDMIAPMatcher::~CNSmlDMIAPMatcher()
    {
    }

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

    MSmlDmAdapter::TError status;
    CBufBase* allIAPs = CBufFlat::NewL(16);
    CleanupStack::PushL(allIAPs);
    iCallback->FetchLinkL(KNSmlDMIAPUri, *allIAPs, status);
    TPtrC8 uri = RemoveDotSlash(aURI);

    if (status == MSmlDmAdapter::EOk && uri.Find(KNSmlDMIAPUri) == 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 )
// -----------------------------------------------------------------------------
HBufC8* CNSmlDMIAPMatcher::URIFromIAPIdL(TInt aIAPId)
    {
    CBufBase *allIAPs = CBufFlat::NewL(16);
    CleanupStack::PushL(allIAPs);
    MSmlDmAdapter::TError status;

    iCallback->FetchLinkL(KNSmlDMIAPUri, *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(KNSmlDMIAPUri().Length() + 1 + uriSeg->Length() );

            TPtr8 uriPtr = uri->Des();
            uriPtr.Format(KNSmlDMIAPUri);
            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) const
    {
    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;
        }
    }

// -----------------------------------------------------------------------------
// 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);
        }
    }