// Copyright (c) 2002-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 FILES

#include <e32svr.h>

#include <tuladdressstringtokenizer.h>

#include <tulpanics.h>

#include "languagespecificnumberconverter.h"

// DEFINE

const TInt KFindItemMaxNumbers  = 48; // Maximum phone number supported in Contacts

const TInt KFindItemMinNumbers  = 3;

const TInt KDotsInIpAddress     = 3;

const TInt KNumbersInIpAddress  = 3;

const TInt KCharLinefeed = 0x000A;

const TInt KCharFormfeed = 0x000C;

const TInt KCharCarriageReturn = 0x000D;

const TInt KCharLineSeparator = 0x2028;

const TInt KCharParagraphSeparator = 0x2029;

// Valid characters for different search cases

_LIT( KPhoneNumberChars, "1234567890*#-./");

_LIT( KEmailChars, "!#$?%&*+-/");

_LIT( KEmailHostChars, "abcdefghijklmnopqrstuvwxyz1234567890._-");

_LIT( KUrlChars, "%/-~?=:&,#+|");

// generic URI scheme checking 

_LIT( KURISchemeStartCharacters, "abcdefghijklmnopqrstuvwxyz" );

_LIT( KURISchemeBodyCharacters, "abcdefghijklmnopqrstuvwxyz1234567890+-.");

_LIT( KURISchemeTerminator, ":");

_LIT( KURICharacters, "abcdefghijklmnopqrstuvwxyz1234567890?/;:@&=+$,%-_.!~*'()#|");

// Url Address beginnings (to support deprecated search cases)

_LIT( KHttpUrlAddress, "http://");

_LIT( KRtspUrlAddress, "rtsp://");

_LIT( KHttpsUrlAddress, "https://");

// Non-schematic URL address beginnings

_LIT( KWwwUrlAddress, "www.");

_LIT( KWapUrlAddress, "wap.");

// IP address pattern to match

_LIT( KIPAddress, "*.*.*.*");

// Panic

_LIT( KFindItemPanic, "ETUL-Panic");

GLDEF_C void Panic(TTulPanic aPanic)

	{

    User::Panic(KFindItemPanic, aPanic);

	}

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

/**

C++ default constructor.

*/

CTulAddressStringTokenizer::CTulAddressStringTokenizer()

    {

	// C++ default constructor must NOT contain any code, that might leave.

    }

/**

Symbian OS constructor

@param aText  Text that will be parsed

@param aSearchCases   Identifies what items are we looking for:

                          EFindItemSearchPhoneNumberBin

                          EFindItemSearchMailAddressBin

                          EFindItemSearchURLBin

                          EFindItemSearchScheme

                      Any combination of these flags can be given

                      as a bit mask.

@param aMinNumbers    Minimum count of numbers in a string when 

                      the string is considered as a phone number.

*/

void CTulAddressStringTokenizer::ConstructL(const TDesC& aText, TInt aSearchCases, TInt aMinNumbers)

    {

    iMinNumbers = aMinNumbers;

    HBufC* buf = NULL;

	TLanguage language = User::Language();

    if (language == ELangArabic || language == ELangHebrew || language == ELangUrdu || 

    	language == ELangFarsi || language == ELangHindi)

		{

		buf = aText.AllocLC();

        TPtr ptr = buf->Des();

        LanguageSpecificNumberConverter::ConvertToWesternNumbers( ptr );

		PerformSearchL( *buf, aSearchCases );

		}

	else

		PerformSearchL( aText, aSearchCases );

	if(buf)

		CleanupStack::PopAndDestroy(buf);

	}

/**

Performs the search. Uses search algorithms SearchGenericUriL(), SearchMailAddressL(), 

SearchUrlL() and SearchPhoneNumberL().

*/

void CTulAddressStringTokenizer::PerformSearchL(const TDesC& aText , TInt aSearchCases)

	{

	ASSERT(!iFoundItems);

	iFoundItems = new (ELeave) CArrayFixFlat<SFoundItem>(2);

    TBool somethingSearched = EFalse;

    // first detect binary mask cases

    if ( (aSearchCases & EFindItemSearchScheme) == EFindItemSearchScheme)

        {

        SearchGenericUriL( aText );

        somethingSearched = ETrue;

        }

    // Prioritize mail address found before URL search. Address name@123.123.123.123 

    // would otherwise be detected as IP number.

    if ( (aSearchCases & EFindItemSearchMailAddressBin) == EFindItemSearchMailAddressBin)

        {

        SearchMailAddressL( aText );

        somethingSearched = ETrue;

        }

    if ( (aSearchCases & EFindItemSearchURLBin) == EFindItemSearchURLBin)

        {

        SearchUrlL( aText, ETrue );

        somethingSearched = ETrue;

        }

    // Search phone numbers last as all others can contain number sequences

    if ( (aSearchCases & EFindItemSearchPhoneNumberBin) == EFindItemSearchPhoneNumberBin)

        {

        SearchPhoneNumberL( aText );

        somethingSearched = ETrue;

        }

    // if no binary cases found

	if ( !somethingSearched )

        {

		__ASSERT_DEBUG( 1, Panic(ETulPanicInvalidTokenizerSearchCase) );

		}

	}

/**

Two-phase constructor method that is used to create a new instance 

of the CTulAddressStringTokenizer class. This instance can then be queried for

the items defined by the second parameter. The actual search is 

executed during construction.

@param aText will be parsed.

@param aSearchCases identifies what items we are looking for: 

						EFindItemSearchPhoneNumberBin

						EFindItemSearchMailAddressBin

						EFindItemSearchURLBin

						EFindItemSearchScheme

Any combination of these flags can be given as a bit mask.

@return a pointer to a new instance of CTulAddressStringTokenizer class.

@panic ETulPanicInvalidTokenizerSearchCase in debug build if there is no valid search case.

@panic ETulPanicDescriptorLength in debug build if item's position 

and/or length is out of the document's range.

@leave KErrNone, if successful; otherwise one of the other system-wide error codes.

*/

EXPORT_C CTulAddressStringTokenizer* CTulAddressStringTokenizer::NewL(const TDesC& aText, TInt aSearchCases)

    {

    CTulAddressStringTokenizer* self = new (ELeave) CTulAddressStringTokenizer; 

    CleanupStack::PushL(self);

    self->ConstructL(aText, aSearchCases, KFindItemMinNumbers);

    CleanupStack::Pop();

    return self;

    }

/**

Two-phase constructor method that is used to create a new instance

of the CTulAddressStringTokenizer class. This instance can then be queried for

the items defined by the second parameter. The actual search is 

executed during construction.

@param aText will be parsed.

@param aSearchCases identifies what items we are looking for: 

						EFindItemSearchPhoneNumberBin

						EFindItemSearchMailAddressBin

						EFindItemSearchURLBin

						EFindItemSearchScheme

Any combination of these flags can be given as a bit mask.

@param aMinNumbers defines a minimum count of numbers in a phone 

number string, during a phone number  

search.

@return a pointer to an new instance of CTulAddressStringTokenizer class.

@panic ETulPanicInvalidTokenizerSearchCase in debug build if there is no valid search case.

@panic ETulPanicDescriptorLength in debug build if item's position 

and/or length is out of the document's range.

@leave KErrNone, if successful; otherwise one of the other system-wide error codes.

*/

EXPORT_C CTulAddressStringTokenizer* CTulAddressStringTokenizer::NewL(const TDesC& aText, TInt aSearchCases,

    TInt aMinNumbers )

    {

    CTulAddressStringTokenizer* self = new (ELeave) CTulAddressStringTokenizer;   

    CleanupStack::PushL( self );

    self->ConstructL( aText, aSearchCases, aMinNumbers );

    CleanupStack::Pop( );

    return self;

    }

/**

Destructor.

*/

EXPORT_C CTulAddressStringTokenizer::~CTulAddressStringTokenizer()

    {

    delete iFoundItems;

	}

// API methods for using engine separately from FindItemUI

/**

Executes a new search with the already created CTulAddressStringTokenizer 

instance. The position in the found items array is reset to the 

beginning of the array.

@param aText will be parsed.

@param aSearchCases identifies what items are we looking for: 

						EFindItemSearchPhoneNumberBin

						EFindItemSearchMailAddressBin

						EFindItemSearchURLBin

						EFindItemSearchScheme

Any combination of these flags can be given as a bit mask.

@return number of found items.

@panic ETulPanicInvalidTokenizerSearchCase in debug build if there is no valid search case.

@panic ETulPanicDescriptorLength in debug build if item's position 

and/or length is out of the document's range.

@leave one of the Symbian error codes.

*/

EXPORT_C TInt CTulAddressStringTokenizer::DoNewSearchL(const TDesC& aText, TInt aSearchCases)

    {

    return DoNewSearchL( aText, aSearchCases, KFindItemMinNumbers );

    }

// API methods for using engine separately from FindItemUI

/**

Executes a new search with the already created CTulAddressStringTokenizer 

instance. The position in the found items array is reset to the 

beginning of the array.

@param aText will be parsed.

@param aSearchCases identifies what items are we looking for: 

						EFindItemSearchPhoneNumberBin

						EFindItemSearchMailAddressBin

						EFindItemSearchURLBin

						EFindItemSearchScheme

Any combination of these flags can be given as a bit mask.

@param aMinNumbers defines a minimum count of numbers in a phone 

number string, during a phone number  

search.

@return number of found items.

@panic ETulPanicInvalidTokenizerSearchCase in debug build if there is no valid search case.

@panic ETulPanicDescriptorLength in debug build if item's position 

and/or length is out of the document's range.

@leave KErrNone, if successful; otherwise one of the other system-wide error codes.

*/

EXPORT_C TInt CTulAddressStringTokenizer::DoNewSearchL(const TDesC& aText, TInt aSearchCases, TInt aMinNumbers)

    {

    delete iFoundItems;

    iFoundItems = NULL;

	iPosition = 0;

    ConstructL(aText, aSearchCases, aMinNumbers);

    return ItemCount();

    }

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

// Search Algorithms and helpers

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

/**

Character information methods

@param charac a Character to be investigated

@return ETrue if the parameter for phone number was valid, else returns EFalse

*/

TBool CTulAddressStringTokenizer::IsValidPhoneNumberChar(const TChar& aCharac)

    { 

    // Returns ETrue if the parameter is a valid character in a phonenumber

    const TDesC& array = KPhoneNumberChars;

    return (array.Locate(aCharac) != KErrNotFound);

    }

/**

Character information methods

@param charac a Character to be investigated

@return ETrue if the parameter for login part of the e-mail address is valid, else returns EFalse

*/

TBool CTulAddressStringTokenizer::IsValidEmailChar(const TChar& aCharac)

    { 

    // Returns ETrue if the parameter is a valid character for username part of e-mail address

    // ASCII 33 - 47 (without '"', ',', ''', '(' and ')' because they can be used to separate address

    // from rest of the text )

    const TDesC& array = KEmailChars;

    return (array.Locate(aCharac) != KErrNotFound || IsValidEmailHostChar(aCharac));

    }

/**

Character information methods

@param charac a Character to be investigated

@return ETrue if the parameter for host part of the e-mail address is valid, else returns EFalse

*/

TBool CTulAddressStringTokenizer::IsValidEmailHostChar(const TChar& aCharac)

    { 

    // Returns ETrue if the parameter is a valid character for a host part of e-mail address

    const TDesC& array = KEmailHostChars;

    return (array.Locate( aCharac.GetLowerCase() ) != KErrNotFound);

    }

/**

Character information methods

@param charac a Character to be investigated

@return ETrue if the parameter for URL is valid, else returns EFalse

*/

TBool CTulAddressStringTokenizer::IsValidUrlChar(const TChar& aCharac)

    { 

    // Returns ETrue if the parameter is a valid character for url

    if (IsValidEmailHostChar(aCharac))

		return ETrue;

    const TDesC& array = KUrlChars;

    return (array.Locate(aCharac) != KErrNotFound);

    }

/**

Search algorithm for searching e-mail addresses

@param aText Text that will be parsed

@return ETrue if any EMail items were found else returns EFalse

@leave KErrNone, if successful; otherwise one of the other system-wide error codes.

@panic ETulPanicDescriptorLength in debug build if item's position 

and/or length is out of the document's range.

*/

