/*

* Copyright (c) 2010 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: Library to handle resource loading when 

*              CCoeEnv is not available.

*

*/

#include <barsread.h>

#include <bautils.h>

#include <biditext.h>

#include <tulpanics.h>

#include "basepluginresourceloader.h"

// panic category constant

#ifdef _DEBUG

_LIT( KPanicCategory, "CResourceLoader" );

#endif

// CP1252 ellipsis character value.

#define KEllipsis       0x2026  // cp1252=133

// Key characters to format key strings.

const TText KKeyPrefix('%');

const TText KSubStringSeparator(0x0001);    // pipe ('|') character

const TText KDirNotFound( 0x0002 );

const TInt KExtraSpaceForMainStringDirMarker = 1;

const TInt KExtraSpaceForSubStringDirMarkers = 2;

const TText KLRMarker = 0x200E; 

const TText KRLMarker = 0x200F;

// KIntSize and KKeySize define maximum number of characters

// in input TInts and in keystring. KNumOfParams is maximum number of

// parameters in the resource string.

const TInt KIntSize(11); //Max 11 digits.

const TInt KNumOfParams(20); //Max 20 parameters

// Key strings for number and unicode data.

_LIT(KNumKeyBuf, "%N"); //Number data

_LIT(KStringKeyBuf, "%U"); //Unicode data

// KUnknownCount is used as default value for param count in FormatStringL

const TInt KUnknownCount(-99);

EXPORT_C CResourceLoader* CResourceLoader::NewL( const TDesC& aName )

    {

    CResourceLoader* temp = new( ELeave ) CResourceLoader();

    CleanupStack::PushL( temp );

    temp->ConstructL( aName );

    CleanupStack::Pop( temp );

    return temp;

    }

CResourceLoader::CResourceLoader()

    {

    }

void CResourceLoader::ConstructL( const TDesC& aFilename )

    {

    User::LeaveIfError( iFs.Connect() );

    TFileName aFile(aFilename);

    BaflUtils::NearestLanguageFile( iFs, aFile );

    iResFile.OpenL( iFs, aFile );

    iResFile.ConfirmSignatureL();

    }

EXPORT_C CResourceLoader::~CResourceLoader()

    {

    iResFile.Close();

    iFs.Close();

    }

EXPORT_C RFs& CResourceLoader::Fs() 

    {

    return iFs;

    }

EXPORT_C HBufC* CResourceLoader::LoadLC( TInt aResourceId )

    {

    TResourceReader reader;

    HBufC8* readBuffer = CreateResourceReaderLC( reader, aResourceId );

    TPtrC textdata = reader.ReadTPtrC();

    HBufC16* textBuffer = HBufC16::NewL( textdata.Length() );

    *textBuffer = textdata;

    CleanupStack::PopAndDestroy( readBuffer );

    CleanupStack::PushL( textBuffer );

    return textBuffer;

    }

EXPORT_C HBufC* CResourceLoader::Load2L( TInt aResourceId )

    {

    HBufC8* readBuffer = iResFile.AllocReadLC( aResourceId );

    const TPtrC16 ptrReadBuffer( ( TText16* ) readBuffer->Ptr(), ( readBuffer->Length()+1 )>>1 );

    HBufC16* textBuffer=HBufC16::NewL( ptrReadBuffer.Length() );

    *textBuffer=ptrReadBuffer;

    CleanupStack::PopAndDestroy( readBuffer );

    return textBuffer;

    }

EXPORT_C HBufC* CResourceLoader::Load2LC( TInt aResourceId )

    {

    HBufC* retbuf = Load2L( aResourceId );

    CleanupStack::PushL( retbuf );

    return retbuf;

    }

