/*
* Copyright (c) 2002-2006 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: Implementation of TDmAdUtil.
*
*/



#include <utf.h>
#include "dmadutil.h"
#include "vpnlogger.h"

//-----------------------------------------------------------------------   

DMAD_EXPORT_C TInt TDmAdUtil::DesToInt(const TDesC& aDes)
    {
    if (aDes.Length() == 0)
        {
        return 0;
        }
    TLex16 lex(aDes);
    TInt value = 0;
    if (lex.Val(value) != KErrNone)
        {
        ;
        }
    return value;
    }

DMAD_EXPORT_C TInt TDmAdUtil::DesToInt(const TDesC8& aDes)
    {
    if (aDes.Length() == 0)
        {
        return 0;
        }
    TLex8 lex(aDes);
    TInt value = 0;
    if (lex.Val(value) != KErrNone)
        {
        ;
        }
    return value;
    }

DMAD_EXPORT_C HBufC* TDmAdUtil::IntToDesLC(const TInt aInt)
    {
    HBufC* buf = HBufC::NewLC(10); //10 = max length of 32bit integer
    TPtr ptrBuf = buf->Des();
    ptrBuf.Num(aInt);
    return buf;
    }

DMAD_EXPORT_C HBufC8* TDmAdUtil::IntToDes8LC(const TInt aInt)
    {
    HBufC8* buf = HBufC8::NewLC(10); //10 = max length of 32bit integer
    TPtr8 ptrBuf = buf->Des();
    ptrBuf.Num(aInt);
    return buf;
    }

DMAD_EXPORT_C HBufC* TDmAdUtil::IntToDesLC(const TInt32 aInt32)
    {
    return IntToDesLC((TInt)aInt32);
    }
    
DMAD_EXPORT_C HBufC8* TDmAdUtil::IntToDes8LC(const TInt32 aInt32)
    {
    return IntToDes8LC((TInt)aInt32);
    }
    
//-----------------------------------------------------------------------
    
DMAD_EXPORT_C TUint TDmAdUtil::DesToUint(const TDesC& aDes)
    {
    if (aDes.Length() == 0)
        {
        return 0;
        }
    TLex16 lex(aDes);
    TUint value = 0;
    if (lex.Val(value) != KErrNone)
        {
        ;
        }
    return value;
    }

DMAD_EXPORT_C TUint TDmAdUtil::DesToUint(const TDesC8& aDes)
    {
    if (aDes.Length() == 0)
        {
        return 0;
        }
    TLex8 lex(aDes);
    TUint value = 0;
    if (lex.Val(value) != KErrNone)
        {
        ;
        }
    return value;
    }

DMAD_EXPORT_C HBufC* TDmAdUtil::IntToDesLC(const TUint aUint)
    {
    HBufC* buf = HBufC::NewLC(10); //10 = max length of 32bit integer
    TPtr ptrBuf = buf->Des();
    ptrBuf.Num(aUint);
    return buf;
    }

DMAD_EXPORT_C HBufC8* TDmAdUtil::IntToDes8LC(const TUint aUint)
    {
    HBufC8* buf = HBufC8::NewLC(10); //10 = max length of 32bit integer
    TPtr8 ptrBuf = buf->Des();
    ptrBuf.Num(aUint);
    return buf;
    }
    
DMAD_EXPORT_C HBufC* TDmAdUtil::IntToDesLC(const TUint32 aUint32)
    {
    return IntToDesLC((TUint)aUint32);
    }

DMAD_EXPORT_C HBufC8* TDmAdUtil::IntToDes8LC(const TUint32 aUint32)
    {
    return IntToDes8LC((TUint)aUint32);
    }
    
//-----------------------------------------------------------------------   
    
DMAD_EXPORT_C TPtrC8 TDmAdUtil::LastUriSeg(const TDesC8& aUri)
    {
    TInt i;
    for (i=aUri.Length()-1; i>=0; i--)
        {
        if (aUri[i] == '/')
            {
            break;
            }
        }
    if (i==0)
        {
        return aUri;
        }
    else
        {
        return aUri.Mid(i+1);
        }
    }