TBool CTulAddressStringTokenizer::SearchMailAddressL( const TDesC& aText )

    {

    TInt searchStart = 0;

    TInt searchResult = 0;

    const TInt end = aText.Length(); // end of document

    do

        {

        TPtrC segment = aText.Right( end - searchStart );

        searchResult = segment.LocateF('@');

        if (searchResult != KErrNotFound)

            { // @ found

            // There should be valid characters (not a period) before and after the @ character

            if ( searchResult == 0 // first char

                || (searchResult >= segment.Length() - 1) // last char 

                || !(IsValidEmailChar(segment[searchResult - 1])) 

                || !(IsValidEmailHostChar(segment[searchResult + 1]))

                || segment[searchResult - 1] == '.' 

                || segment[searchResult + 1] == '.'

               )

                {

                searchStart += searchResult + 1;

                continue;

                }

            TBool wasPeriod = EFalse; // To prevent sequential periods

            // Get TLex from the pointer to get a better API for parsing

            TLexMark startPos;

            TLexMark endPos;

            TLex token = segment;

            // Go to searchResult and un-get until the beginning of e-mail address is reached

            token.Inc( searchResult );

            token.Mark();

            do

                {

                token.UnGet();

                if ( token.Peek() == '.' )

                    { // If it was a period

                    if (wasPeriod)	// and if the former was also -> break

                        break;

                    else	// else mark that this one was a period

                        wasPeriod = ETrue;

                    }

                else

                    wasPeriod = EFalse;

                }

            while (token.Offset() > 0 && IsValidEmailChar(token.Peek()));

            if (token.Offset() != 0 || !IsValidEmailChar(token.Peek()))

                token.Inc();

            // Get rid of periods from the start of address

            // Does it have to start with a number or char(abc...).

            // If it does, the loop should check that it gets rid of all special chars also.

            while (token.Peek() == '.')

                token.Inc();

            token.Mark( startPos ); // Mark the beginning of address

            token.UnGetToMark();

            wasPeriod = EFalse;

            do	// Go forward until a nonvalid character

                {

                token.Inc();

                if ( token.Peek() == '.' )

                    { // If it was a period

                    if ( wasPeriod )	// and if the former was also -> break

                        break;

                    else	// else mark that this one was a period

                        wasPeriod = ETrue;

                    }

                else

                    wasPeriod = EFalse;

                }

            while ( !token.Eos() && IsValidEmailHostChar( token.Peek() ) );

            // If address ends with a period take it away

            token.UnGet();

            if (token.Peek() != '.')

                token.Inc();

            token.Mark( endPos ); // Mark the beginning of address

            // Append the found string to the array

            __ASSERT_DEBUG( searchStart + token.MarkedOffset( startPos ) 

                            + token.MarkedOffset( endPos ) 

                            - token.MarkedOffset( startPos ) <= aText.Length(), 

                            Panic(ETulPanicDescriptorLength) );

            AddItemL( searchStart + token.MarkedOffset( startPos ), 

                      token.MarkedOffset( endPos ) - token.MarkedOffset( startPos ), 

                      EFindItemSearchMailAddressBin);

            searchStart += token.MarkedOffset( endPos ) + 1;

            }

        }

    while ( searchResult != KErrNotFound && searchStart < end );

    return (iFoundItems->Count() > 0);

    }

/**

Search algorithm for searching phone numbers

@param aText Text that will be parsed

@return ETrue if any Phone Number items were found else returns EFalse

@leave KErrNone, if successful; otherwise one of the other system-wide error codes.

@panic ETulPanicDescriptorLength in debug build if item's position 

and/or length is out of the document's range.

*/

TBool CTulAddressStringTokenizer::SearchPhoneNumberL( const TDesC& aText )

    {

    TLexMark startMark; // Points to the start of the found phone number

    TLexMark endMark; // Points to the end of the found phone number

    TLexMark mark;

    const TInt end = aText.Length();

    TLex number = aText;

    while ( !(number.Eos()) )

        {

        TInt numberCount = 0; // How many real numbers (1234567890)

        TInt bracketsOpen = 0; // How many brackets are currently open

        TInt brackets = 0; // How many brackets overall

        TChar charac = number.Peek();

        while( (!(IsValidPhoneNumberChar( charac ) || charac == '+'

               || charac == '(' ) || charac == '-' || charac == '.' || charac == '/') 

			   && !(number.Eos()) && number.Offset() < end )

            {

            number.Inc();

            charac = number.Peek();

            }

        if ( number.Offset() >= end )

            break;

        if ( number.Peek() == '#' )

			{

			number.Inc();

			if (number.Peek() == '.' )

				continue;

			number.UnGet();

			}

        if ( number.Peek() == '+' )

            { // '+' has to be followed by a number (not # or * ...)

            number.Inc();

            if ( !(number.Peek().IsDigit()) )

                continue;

            number.UnGet();

            }

        if ( number.Peek() == '(' )

            { // '(' has to be followed by valid phone number 

              // character (whitespaces are allowed before) or '+' is a next character

            number.Inc();

            if ( !(number.Peek() == '+') )

                {

                number.Mark(mark);

                number.SkipSpace();

                charac = number.Peek();

                if ( !( IsValidPhoneNumberChar(charac) || charac == '+' 

                    || charac == '(' ) || charac == '-' || charac == '.' || charac == '/')

                    {

                    number.Inc();

                    continue;