/*
* Copyright (c) 2002 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:  Parser for phone numbers.
*
*/


// INCLUDE FILES
#include    "CPhoneGsmPhoneNumberParser.h"
#include    "CPhoneGsmParserResult.h"
#include    "CPhoneGsmOptionContainer.h"
#include    "CPhoneVoipNumberParser.h"
#include    "CPhoneParserFeatures.h"
#include    "phoneParserCommon.h"
// CONSTANTS
_LIT( KPhoneClirSuppress, "*31#" );
_LIT( KPhoneClirInvoke, "#31#" );

const TInt KPhoneNumberOne = '1';

const TInt KPhoneNumberMaxLength = 80;

const TInt KPhoneShortStringMinLength = 1;  // Must be positive.
const TInt KPhoneShortStringMaxLength = 2;  // Must be positive.
const TInt KPhoneHashStringMinLength = 2;
const TInt KPhoneTwoDigitStringLength = 2;

// If there is one of the characters in the string, then the string
// is considered as phone number.
_LIT( KPhoneMustPhoneNumberChars, "pw" );
_LIT( KPhoneHashChar, "#" );
_LIT( KPhoneNumberZero, "0" );


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

// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::CPhoneGsmPhoneNumberParser
// -----------------------------------------------------------------------------
//
CPhoneGsmPhoneNumberParser::CPhoneGsmPhoneNumberParser()
    {
    }

// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::NewLC
// -----------------------------------------------------------------------------
//
CPhoneGsmPhoneNumberParser* CPhoneGsmPhoneNumberParser::NewLC()
    {
    CPhoneGsmPhoneNumberParser* self = 
        new ( ELeave ) CPhoneGsmPhoneNumberParser;
    
    CleanupStack::PushL( self );
        
    return self;
    }

// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::ParseL
// 
// Phone number can contain following parts: supplementary
// service prefix, main part and dtmf postfix.
// 
// -----------------------------------------------------------------------------
//
TBool CPhoneGsmPhoneNumberParser::ParseL( 
        const TDesC& aString,
        CPhoneGsmParserResult& aResult,
        CPhoneGsmOptionContainerBase& aOptions )
    {
    aResult.ClearL();

    TBool result = DoParseL( 
            aString,
            aResult,
            static_cast<CPhoneGsmOptionContainer&>( aOptions ) );

    if ( !result )
        {
        aResult.ClearL();
        }

    return result;
    }
    
// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::DoParseL
// 
// Phone number can contain following parts: supplementary
// service prefix, main part and dtmf postfix.
// -----------------------------------------------------------------------------
//
TBool CPhoneGsmPhoneNumberParser::DoParseL( 
        const TDesC& aString,
        CPhoneGsmParserResult& aResult,
        CPhoneGsmOptionContainer& aOptions )
    {
    TBool result = EFalse;

    if ( !aOptions.FindOptionStatus( KPhoneOptionSend ))
        {
        return EFalse;
        }
    if ( !ContainsPauseOrWaitChars( aString )) // p or w --> always phone number
        {
        if ( IsHashString( aString ))
            {
            return EFalse;
            }
        if ( aString.Length() >= KPhoneShortStringMinLength &&
             aString.Length() <= KPhoneShortStringMaxLength )
            {
            if ( !IsZeroDialling( aString, aOptions ) && 
                !IsTwoDigitDialling( aString ) && !Is1xDialling( aString, aOptions )) 
                {
                return EFalse;
                }
            }
        }
    TLex input( aString );
    
    if ( !HandleServicePrefix( input, aResult ) )
        {
        aResult.SetAuxInformation( KPhoneDialDefaultClir );
        }

    // Take number part and add it to result.
    result = TakeNumberPartL( input, aResult );
        
    if ( result )
        {
        if ( !aOptions.FindOptionStatus( KPhoneOptionVoipCall ) )
            {
            aResult.SetUid( KPhoneUidPhoneNumber );
            }

        // Add rest of string( dtmf postfix ) to result.
        if ( !TakeDtmfPostfixL( input, aResult ) )
            {
            aResult.AddParameterL( KNullDesC );
            }
        }

    return result;
    }

// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::HandleServicePrefix
// 
// Checks if there is clir suppress/invoke prefix in the
// string. 
// -----------------------------------------------------------------------------
//
TBool CPhoneGsmPhoneNumberParser::HandleServicePrefix( 
        TLex& aLex, 
        CPhoneGsmParserResult& aResult )
    {
    TBool result = EFalse;
    TPtrC remainder( aLex.Remainder() );

    if ( EqualsLeft( remainder, KPhoneClirSuppress ) )
        {
        aLex.Inc( KPhoneClirSuppress().Length() );
        aResult.SetAuxInformation( KPhoneDialSuppressClir );
        result = ETrue;
        }
    else if ( EqualsLeft( remainder, KPhoneClirInvoke ) )
        {
        aLex.Inc( KPhoneClirSuppress().Length() );
        aResult.SetAuxInformation( KPhoneDialInvokeClir );
        result = ETrue;
        }
    
    return result;
    }

// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::TakeNumberPartL
// 
// Takes a main part of the phone number. And add
// it to the aReturn parameter with or without optional international prefix.
// -----------------------------------------------------------------------------
//
TBool CPhoneGsmPhoneNumberParser::TakeNumberPartL(
        TLex& aLex,
        CPhoneGsmParserResult& aResult )
    {
    TBool result = EFalse;
    
    TLexMark start;
    aLex.Mark( start );

    TInt maxLength = KPhoneNumberMaxLength;

    // Checks is first char optional international prefix
    // and if its increments to the next char position.
    if ( aLex.Peek() == KPhonePlus )
        {
        aLex.Inc();
        maxLength++;
        }

    // Check possible 'p','w' or '+' marks.
    while ( ( aLex.Peek().IsDigit() ) || 
            ( aLex.Peek() == KPhoneNumberAsterisk ) ||
            ( aLex.Peek() == KPhoneNumberHash ) )
        {
        aLex.Inc();
        }

    // Add parsing string to result parameter
    TPtrC mainpart( aLex.MarkedToken( start ) );
    const TInt length = mainpart.Length();
    if ( length <= maxLength )
        {
        result = ETrue;
        aResult.AddParameterL( mainpart );
        }
    
    return result;
    }

// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::TakeDtmfPostfixL
// -----------------------------------------------------------------------------
//
TBool CPhoneGsmPhoneNumberParser::TakeDtmfPostfixL(
        TLex& aLex,
        CPhoneGsmParserResult& aResult )
    {
    // Add rest of string( after TLex16::iNext ) to result.
    aResult.AddParameterL( aLex.Remainder() );
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::EqualsLeft
// -----------------------------------------------------------------------------
//
TBool CPhoneGsmPhoneNumberParser::EqualsLeft( 
        const TDesC& aDesc, 
        const TDesC& aLeft )
    {
    return IsPrefixOf( aDesc, aLeft );
    }

// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::ContainsPauseOrWaitChars
// -----------------------------------------------------------------------------
//
TBool CPhoneGsmPhoneNumberParser::ContainsPauseOrWaitChars(
        const TDesC& aString ) const
    {

    TBool result = EFalse;
    TPtrC chs( KPhoneMustPhoneNumberChars );
    for ( TInt index = 0; index < chs.Length(); index++ )
        {
        if ( aString.Locate( chs[ index ] ) != KErrNotFound )
            {
            result = ETrue;
            break;
            }
        }

    return result; 
    }

// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::IsHashString
// -----------------------------------------------------------------------------
//
TBool CPhoneGsmPhoneNumberParser::IsHashString( 
        const TDesC& aString ) const
    {
    return aString.Length() >= KPhoneHashStringMinLength &&
        // Rightmost character must be #
        aString.Right( 1 ) == KPhoneHashChar; 
    }

// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::IsZeroDialling
// -----------------------------------------------------------------------------
//
TBool CPhoneGsmPhoneNumberParser::IsZeroDialling( 
        const TDesC& aString, CPhoneGsmOptionContainer& aOptions ) const
    {
    return !aOptions.FindOptionStatus( KPhoneOptionInCall ) &&
        !aString.Compare( KPhoneNumberZero ) && 
        CPhoneParserFeatures::IsZeroDialEnabled(); 
    }

// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::IsTwoDigitDialling
// -----------------------------------------------------------------------------
//
TBool CPhoneGsmPhoneNumberParser::IsTwoDigitDialling( 
        const TDesC& aString ) const
    {
    return CPhoneParserFeatures::TwoDigitCallingEnabled() &&
        aString.Length()== KPhoneTwoDigitStringLength;
    }

// -----------------------------------------------------------------------------
// CPhoneGsmPhoneNumberParser::Is1xDialling
// -----------------------------------------------------------------------------
//
TBool CPhoneGsmPhoneNumberParser::Is1xDialling( 
    const TDesC& aString, CPhoneGsmOptionContainer& aOptions  ) const
    {
    return !aOptions.FindOptionStatus( KPhoneOptionInCall ) &&
        aString.Length()== KPhoneShortStringMaxLength &&
        aString[0] == KPhoneNumberOne &&
        TChar( aString[1] ).IsDigit();
    }

//  End of File