DMAD_EXPORT_C TPtrC8 TDmAdUtil::FirstUriSeg(const TDesC8& aUri)
    {
    TInt i;
    TBool found = EFalse;
    for (i=0; i<aUri.Length(); i++)
        {
        if (aUri[i] == '/')
            {
            found = ETrue;
            break;
            }
        }
    if (found)
        {
        return aUri.Left(i);
        }
    else
        {
        return aUri;
        }
    }

DMAD_EXPORT_C TPtrC8 TDmAdUtil::RemoveLastUriSeg(const TDesC8& aUri)
    {
    TInt i;
    for (i=aUri.Length()-1; i>=0; i--)
        {
        if (aUri[i] == '/')
            {
            break;
            }
        }
    return aUri.Left(i);
    }

DMAD_EXPORT_C TInt TDmAdUtil::NumOfURISegs(const TDesC8& aUri)
    {
    TPtrC8 uri(TDmAdUtil::RemoveDotSlash(aUri));
    TInt numOfURISegs = 1;
    for (TInt i=0; i<uri.Length(); i++)
        {
        if (uri[i] == '/')
            {
            numOfURISegs++;
            }
        }
    return numOfURISegs;
    }

DMAD_EXPORT_C TPtrC8 TDmAdUtil::RemoveDotSlash(const TDesC8& aUri)
    {
    if (aUri.Find(KDmAdUriDotSlash) == 0)
        {
        return aUri.Right(aUri.Length() - KDmAdUriDotSlash().Length());
        }
    else
        {
        return aUri;
        }
    }

DMAD_EXPORT_C TInt TDmAdUtil::CompareUris(const TDesC8& aUri1, const TDesC8& aUri2)
    {
    TPtrC8 uri1(TDmAdUtil::RemoveDotSlash(aUri1));
    TPtrC8 uri2(TDmAdUtil::RemoveDotSlash(aUri2));
    return uri1.Compare(uri2);
    }

DMAD_EXPORT_C HBufC8* TDmAdUtil::BuildUriLC(const TDesC8& aUriPath, const TDesC8& aUriSeg)
    {
    HBufC8* uri = BuildUriL(aUriPath, aUriSeg);
    CleanupStack::PushL(uri);
    return uri;
    }
    
DMAD_EXPORT_C HBufC8* TDmAdUtil::BuildUriL(const TDesC8& aUriPath, const TDesC8& aUriSeg)
    {
    HBufC8* uri = HBufC8::NewL(aUriPath.Length() + 1 + aUriSeg.Length());
    TPtr8 uriDesc = uri->Des();
    uriDesc.Copy(aUriPath);
    uriDesc.Append(KDmAdSeparator);
    uriDesc.Append(aUriSeg);
    return uri;
    }

DMAD_EXPORT_C MSmlDmAdapter::TError TDmAdUtil::MapStatusCode(TInt aStatus)
    {
    TRACE("TDmAdUtil::MapStatusCode");
    
    
    MSmlDmAdapter::TError dmStatus;
    if (aStatus == KErrNone)
        {
        dmStatus = MSmlDmAdapter::EOk;
        }
    else if (aStatus == KErrNotFound)
        {
        dmStatus = MSmlDmAdapter::ENotFound;
        }
    else if (aStatus == KErrCorrupt)
        {
        dmStatus = MSmlDmAdapter::EInvalidObject;
        }
    else if (aStatus == KErrAlreadyExists)
        {
        dmStatus = MSmlDmAdapter::EAlreadyExists;
        }
    else if (aStatus == KErrTooBig)
        {
        dmStatus = MSmlDmAdapter::ETooLargeObject;
        }
    else if (aStatus == KErrDiskFull)
        {
        dmStatus = MSmlDmAdapter::EDiskFull;
        }
    /*
                ERollbackFailed,
                EObjectInUse,
                ENoMemory,
                ECommitOK,
                ERollbackOK,
                ECommitFailed
    */
    else
        {
        dmStatus = MSmlDmAdapter::EError;
        }
    return dmStatus;
    }

