/*
 * ==============================================================================
 * Copyright (c) 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 <e32base.h>
#include <utf.h>
#include <cmpluginpacketdatadef.h>

#include "Utils.h"
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "UtilsTraces.h"
#endif

// ======== LOCAL CONSTANTS =========

_LIT8( KFalse,               "False" );
_LIT8( KTrue,                "True" );
_LIT8( KWhiteSpace,          " " );

// ======== LOCAL FUNCTIONS =========

// ======== MEMBER FUNCTIONS ========   
//------------------------------------------------------------------------------
// CUtils::CUtils()
//------------------------------------------------------------------------------
CUtils::CUtils() 
    {
    OstTraceFunctionEntry0( CUTILS_CUTILS_ENTRY );
    OstTraceFunctionExit0( CUTILS_CUTILS_EXIT );
    }

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

//------------------------------------------------------------------------------
// TPtrC8 CUtils::GetFirstURISeg(const TDesC8& aURI)
//------------------------------------------------------------------------------
TPtrC8 CUtils::GetFirstURISeg( const TDesC8& aURI )
    {
    OstTraceExt1( TRACE_NORMAL, CUTILS_GETFIRSTURISEG_ENTRY, 
                  "ENTRY: CUtils::GetFirstURISeg;aURI=%s", aURI );
    
    TInt i = 0;
    TInt j = 0;
    
    for( i  =0; i <= aURI.Length()-1; i++ )
        {
        if( aURI[i] == '/' )
            {
            if ( i == 0 )
                {
                // Skip first slash
                j = 1;
                continue;
                }
            break;
            }
        }
    OstTraceExt1( TRACE_NORMAL, CUTILS_GETFIRSTURISEG_EXIT, 
                  "EXIT: CUtils::GetFirstURISeg;retval=%s", aURI.Mid( j,i-j ) );
    
    return aURI.Mid( j,i-j );
    }

//------------------------------------------------------------------------------
// TPtrC8 CUtils::GetSecondURISeg(const TDesC8& aURI)
//------------------------------------------------------------------------------
TPtrC8 CUtils::GetSecondURISeg( const TDesC8& aURI )
    {
    OstTraceExt1( TRACE_NORMAL, CUTILS_GETSECONDURISEG_ENTRY, 
                  "ENTRY: CUtils::GetSecondURISeg;aURI=%s", aURI );
    
    TInt j = 0;
    TInt i = 0;
    
    for( i = 0; i <= aURI.Length() - 1; i++ )
        {
        if( aURI[i] == '/' )
            {
            for( j = i + 1; j <= aURI.Length() - 1; j++ )
                {
                if( aURI[j] == '/' ) // Second slash => AP/xxxx
                    {
                    break;
                    }
                }
            break;
            }
        }
    OstTraceExt1( TRACE_NORMAL, CUTILS_GETSECONDTURISEG_EXIT, 
                  "EXIT: CUtils::GetSecondURISeg;retval=%s", aURI.Mid( i+1, j-1-i ) );
    
    return aURI.Mid( i+1, j-1-i );
    }

//------------------------------------------------------------------------------
// TPtrC8 CUtils::GetLastURISeg(const TDesC8& aURI)
// Returns only the last uri segment
//------------------------------------------------------------------------------
TPtrC8 CUtils::GetLastURISeg( const TDesC8& aURI )
    {
    OstTraceExt1( TRACE_NORMAL, CUTILS_GETLASTURISEG_ENTRY, 
                  "ENTRY: CUtils::GetLastURISeg;aURI=%s", aURI );
    
    TInt i;
    
    for( i = aURI.Length() - 1 ; i >= 0; i-- )
        {
        if( aURI[i] == '/' )
            {
            break;
            }
        }
    if( i == 0 )
        {
        OstTraceExt1( TRACE_NORMAL, CUTILS_GETLASTURISEG_EXIT, 
                      "EXIT: CUtils::GetLastURISeg;retval=%s", aURI );
        return aURI;
        }
    else
        {
        OstTraceExt1( TRACE_NORMAL, CUTILS_GETLASTURISEG_EXIT2, 
                      "EXIT: CUtils::GetLastURISeg;retval=%s", aURI.Mid( i+1 ) );
        return aURI.Mid( i+1 );
        }
    }

//------------------------------------------------------------------------------
// TPtrC8 CUtils::GetEndOfURIFromSeg(const TDesC8& aURI,const TDesC8 aName)
// Returns the end of aURI starting from aName
//------------------------------------------------------------------------------
TPtrC8 CUtils::GetEndOfURIFromSeg( const TDesC8& aURI, const TDesC8& aName )
    {
    OstTraceExt2( TRACE_NORMAL, CUTILS_GETENDOFURIFROMSEG_ENTRY, 
                  "ENTRY: CUtils::GetEndOfURIFromSeg;aURI=%s;aName=%s", aURI, aName );
    
    TInt begin = aURI.Find( aName );
    
    if ( begin == KErrNotFound )
        {
        OstTrace1( TRACE_NORMAL, CUTILS_GETENDOFURIFROMSEG_EXIT, 
                   "EXIT: CUtils::GetEndOfURIFromSeg;%d", KErrNotFound );
        return aURI;
        }
    OstTraceExt1( TRACE_NORMAL, CUTILS_GETENDOFURIFROMSEG_EXIT2, 
                  "EXIT: CUtils::GetEndOfURIFromSeg;%s", aURI.Mid(begin) );    
    return aURI.Mid(begin);
    }

//------------------------------------------------------------------------------
// CUtils::ConvertTo8LC()
// Converts string value to 8-bit
//------------------------------------------------------------------------------
TDesC8& CUtils::ConvertTo8LC( const TDesC& aSource )
    {
    HBufC8* buf = HBufC8::NewLC( aSource.Length() * 2 );
    TPtr8 bufPtr = buf->Des();
    CnvUtfConverter::ConvertFromUnicodeToUtf8( bufPtr, aSource );

    return *buf;
    }

//------------------------------------------------------------------------------
// CUtils::ConvertTo16LC()
// Converts string value to 16-bit      
//------------------------------------------------------------------------------
TDesC16& CUtils::ConvertTo16LC( const TDesC8& aSource )
    {
    HBufC16* buf16 = HBufC16::NewLC( aSource.Length() );
    TPtr bufPtr16 = buf16->Des();

    CnvUtfConverter::ConvertToUnicodeFromUtf8( bufPtr16, aSource );

    return *buf16;
    }

// -------------------------------------------------------------------------------------
// CUtils::FillNodeInfoL()
// Fills the node info in ddf structure
// -------------------------------------------------------------------------------------
void CUtils::FillNodeInfoL( MSmlDmDDFObject& aNode,
                            TSmlDmAccessTypes aAccTypes,
                            MSmlDmDDFObject::TOccurence aOccurrence, 
                            MSmlDmDDFObject::TScope aScope, 
                            MSmlDmDDFObject::TDFFormat aFormat,
                            const TDesC8& aDescription )
                                          
    {
    aNode.SetAccessTypesL( aAccTypes );
    aNode.SetOccurenceL( aOccurrence );
    aNode.SetScopeL( aScope );
    aNode.SetDFFormatL( aFormat );
    if( aFormat != MSmlDmDDFObject::ENode )
        {
        // aNode.AddDFTypeMimeTypeL(KNSmlMimeType);
        }
    if ( aDescription != KNullDesC8 )
        {
        aNode.SetDescriptionL( aDescription );
        }
    }

// -------------------------------------------------------------------------------------
// CUtils::StripWhiteSpaces()
// Removes all white spaces from a string
// -------------------------------------------------------------------------------------
void CUtils::RemoveIllegalCharsFromURI( TDes8& aString )
    {
    TInt delPos;
    TInt delLen = 1;
    
    aString.TrimAll();
    delPos = aString.Find( KWhiteSpace );
    while ( delPos != KErrNotFound )
        {
        aString.Delete( delPos,delLen );
        delPos = aString.Find( KWhiteSpace );
        }
    }

// -------------------------------------------------------------------------------------
// TInt CUtils::DesCToBool
// -------------------------------------------------------------------------------------
TInt32 CUtils::DesToBool( const TDesC8& aSource, TBool& aBool )
    {
    TInt retval( KErrNone );
    
    if ( aSource.Match( KTrue ) != KErrNotFound )
        {
        aBool = ETrue;
        }
    else if ( aSource.Match( KFalse ) != KErrNotFound )
        {
        aBool = EFalse;
        }
    else
        {
        retval = KErrGeneral;
        }
        
    return retval;
    }

// -------------------------------------------------------------------------------------
// CUtils::IntToCharL()
// -------------------------------------------------------------------------------------
TDesC8& CUtils::IntToCharL( const TInt& aObject )
    {
    HBufC8* buf = HBufC8::NewLC( 8 );
    TPtr8 ptrBuf = buf->Des();

    ptrBuf.Num( aObject );

    return *buf;
    }
//------------------------------------------------------------------------------
// TPtrC8 CUtils::AppendFirstURISeg( TDes8& aURI, TDes8& aTarget )
//------------------------------------------------------------------------------
TInt CUtils::AppendFirstURISeg( TDes8& aURI, TDes8& aTarget )
    {
    
    TInt i = aURI.FindC(_L8("/"));
    
    if ( i != KErrNotFound )
        {
        aTarget.Append( aURI.Left( i ) );
        aURI.Copy( aURI.Right( aURI.Length() - i - 1 ) );
        }
    else
        {
        aTarget.Copy( aURI );
        aURI.Copy( aURI.Right( 0 ) );
        }
    
    return i;
    }

//=============================================
//      CUtils::IntLUID()
//      Returns IntValue for aLUID
//=============================================
TInt CUtils::IntLUID(const TDesC8& aLUID)
    {
    TInt ret(0);

    TLex8 lex(aLUID);
    
    lex.Val( ret );
    
    return ret;
    }