/*

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

#include "RegularExpression.h"

#include "cleanuputil.h"

#include <barsread.h>

#include <eikenv.h>

#include <centralrepository.h>

#include <NumberGroupingCRKeys.h>

const TText KNumberGroupingWildcard('n');

const TText KNumberGroupingOneOrMoreCharactersToken('~');

// This constant represents all the valid whitespace that we can handle. Several

// APIs give whitespace special significance as a formatting character, especially

// those methods used to obtain text for formatting into fixed-width UI elements

// where spaces are not to be rendered at the margins.

const TText KNumberGroupingSpace(' ');

const TInt KMinimumLengthToGroup = 1; // No grouping occurs if fewer than this in unformatted buffer

#include <numbergrouping.rsg>

GLDEF_C void Panic(TNumberGroupingPanic aPanic)

    {

    _LIT(KPanicCat,"Number Grouping");

    User::Panic(KPanicCat, aPanic);

    }

// Valid phone number characters apart from IsDigit() characters are listed here

const TText KAdditionalPhoneNumberCharacters[] = {'+','#','*','p','w'};

NONSHARABLE_CLASS(CPNGNumberGroupingExtension): public CBase

	{

public:

	CPNGNumberGroupingExtension();

	~CPNGNumberGroupingExtension();

public:

    TInt        iMaxExtraCharacters; 

    TInt        iNumberGroupingCRValue;

    };

CPNGNumberGroupingExtension::CPNGNumberGroupingExtension()

	{

	}

CPNGNumberGroupingExtension::~CPNGNumberGroupingExtension()

	{

	}

CPNGNumberGrouping::TPNGSeparator::TPNGSeparator()

    : iPosition(-1), iSeparatorCharacter(KNumberGroupingSpace)

    {

    }

CPNGNumberGrouping::TPNGSeparator::TPNGSeparator( TInt aPosition, TText aSeparatorCharacter )

    : iPosition(aPosition), iSeparatorCharacter(aSeparatorCharacter)

    {

    }

CPNGNumberGrouping::TPNGGroupingInfo::TPNGGroupingInfo()

    {

    }

// CPNGNumberGrouping - grouping engine class

CPNGNumberGrouping::CPNGNumberGrouping(TInt aMaxLength /* = 0 */, TBool aReversed /* = EFalse */) :

                                            iForceLanguage(ELangTest),

                                            iUnformattedNumberPtr(KNullDesC),

                                            iFormattedNumberPtr(KNullDesC),

                                            iReverseFormattedNumberPtr(KNullDesC),

                                            iSelectionPtr(KNullDesC),

                                            iLanguage(ELangTest),

                                            iMaxUnformattedLength(aMaxLength),

                                            iReversed(aReversed),

                                            iMatchedPatternIndex(ENoMatchedPattern)

    {

    }

EXPORT_C CPNGNumberGrouping* CPNGNumberGrouping::NewL( TInt aMaxLength, TBool aReserved)

    {

    CPNGNumberGrouping* s = NewLC(aMaxLength, aReserved);

    CleanupStack::Pop();

    return s;

    }

EXPORT_C CPNGNumberGrouping* CPNGNumberGrouping::NewLC( TInt aMaxLength, TBool aReserved)

    {

    CPNGNumberGrouping* s = new(ELeave)CPNGNumberGrouping( aMaxLength, aReserved);

    CleanupStack::PushL(s);

    s->ConstructL();

    return s;

    }

void CPNGNumberGrouping::ConstructL()

    {

    iExtension = new (ELeave) CPNGNumberGroupingExtension(); 

    CRepository* repository = NULL;

    iExtension->iNumberGroupingCRValue = 0;

    TRAPD(ret, repository = CRepository::NewL(KCRUidNumberGrouping));

    if (ret == KErrNone)

        {

        ret = repository->Get(KNumberGrouping, iExtension->iNumberGroupingCRValue);

        }

    delete repository;

    // Read from resource first in order to obtain a value for iExtension->iMaxExtraCharacters

    iLanguage = doReadLanguageFromSharedData();

    doReadFormatInfoFromResourceFileL(); // This sets iExtension->iMaxExtraCharacters

    // Allocation of buffers.  Note that iMaxUnformattedLength must be retained as member

    // data because HBufCs may come back with more storage available than asked for.

    // The uncertainty in the actual length provided by the HBufCs means that although

    // they are asked to be different by iExtension->iMaxExtraCharacters, the difference between the

    // actual MaxLengths may be less than iMaxExtraCharcaters.

    // The approach decided upon is to retain iMaxUnformattedLength as member data and

    // use IT everywhere throughout this class's implementation, NEVER using

    // iUnformattedNumber->Des().MaxLength()

    iUnformattedNumber = HBufC::NewL(iMaxUnformattedLength);

    iFormattedNumber = HBufC::NewL(iMaxUnformattedLength + iExtension->iMaxExtraCharacters);

    // Create revesed buffer only if requested

    if ( iReversed )

        iReverseFormattedNumber = HBufC::NewL(iMaxUnformattedLength + iExtension->iMaxExtraCharacters);        

    }