DMAD_EXPORT_C void TDmAdUtil::ParseUriLC(const TDesC8& aUri, CArrayFix<TPtrC8>*& aUriSegList)
    {
    TPtrC8 uri(TDmAdUtil::RemoveDotSlash(aUri));
    
    CArrayFix<TPtrC8>* uriSegList;
    uriSegList = new (ELeave) CArrayFixFlat<TPtrC8>(8);
    CleanupStack::PushL(uriSegList);

    TPtrC8 seg;
    TPtrC8 curr(uri);

    while (curr.Length() > 0)
        {
        TInt offset = curr.Locate('/');
        if (offset == KErrNotFound)
            {
            seg.Set(curr);
            curr.Set(KNullDesC8);
            }
        else
            {
            seg.Set(curr.Left(offset));
            TInt rightLth = curr.Length() - offset - 1;
            if (rightLth <= 0)           
                {
                DEBUG_LOG(_L("TDmAdUtil::ParseUriLC: corrupted uri"));
                DEBUG_LOG1(_L8("URI: %S"), &aUri);
                
                User::Leave(KErrGeneral);
                }
            curr.Set(curr.Right(rightLth));
            }
        uriSegList->AppendL(seg);
        }
    
    aUriSegList = uriSegList;
    }

DMAD_EXPORT_C HBufC8* TDmAdUtil::LuidTo8L(const TDesC& aLuid16)
    {
    HBufC8* luid8 = HBufC8::NewL(aLuid16.Length());
    luid8->Des().Copy(aLuid16);
    return luid8;
    }
    
DMAD_EXPORT_C HBufC* TDmAdUtil::LuidTo16L(const TDesC8& aLuid8)
    {
    HBufC* luid16 = HBufC::NewL(aLuid8.Length());
    luid16->Des().Copy(aLuid8);
    return luid16;
    }

//-----------------------------------------------------------------------   
    
DMAD_EXPORT_C void TDmAdUtil::FillNodeInfoL(MSmlDmDDFObject&               aNode,
                                            TSmlDmAccessTypes              aAccTypes,
                                            MSmlDmDDFObject::TOccurence    aOccurrence,
                                            MSmlDmDDFObject::TScope        aScope,
                                            MSmlDmDDFObject::TDFFormat     aFormat,
                                            const TDesC8&                  aDescription,
                                            TBool                          aObjectGroup,
                                            const TDesC8&                  aMimeType)
{
    aNode.SetAccessTypesL(aAccTypes);
    aNode.SetOccurenceL(aOccurrence);
    aNode.SetScopeL(aScope);
    aNode.SetDFFormatL(aFormat);

    if (aMimeType.Length() > 0)
        {
        aNode.AddDFTypeMimeTypeL(aMimeType);
        }

    aNode.SetDescriptionL(aDescription);

    (void)aObjectGroup;
    }

DMAD_EXPORT_C MSmlDmDDFObject& TDmAdUtil::AddChildObjectL(MSmlDmDDFObject& aNode, const TDesC8& aNodeName)
    {
    if (aNodeName.Length() == 0)
        {
        MSmlDmDDFObject& object = aNode.AddChildObjectGroupL();
        return object;
        }
    else
        {
        MSmlDmDDFObject& object = aNode.AddChildObjectL(aNodeName);
        return object;
        }
    }

DMAD_EXPORT_C HBufC8* TDmAdUtil::BuildLocallyCreatedRtNodeUriSegLC(TInt& aLargest)
    {
    ++aLargest;
    HBufC8* number = TDmAdUtil::IntToDes8LC(aLargest);
    HBufC8* uri = HBufC8::NewL(KDmAdLocallyCreatedRtNodeUriSegPrefix().Length() + number->Length());
    uri->Des().Copy(KDmAdLocallyCreatedRtNodeUriSegPrefix);
    uri->Des().Append(*number);
    CleanupStack::PopAndDestroy(); // number
    CleanupStack::PushL(uri);
    return uri;
    }