EXPORT_C HBufC* CResourceLoader::Load2L( TInt aResourceId, const TDesC& aString )

    {

    HBufC* resbuf = Load2LC( aResourceId );

    TPtr retptr(resbuf->Des());

    // Get number of sub strings

    TInt count = GetSubStringCount( retptr ); 

    TBool marker(EFalse); 

    if (count >= 1)

        {

        HBufC* buffer = ResolveSubStringDirsL( retptr, count, &marker );

        CleanupStack::PushL(buffer);

        TBool found(EFalse);

        TBidiText::TDirectionality mainDir = DirectionalityL(*buffer , &found);

        //Formating the return string with FormatStringL.

        HBufC* retbuf = FormatStringL(*buffer, KStringKeyBuf, aString, mainDir);

        CleanupStack::PopAndDestroy(buffer);

        CleanupStack::PopAndDestroy(resbuf);

        if (marker && retbuf->Length())

            {

            TPtr ptr = retbuf->Des();

            RemoveNoDirMarkers(ptr);

            } 

        __ASSERT_DEBUG(retbuf->Length(), 

                    User::Panic(KPanicCategory, EKeyStringNotFound));    

        return retbuf;

        }

     else

        {

        CleanupStack::PopAndDestroy(resbuf);

        HBufC* retbuf = HBufC::NewL(0); // return empty buffer

        __ASSERT_DEBUG(retbuf->Length(), 

                    User::Panic(KPanicCategory, EKeyStringNotFound));

        return retbuf;

        }

    }

EXPORT_C HBufC* CResourceLoader::Load2LC( TInt aResourceId, const TDesC& aString )

    {

    HBufC* retbuf = Load2L( aResourceId, aString );

    CleanupStack::PushL( retbuf );

    return retbuf;

    }

EXPORT_C HBufC* CResourceLoader::Load2L(TInt aResourceId, TInt aInt )

    {

    HBufC* resbuf = Load2LC( aResourceId );

    TPtr retptr = resbuf->Des();

    //

    //Converting input TInt to a descriptor. This way the size

    //of the return string can be controlled.

    //

    TBuf<KIntSize> intbuf;

    intbuf.Num(aInt);

    if (LanguageSpecificNumberConverter::IsConversionNeeded())

        LanguageSpecificNumberConverter::Convert(intbuf);

    //

    // Get number of sub strings

    TInt count = GetSubStringCount(retptr); 

    TBool marker(EFalse); 

    if (count >= 1)

        {

        HBufC* buffer = ResolveSubStringDirsL(retptr, count, &marker);

        CleanupStack::PushL(buffer);

        TBool found(EFalse);

        TBidiText::TDirectionality mainDir = DirectionalityL(*buffer , &found);

        //Adding int    

        HBufC* retbuf = FormatStringL(*buffer, KNumKeyBuf, intbuf, mainDir);

        CleanupStack::PopAndDestroy(buffer);

        CleanupStack::PopAndDestroy(resbuf);

        if (marker && retbuf->Length())

            {

            TPtr ptr = retbuf->Des();

            RemoveNoDirMarkers(ptr);

            } 

        __ASSERT_DEBUG(retbuf->Length(), 

                    User::Panic(KPanicCategory, EKeyStringNotFound));

        return retbuf;

        }

     else

        {

        CleanupStack::PopAndDestroy(resbuf);

        HBufC* retbuf = HBufC::NewL(0); // return empty buffer

        __ASSERT_DEBUG(retbuf->Length(), 

                    User::Panic(KPanicCategory, EKeyStringNotFound));

        return retbuf;

        }

    }

EXPORT_C HBufC* CResourceLoader::Load2LC( TInt aResourceId, TInt aInt )

    {

    HBufC* retbuf = Load2L( aResourceId, aInt );

    CleanupStack::PushL( retbuf );

    return retbuf;

    }

EXPORT_C HBufC8* CResourceLoader::CreateResourceReaderLC(TResourceReader& aReader,TInt aResourceId) const

    {

    HBufC8* readBuffer = iResFile.AllocReadLC( aResourceId );

    aReader.SetBuffer( readBuffer );

    return readBuffer;

    }

/**

Counts the number of substrings (separated by KSubStringSeparators) in the text. 

Needed for correct memory allocations.

*/

TInt CResourceLoader::GetSubStringCount(const TDesC& aText)

    {

    TInt subCount = 0;

    TInt i = 0;

    while (i < aText.Length())

        {

        TPtrC remainder = aText.Right(aText.Length() - i);

        TInt nextKey = remainder.Locate(KSubStringSeparator);

        i += nextKey;

        // Always increase subcount, as a string without any separators counts as one substring.

        // However, if string length is zero, then there are no substrings.

        subCount++;

        if (nextKey != KErrNotFound && i < aText.Length() - 1)

            {

            i++; // skip separator

            }

        else

            break;

        }

    return subCount;

    }

HBufC* CResourceLoader::ResolveSubStringDirsL(TDes& aText, TInt aCount, TBool* aMarker)

    {   

    // Allocating heap buffer for return string.

    TInt destlength(aText.Length());

    destlength = destlength + (KExtraSpaceForMainStringDirMarker) * aCount;

    HBufC* retbuf = HBufC::NewLC(destlength);

    TPtr retptr(retbuf->Des());

    TInt freeSpace(destlength); 

    TInt i(0);

    TInt j(0);

    TBuf<1> subsMarker;

    subsMarker.Append(KSubStringSeparator);

    TInt count(aCount - 1);

    while (i  < aCount)

        {

        // Resolve sub string

        HBufC* buffer = ResolveSubStringL(aText, aMarker);

        TPtr ptr = buffer->Des();

        CleanupStack::PushL(buffer); 

        // Restore sub string separators

        if (freeSpace >= ptr.Length()) 

            {

            retptr.Insert(j, ptr);

            freeSpace -= ptr.Length();

            j += ptr.Length();

            if (freeSpace > KExtraSpaceForMainStringDirMarker && i < count)

                {

                retptr.Append(subsMarker);

                j ++;

                }

            }    

        CleanupStack::PopAndDestroy(buffer);  

        i++;                       

        } 

    retbuf = retbuf->ReAllocL(retptr.Length());

    CleanupStack::Pop(); //retbuf  

    return retbuf;

    }

TBidiText::TDirectionality CResourceLoader::DirectionalityL(const TDesC& aText, TBool* aFound)

    {

    // Resolve directionality of sub string

    HBufC* dirbuf = aText.AllocL();

    TPtr dirptr = dirbuf->Des();

    TBidiText::TDirectionality dir = ResolveDirectionality(dirptr, aFound);

    delete dirbuf;

    return dir;

    }

/**

Resolves directionality of the given source text.

Place-holder strings are removed so that they don't affect the result.

*/

TBidiText::TDirectionality CResourceLoader::ResolveDirectionality(TDes& aText, TBool* aFound)

    {

    TInt i = 0;

    // Remove place-holders from string so they don't affect directionality

    // length parameters e.g. "[29]" do not contain strongly directional

    // characters so can ignore them.

    while (i < aText.Length())

        {

        TPtrC remainder = aText.Right(aText.Length() - i);

        TInt nextKey = remainder.Locate(KKeyPrefix);

        i += nextKey;

        if (nextKey != KErrNotFound && i < aText.Length() - 1)

            {

            TInt lastCharInKey = i + 1;

            // skip possible key index

            TText t = aText[lastCharInKey];

            if (t >= '0' && t <= '9')

                {

                lastCharInKey++;

                if (lastCharInKey < aText.Length())

                    {

                    t = aText[lastCharInKey];

                    if (t >= '0' && t <= '9')

                        {

                        lastCharInKey++;

                        }

                    }

                }

            // lastCharInKey is now the index of 'N' or 'U' in the key

            if (lastCharInKey < aText.Length())

                {

                TText t = aText[lastCharInKey];

                if (t == 'U' || t == 'N')

                    {

                    // found key, delete it and continue loop to

                    // search for the next key

                    aText.Delete(i, lastCharInKey - i + 1);

                    }

                // This was not a proper key - check the remaining string

                else

                    {

                    i = lastCharInKey + 1;

                    }

                }

            // end of string encountered - stop

            else

                {

                break;

                }

            }

        // no key found - stop

        else

            {

            break;

            }

        }

    return TBidiText::TextDirectionality(aText, aFound);

    }

/**

Finds the keystring from the source string and replaces it with the

replacement string.

*/

HBufC* CResourceLoader::FormatStringL(const TDesC& aSource, const TDesC& aKey, const TDesC& aSubs,TBidiText::TDirectionality aDir)

    {

    TInt paramCount(KUnknownCount); // variable needed as it may be updated

    return FormatStringL(aSource, aKey, aSubs, aDir, paramCount, KUnknownCount);

    }