EXPORT_C CPNGNumberGrouping::~CPNGNumberGrouping()

    {

    doClearGroupingItemsList();

    delete iUnformattedNumber;

    delete iFormattedNumber;

    delete iReverseFormattedNumber;

    delete iRegExp;

    delete iExtension;

    }

EXPORT_C TInt CPNGNumberGrouping::Insert(TInt aIndex, TText aChar)

    {

    if( aIndex >= 0 && aIndex <= iUnformattedNumber->Length())

        {

        if(iUnformattedNumber->Length() >= iMaxUnformattedLength)

            return KErrOverflow;

        TBuf<1> bufChar(1);

        bufChar[0] = aChar;

        TPtr ptrModifyable(iUnformattedNumber->Des());

        ptrModifyable.Insert(aIndex, bufChar);

        doClearFormattedNumbers();

        return KErrNone;

        }

    return KErrIndexOutOfRange;

    }

EXPORT_C TInt CPNGNumberGrouping::Delete(TInt aIndex)

    {

    if(aIndex >= 0 && aIndex < iUnformattedNumber->Length())

        {

        TPtr ptrModifyable(iUnformattedNumber->Des());

        ptrModifyable.Delete(aIndex, KSingleCharacter);

        doClearFormattedNumbers();

        return KErrNone;

        }

    return KErrIndexOutOfRange;

    }

EXPORT_C TInt CPNGNumberGrouping::Append(TText aChar)

    {

    if(iUnformattedNumber->Length() >= iMaxUnformattedLength)

        return KErrOverflow;

    TBuf<1> bufChar(1);

    bufChar[0] = aChar;

    TPtr ptrModifyable(iUnformattedNumber->Des());

    ptrModifyable.Append(bufChar);

    doClearFormattedNumbers();

    return KErrNone;

    }

EXPORT_C TInt CPNGNumberGrouping::Set(const TDesC& aNumber)

    {

    if( aNumber.Length() > iMaxUnformattedLength )

        return KErrOverflow;

    TPtr ptrModifyable( iUnformattedNumber->Des() );

    ptrModifyable.Copy( aNumber );

    doClearFormattedNumbers();

    return KErrNone;

    }

EXPORT_C TInt CPNGNumberGrouping::Length() const

    {

    if(!iFormattedNumber->Length()) // This test is used as the trigger to reformat

        FormattedNumber();

    return iFormattedNumber->Length();

    }

EXPORT_C TInt CPNGNumberGrouping::UnFormattedLength() const

    {

    return iUnformattedNumber->Length();

    }

EXPORT_C TInt CPNGNumberGrouping::MaxDisplayLength() const

    {

    // Despite its name, this method returns the max length of the UNFORMATTED buffer

    // This must not be implemented to return the actual length available in

    // iUnformattedBuffer.

    return iMaxUnformattedLength;

    }

EXPORT_C TBool CPNGNumberGrouping::IsSpace(TInt aPos) const

    {

    // Very tricky semantics for this.  Must be a space inserted by the formatting

    if ( iFormattedNumber->Length() > aPos &&

         iFormattedNumber->operator[](aPos) == KNumberGroupingSpace &&

         // Check also that is is less than the length to group + inserted characters

         aPos < ( LengthToGroup() + (iFormattedNumber->Length() - iUnformattedNumber->Length()) ) )

        return ETrue;

    else

        return EFalse;

    }

EXPORT_C const TDesC& CPNGNumberGrouping::FormattedNumber(TInt aFrom, TInt aTo) const

    {

    if(iUnformattedNumber->Length() != 0 &&

        aFrom >= 0 &&

        aFrom <= aTo )

        {

        FormattedNumber();

        iFormattedNumberPtr.Set(KNullDesC);

        TInt length = iFormattedNumber->Length();

        if(aTo < length + 1)

            {

            TInt length = iFormattedNumber->Length();

            if ( iExtension->iNumberGroupingCRValue )

            	{

				// Advance to the next non-space

				while( (aFrom < length ) && (*iFormattedNumber)[aFrom] == KNumberGroupingSpace )

					{

					++aFrom;

					}

				// Retreat to the last non-space

				while( (aTo > 0) && (*iFormattedNumber)[aTo] == KNumberGroupingSpace )

					{

					--aTo;

					}

            	}

            // Does fetching the descriptor still make sense?

            if ( (0 <= aFrom) && (aFrom <= aTo) && (aTo < length) )

                iFormattedNumberPtr.Set( iFormattedNumber->Mid( aFrom, aTo-aFrom+1 ) );

            }

        }

    else

        {

        if(iFormattedNumber->Length())

            {

            CPNGNumberGrouping* pThis = const_cast<CPNGNumberGrouping*>(this);

            pThis->doClearFormattedNumbers();

            }

        iFormattedNumberPtr.Set(KNullDesC);

        }

    return iFormattedNumberPtr;

    }

EXPORT_C const TDesC& CPNGNumberGrouping::FormattedNumber() const

    {

    if( !iFormattedNumber->Length() )

        {

        TInt err = KErrNone;

        CPNGNumberGrouping* pThis = const_cast<CPNGNumberGrouping*>(this);

        if( LengthToGroup() < KMinimumLengthToGroup || !iExtension->iNumberGroupingCRValue )

            {

            // This is now just a short cut, as doNumberGroupingL handles premature truncation of

            // formatting. But this avoids all the language checking

            doNumberSquashing();  // copies the unformatted number straight into the formatted number

            }

        else

            {

            TLanguage eLanguage;

            if(iForceLanguage != ELangTest)

                eLanguage = iForceLanguage;

            else

                eLanguage = doReadLanguageFromSharedData();

            if(eLanguage != iLanguage)

                {

                iLanguage = eLanguage;

                TRAP(err, pThis->doReadFormatInfoFromResourceFileL());

                if(err != KErrNone)

                    {

                    iFormattedNumberPtr.Set(KNullDesC);

                    return iFormattedNumberPtr;

                    }

                }

            TRAP(err, doNumberGroupingL());

            }

        if(err != KErrNone)

            pThis->doClearFormattedNumbers();

        else

            iFormattedNumberPtr.Set(iFormattedNumber->Ptr(), iFormattedNumber->Length());

        }

    return iFormattedNumberPtr;

    }

EXPORT_C const TDesC& CPNGNumberGrouping::ReverseFormattedNumber(TInt aFrom, TInt aTo) const

    {

    if ( iReversed )

        {

        if(iUnformattedNumber->Length() != 0 &&

            aFrom >= 0 &&

            aFrom <= aTo)

            {

            ReverseFormattedNumber();

            iReverseFormattedNumberPtr.Set(KNullDesC);

            TInt length = iReverseFormattedNumber->Length();

            if( aTo < length + 1 )

                {

                // Advance to the next non-space

                if( iExtension->iNumberGroupingCRValue )

                	{

					while( (aFrom < length ) && (*iReverseFormattedNumber)[aFrom] == KNumberGroupingSpace )

						{

						++aFrom;

						}

					// Retreat to the last non-space

					while( (aTo > 0) && (*iReverseFormattedNumber)[aTo] == KNumberGroupingSpace )

						{

						--aTo;

						}

                	}

                // Does fetching the descriptor still make sense?

                if ( (0 <= aFrom) && (aFrom <= aTo) && (aTo < length) )

                    iReverseFormattedNumberPtr.Set(

                        iReverseFormattedNumber->Mid( aFrom, aTo-aFrom+1) );

                }

            }

        else

            iReverseFormattedNumberPtr.Set(KNullDesC);

        }

    return iReverseFormattedNumberPtr; // Zero initialized at construction

    }