TInt TDmAdUtil::FindLargestLocallyCreated(const CArrayFix<TSmlDmMappingInfo>& aPreviousUriSegmentList)
    {
    TRACE("TDmAdUtil::FindLargestLocallyCreated");
    TInt largest = 0;
    for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++)
        {
        const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i);        
        if (mappingInfo.iURISeg.Find(KDmAdLocallyCreatedRtNodeUriSegPrefix) == 0)
            {            
            TPtrC8 numberPart(mappingInfo.iURISeg.Mid(KDmAdLocallyCreatedRtNodeUriSegPrefix().Length()));
            TInt number = TDmAdUtil::DesToInt(numberPart);
            if (number > largest)
                {
                largest = number;
                }
            }
        }
    return largest;
    }
    
    
void PointerArrayCleanup(TAny* item)
    {
    RPointerArray<HBufC8>* a = static_cast<RPointerArray<HBufC8>*>(item);
    a->ResetAndDestroy();
    a->Close();
    }


#define DMAD_DUMP_PREVIOUS_URI_SEGMENT_LIST
    
DMAD_EXPORT_C void TDmAdUtil::BuildRtNodeChildUriListL(MDmAdCallBack*                          aDmAdCallBack,
                                                  MDmAdStoreApi*                          aStoreApi,
                                                  const TDesC8&                           aUri,
                                                  const TDesC8&                           aParentLuid,
                                                  const CArrayFix<TSmlDmMappingInfo>&     aPreviousUriSegmentList,
                                                  CBufBase&                               aCurrentList)
    {
#ifdef DMAD_DUMP_PREVIOUS_URI_SEGMENT_LIST
        DEBUG_LOG(_L("BuildRtNodeChildUriListL:"));
        {
        for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++)
            {
            const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i);
                        
            DEBUG_LOG1(_L("entry %d:"), i);            
            DEBUG_LOG1(_L8("Uri: %S"), &(mappingInfo.iURISeg));
            DEBUG_LOG_HEX(mappingInfo.iURISegLUID);
            
            }
        }
#endif

    RPointerArray<HBufC8> luidList;
    CleanupStack::PushL(TCleanupItem(PointerArrayCleanup, &luidList));
    
    aStoreApi->LuidListL(aUri, aParentLuid, luidList);


    // Finds largest number used in cli<x> named nodes.
    TInt largest = FindLargestLocallyCreated(aPreviousUriSegmentList);
    DEBUG_LOG1(_L("largest is cli%d"), largest);
    
    TInt countLuidList = luidList.Count();
    for (TInt j=0; j < countLuidList; j++)
        {
        const HBufC8* luidElem = luidList[j];

        HBufC8* uriSeg = 0;
        
        //Tries to find the luid from the aPreviousUriSegmentList
        for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++)
            {
            const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i);
                        
            if (mappingInfo.iURISegLUID.Compare(*luidElem) == 0)
                {            
                uriSeg = mappingInfo.iURISeg.AllocLC();
                break;
                }
            }
        
        if (uriSeg == 0)
            {
            //Uri was not found from the aPreviousUriSegmentList
            uriSeg = BuildLocallyCreatedRtNodeUriSegLC(largest);
            
            DEBUG_LOG2(_L8("uriSeg %S, largest %d"), uriSeg, largest);
            
            HBufC8* wholeUri = TDmAdUtil::BuildUriLC(aUri, *uriSeg);            
            aDmAdCallBack->SetMappingL(*wholeUri, *luidElem);
            CleanupStack::PopAndDestroy(); //wholeUri
            }

        //If this is not the first element, inserts slash at the beginning
        //of the result list.
        if (j > 0)
            {            
            aCurrentList.InsertL(aCurrentList.Size(), KDmAdSeparator);
            }
        aCurrentList.InsertL(aCurrentList.Size(), *uriSeg);
        
        CleanupStack::PopAndDestroy(); // uriSeg
        }
    
    CleanupStack::PopAndDestroy(); //luidList
    }