/**

Finds the keystring from the source string and replaces it with the

replacement string.

*/

HBufC* CResourceLoader::FormatStringL(const TDesC& aSource, const TDesC& aKey, const TDesC& aSubs, TBidiText::TDirectionality aDirectionality,

    TInt& aParamCount, TInt aSubCount)

    {

    if (aParamCount == KUnknownCount)

        aParamCount = GetParamCount(aSource);

    if (aSubCount == KUnknownCount)

        aSubCount = GetSubStringCount(aSource);

    // determine lenght of needed buffer 

    TInt sourcelength(aSource.Length()); 

    TInt keylength(aKey.Length());

    TInt subslength(aSubs.Length());

    TInt destlength = 0;

    if (subslength >= keylength)

        {

        destlength = sourcelength + ((subslength - keylength) * aParamCount);

        }

    else

        {

        destlength = sourcelength;

        }

    destlength += KExtraSpaceForMainStringDirMarker * aSubCount;

    destlength += KExtraSpaceForSubStringDirMarkers * aParamCount;

    //

    // Allocating heap buffer for return string.

    //

    HBufC* retbuf = HBufC::NewL(destlength);

    TPtr retptr(retbuf->Des());

    // Formating the resource string. Don't bother with format, 

    // if parameter count is not above zero

    if (aParamCount > 0)

        {

        aParamCount -= Formater(retptr, aSource, aKey, aSubs, aDirectionality);

        __ASSERT_DEBUG(aParamCount >= 0, User::Invariant());

        }

    //

    // If the key string wasn't found, retbuf is empty.

    //

    return retbuf; 

    }

/**

Finds the keystring from the source string and replaces it with the

replacement string. The formated string is stored in the destination

descriptor.

*/

TInt CResourceLoader::Formater(TDes& aDest, const TDesC& aSource, const TDesC& aKey, const TDesC& aSubs, TBidiText::TDirectionality aDirectionality)    

    {

    // substitute string must not contain KSubStringSeparator, 

    // or results will be unpredictable 

    __ASSERT_DEBUG(aSubs.Locate(KSubStringSeparator) == KErrNotFound, 

        User::Panic(KPanicCategory, EInvalidSubstitute));

    TInt keylength(aKey.Length());

    //aDest must be empty.

    aDest.Zero();

    // offset indicates end of last handled key in source

    TInt offset(0);

    // offset in destination string

    TInt desOffset(0);

    // Substring directionalities are adjusted after all changes are done.

    TBool checkSubstringDirectionalities(EFalse);

    // count is the position in the source from which the substring starts

    TInt count(0);

    // Replaced parameters count

    TInt replaceCount(0);

    while (count != KErrNotFound)

        {

        // desCount is the position of the substring starts in destination.

        TInt desCount(0);

        TPtrC remainder = aSource.Right(aSource.Length() - offset);

        count = remainder.Find(aKey);

        TInt maxSubLength = -1;

        if (count != KErrNotFound)

            {

            replaceCount++;

            desOffset += count;

            offset += count;

            count = offset;

            desCount = desOffset;

            // copy source to destination if first time

            if (aDest.Length() == 0)

                aDest.Append(aSource);

            // delete found key from destination

            aDest.Delete(desCount, keylength);

            offset += keylength; // increase offset by key length

            if (count + keylength < (aSource.Length()-1)) // aKey is not at the end of string

                {

                if (aSource[count+keylength] == '[') // Key includes max datalength

                    {

                    maxSubLength = 10*(aSource[count+keylength+1]-'0') 

                                   + (aSource[count+keylength+2]-'0');

                    aDest.Delete(desCount,4); // Length information stored->delete from descriptor

                    offset += 4; // increase offset by max sub length indicator

                    }

                }

            aDest.Insert(desCount, aSubs);

            desOffset = desCount + aSubs.Length();

            if (maxSubLength > 0 && aSubs.Length() > maxSubLength)

                {

                aDest.Delete(desCount+maxSubLength-1, aSubs.Length()+1-maxSubLength);     

                TText ellipsis(KEllipsis);

                aDest.Insert(desCount+maxSubLength-1, TPtrC(&ellipsis,1));

                desOffset = desCount + maxSubLength;

                }