EXPORT_C const TDesC& CPNGNumberGrouping::ReverseFormattedNumber() const

    {

    if( iReverseFormattedNumber && !iReverseFormattedNumber->Length())

        {

        if(!iFormattedNumber->Length())

            FormattedNumber();

        TInt nLength = iFormattedNumber->Length();

        TPtr ptrModifyable(iReverseFormattedNumber->Des());

        TBuf<1> bufChar(1);

        for(TInt i = nLength; i > 0; --i)

            {

            TText cChar = (*iFormattedNumber)[i-1];

            bufChar[0] = cChar;

            ptrModifyable.Insert(nLength - i, bufChar);

            }

        iReverseFormattedNumberPtr.Set(iReverseFormattedNumber->Ptr(), nLength);

        }

    return iReverseFormattedNumberPtr;

    }

EXPORT_C const TDesC& CPNGNumberGrouping::Selection(TInt aFrom, TInt aTo) const

    {

    if(aFrom < iUnformattedNumber->Length())

        {

        TPtr ptrUnformatted = iUnformattedNumber->Des();

        iSelectionPtr.Set(&(ptrUnformatted[aFrom]), aTo - aFrom);

        }

    else

        iSelectionPtr.Set(KNullDesC);

    return iSelectionPtr;

    }

EXPORT_C const TDesC&   CPNGNumberGrouping::UnFormattedNumber(TInt aFrom, TInt aTo) const

    {

    if (iUnformattedNumber && aFrom >= 0 && aFrom <= aTo && aTo < iUnformattedNumber->Length())

        {

        iUnformattedNumberPtr.Set(&((*iUnformattedNumber)[aFrom]), aTo - aFrom + 1);

        }

    else

        {

        iUnformattedNumberPtr.Set(KNullDesC);

        }

    return iUnformattedNumberPtr;

    }

EXPORT_C const TDesC& CPNGNumberGrouping::UnFormattedNumber() const

    {

    return UnFormattedNumber(0, iUnformattedNumber->Length() - 1);

    }

TLanguage CPNGNumberGrouping::doReadLanguageFromSharedData() const

    {    

    if (iExtension->iNumberGroupingCRValue)

        {

        return ELangAmerican;

        }

    else

        {

        return ELangTest;

        }

    }

void CPNGNumberGrouping::doClearFormattedNumbers()

    {

    TPtr ptrModifyable( iUnformattedNumber->Des() );

    for (TInt index = 0; index < ptrModifyable.Length(); index++)

        {

        TChar ch = TChar(ptrModifyable[index]);

        ch.Fold( TChar::EFoldDigits | TChar::EFoldSpaces);

        }

    iFormattedNumber->Des().Zero();

    iFormattedNumberPtr.Set(KNullDesC);

    if ( iReverseFormattedNumber )

        iReverseFormattedNumber->Des().Zero();

    iReverseFormattedNumberPtr.Set(KNullDesC);

    iMatchedPatternIndex = ENoMatchedPattern;

    }

void CPNGNumberGrouping::doReadFormatInfoFromResourceFileL()

    {

    doClearGroupingItemsList();

    delete iRegExp;

    iRegExp = NULL;

    RPointerArray<TDesC> parrGroupingPatternsList;

    CleanupResetAndDestroyPushL(parrGroupingPatternsList);

    TInt maxExtraCharacters(0);

    RFs fs;

    CleanupClosePushL(fs);

    if(fs.Connect() == KErrNone)

        {

        RResourceFile resourceFile;

        CleanupClosePushL(resourceFile);

        resourceFile.OpenL(fs, _L("z:\\resource\\numbergrouping.rsc"));

        HBufC8* bufResource = resourceFile.AllocReadL(R_GROUPING_MAPPING);

        TResourceReader resourceReader;

        resourceReader.SetBuffer(bufResource);

        TInt    nLanguageCount = resourceReader.ReadInt8();

        TBool   bLanguageMatches = EFalse;

        while(nLanguageCount-- || !bLanguageMatches)

            {

            TBool bLanguageMatches = (resourceReader.ReadInt8() == iLanguage);

            if(bLanguageMatches || ((nLanguageCount == -1) && !bLanguageMatches))

                {

                TInt nGroupingSchemeCount = resourceReader.ReadInt8();

                while(nGroupingSchemeCount--)

                    {

                    TInt thisMaxExtraCharacters(0);

                    ReadGroupingSchemeL(

                        resourceReader, parrGroupingPatternsList, thisMaxExtraCharacters );

                    // take this new max extra characters if bigger

                    maxExtraCharacters = Max( maxExtraCharacters, thisMaxExtraCharacters );

                    }

                break; // This breaks out because we take the first language that matches

                } // End of if on language/locale test

            else  // skip other locales

                {