/*

* Copyright (c) 2008 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 "csvtsipuriparser.h"

#include "svtphonenumbervalidator.h"

_LIT( KColon, ":");

_LIT( KAtSign, "@");

_LIT( KLeftElbow, "<" );

_LIT( KRightElbow, ">" );

// ======== MEMBER FUNCTIONS ========

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

// CSvtSipUriParser::CSvtSipUriParser

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

//

CSvtSipUriParser::CSvtSipUriParser( TDomainPartClippingSetting aOptions )

    :

    iOptions( aOptions )

    {

    }

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

// CSvtSipUriParser::ConstructL

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

//

void CSvtSipUriParser::ConstructL( const TDesC& aSipUri )

    {

    ParseSipUriL( aSipUri );

    }

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

// CSvtSipUriParser::NewL

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

//

CSvtSipUriParser* CSvtSipUriParser::NewL( const TDesC& aSipUri,

        TDomainPartClippingSetting aOptions )

    {

    CSvtSipUriParser* self = CSvtSipUriParser::NewLC( aSipUri, aOptions );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSvtSipUriParser::NewLC

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

//

CSvtSipUriParser* CSvtSipUriParser::NewLC( const TDesC& aSipUri,

        TDomainPartClippingSetting aOptions )

    {

    CSvtSipUriParser* self = new( ELeave ) CSvtSipUriParser( aOptions );

    CleanupStack::PushL( self );

    self->ConstructL( aSipUri );

    return self;

    }

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

// CSvtSipUriParser::~CSvtSipUriParser

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

//

CSvtSipUriParser::~CSvtSipUriParser()

    {

    iUserName.Close();

    iDomain.Close();

    iDisplayName.Close();

    }

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

// CSvtSipUriParser::GetVoipAddress

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

//

TInt CSvtSipUriParser::GetVoipAddress( RBuf& aVoipAddress ) const

    {

    aVoipAddress = KNullDesC();

    if ( IsAnonymousUri( iUserName ) )

        {

        return KErrNone;

        }

    TInt result( KErrNone );

    TInt addressLength = AddressLength( iUserName, iDomain, iOptions );

    if ( aVoipAddress.MaxLength() < addressLength )

        {

        result = aVoipAddress.ReAlloc( addressLength );

        }

    if ( KErrNone == result )

        {

        aVoipAddress.Append( iUserName );

        if ( iUserName.Length() < addressLength )

            {

            // domain part clipping isn't used

            aVoipAddress.Append( KAtSign() );

            aVoipAddress.Append( iDomain );

            }

        }

    return result;

    }

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

// CSvtSipUriParser::GetPhoneNumber

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

//

TInt CSvtSipUriParser::GetPhoneNumber( RBuf& aPhoneNumber ) const

    {

    aPhoneNumber = KNullDesC();

    TInt result( KErrNone );

    if ( SvtPhoneNumberValidator::IsValidNumber( iUserName ) 

            && ( ENoClipping != iOptions ) )

        {

        if ( aPhoneNumber.MaxLength() < iUserName.Length() )

            {

            result = aPhoneNumber.ReAlloc( iUserName.Length() );

            }

        if ( KErrNone == result )

            {

            aPhoneNumber.Append( iUserName );

            }        

        }

    return result;

    }

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

// CSvtSipUriParser::GetDisplayName

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

//

TInt CSvtSipUriParser::GetDisplayName( RBuf& aDisplayName ) const

    {

    aDisplayName = KNullDesC();

    TInt result( KErrNone );

    if ( aDisplayName.MaxLength() < iDisplayName.Length() )

        {

        result = aDisplayName.ReAlloc( iDisplayName.Length() );

        }

    if ( KErrNone == result )

        {

        aDisplayName = iDisplayName;

        }

    return result;

    }

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

// CSvtSipUriParser::ParseSipUriL

// Accepted URI forms are: [schema:]user@host[:port] and 

// displayname <[schema:]user@host[:port]>. URI parameters and headers are 

// ripped off in MCE & SVP.

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

//

void CSvtSipUriParser::ParseSipUriL( const TDesC& aSipUri )

    {

    if ( IsAnonymousUri( aSipUri ) )

        {

        ParsePrivateAddress();

        }

    else

        {

        RBuf sipUri( aSipUri.AllocL() );

        CleanupClosePushL( sipUri );

        // remove trailing and leading white spaces from input uri

        sipUri.TrimAll();

        ParseDisplayNameL( sipUri );

        RemoveElbows( sipUri );

        ParseUserNameL( sipUri );

        ParseDomainL( sipUri );

        CleanupStack::PopAndDestroy( &sipUri );

        }

    }

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

// CSvtSipUriParser::ParseDisplayNameL

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

//

void CSvtSipUriParser::ParseDisplayNameL( const TDesC& aSipUri )

    {

    iDisplayName.Close();

    TInt leftElbowIndex = aSipUri.Find( KLeftElbow );

    TInt rightElbowIndex = aSipUri.Find( KRightElbow );

    if ( ( 0 < leftElbowIndex ) && ( KErrNotFound != rightElbowIndex ) )

        {

        // display name is available

        iDisplayName.Assign( aSipUri.Left( leftElbowIndex ).AllocL() );

        // remove whitespace around display name

        iDisplayName.TrimAll();

        // remove quatation marks around display name

        _LIT( KQuatationMark, "\"");

        if ( iDisplayName.Length() && iDisplayName[0] == '"' )

            {

            iDisplayName.Delete( 0, KQuatationMark().Length() );

            }

        if ( iDisplayName.Length() 

                && iDisplayName[iDisplayName.Length() - 1] == '"')

            {

            iDisplayName.Delete( 

                iDisplayName.Length() - 1, KQuatationMark().Length() );

            }

        }

    }

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

// CSvtSipUriParser::RemoveElbows

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

//

void CSvtSipUriParser::RemoveElbows( TDes& sipUri ) const

    {

    TInt leftElbowIndex = sipUri.Find( KLeftElbow );

    if ( KErrNotFound != leftElbowIndex )

        {

        sipUri.Delete( leftElbowIndex, KLeftElbow().Length() );

        }

    TInt rightElbowIndex = sipUri.Find( KRightElbow );

    if ( KErrNotFound != rightElbowIndex )

        {

        sipUri.Delete( rightElbowIndex, KRightElbow().Length() );

        }

    }

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

// CSvtSipUriParser::ParseUserNameL

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

//

void CSvtSipUriParser::ParseUserNameL( const TDesC& aSipUri )

    {

    // If uri does not specify schema, user name starts from the beginning of

    // the uri. Otherwise additional calculations are done.

    TInt userNameStartInd = 0;

    TInt indexOfColon = aSipUri.Find( KColon() );

    if ( KErrNotFound != indexOfColon )

        {

        userNameStartInd = aSipUri.Find( KColon() ) + KColon().Length();

        __ASSERT_ALWAYS( KColon().Length() <= userNameStartInd, 

            User::Leave( KErrArgument ) );

        }

    TInt userNameEndInd = aSipUri.Find( KAtSign() ) - KAtSign().Length();

    __ASSERT_ALWAYS( 0 <= userNameEndInd, User::Leave( KErrArgument ) );

    TInt userNameLength = ( userNameEndInd - userNameStartInd ) + 1;

    __ASSERT_ALWAYS( 0 < userNameLength, User::Leave( KErrArgument ) );

    iUserName.Close();

    iUserName.Assign( aSipUri.Mid( userNameStartInd, userNameLength ).AllocL() );

    }

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

// CSvtSipUriParser::ParseDomainL

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

//

void CSvtSipUriParser::ParseDomainL( const TDesC& aSipUri )

    {

    TInt hostNameStartInd = aSipUri.Find( KAtSign() ) + KAtSign().Length();

    __ASSERT_ALWAYS( KAtSign().Length() <= hostNameStartInd, 

        User::Leave( KErrArgument ) );

    TInt hostNameEndInd = aSipUri.Length() - 1;

    TInt hostNameLength = ( hostNameEndInd - hostNameStartInd ) + 1;

    __ASSERT_ALWAYS( 0 < hostNameLength, User::Leave( KErrArgument ) );

    iDomain.Close();

    iDomain.Assign( aSipUri.Mid( hostNameStartInd, hostNameLength ).AllocL() );

    }

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

// CSvtSipUriParser::ParsePrivateAddress

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

//

void CSvtSipUriParser::ParsePrivateAddress()

    {

    iUserName.Close();

    iUserName = KNullDesC();

    iDomain.Close();

    iDomain = KNullDesC();

    }

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

// CSvtSipUriParser::AddressLength

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

//

TInt CSvtSipUriParser::AddressLength( const TDesC& aUserName, 

        const TDesC& aDomain, TDomainPartClippingSetting aClipSetting ) const

    {

    TInt addressLength( 0 );

    TBool isPhoneNumber( SvtPhoneNumberValidator::IsValidNumber( aUserName ) );

    switch ( aClipSetting )

        {

        case ENoClipping:

            addressLength = 

            aUserName.Length() + KAtSign().Length() + aDomain.Length();

            break;

        case EClipDomainIfNumber:

            addressLength = isPhoneNumber 

                ? aUserName.Length() 

                : aUserName.Length() + KAtSign().Length() + aDomain.Length();

            break;

        case EClipDomain:

            addressLength = aUserName.Length();

            break;

        default:

            ASSERT( EFalse );

        }

    return addressLength;

    }

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

// CSvtSipUriParser::IsAnonymousUri

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

//

TBool CSvtSipUriParser::IsAnonymousUri( const TDesC& aCandidate ) const

    {

    if ( aCandidate.Length() == 0 )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }