/*

* Copyright (c) 2006-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:  

*           Miscellaneous text related utility methods.

*

*/

// ========== INCLUDE FILES ================================

#include <e32std.h>

#include <e32base.h>

#include <f32file.h>

#include <s32file.h>

#include <charconv.h>

#include <txtrich.h>

#include <cmsvattachment.h>

#include <cmsvmimeheaders.h>

#include <mmsvattachmentmanager.h>

#include "msgtextutils.h"

// ========== LOCAL CONSTANTS AND MACROS ===================

/* Reddy - Moved ot header

// Default charsets

const TUint KDefaultCharConvCharset = KCharacterSetIdentifierAscii;

const TUint KDefaultMIBCharset = KCharacterSetMIBEnumUsAscii;

*/

const TInt KMaxSampleLengthForAutoDetection = 512;

const TInt KCharsetPluginArrayGranularity = 10;

const TUint KCharParagraphSeparator = 0x2029;

const TUint KCharLineFeed = 0x0a;

const TUint KCharCarriageReturn = 0x0d;

const TUint KCharAsciiDot = 0x2e;

const TUint KCharAsciiMax = 0x7f;

const TInt KMaxFileNameLength = 8;      // must be at least 4!

const TInt KMaxFileExtensionLenght = 5; // includes dot

const TInt KMaxFileTotalLength = 12;

_LIT8( KReplaceChar8, "_" );

_LIT16( KReplaceChar16, "_" );

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

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

// CMsgTextUtils::NewL

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

//

EXPORT_C CMsgTextUtils* CMsgTextUtils::NewL( RFs& aFs )

    {

    CMsgTextUtils* data = new ( ELeave ) CMsgTextUtils( aFs );

    CleanupStack::PushL( data );

    data->ConstructL();

    CleanupStack::Pop();

    return data;

    }

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

// CMsgTextUtils::CMsgTextUtils

//

// Constructor

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

//

CMsgTextUtils::CMsgTextUtils( RFs& aFs )

    : iFs( aFs )

    {

    }

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

// CMsgTextUtils::ConstructL

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

//

void CMsgTextUtils::ConstructL()

    {

    // Nothing to do. Reserved for future use.

    }

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

// CMsgTextUtils::~CMsgTextUtils

//

// Destructor.

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

//

CMsgTextUtils::~CMsgTextUtils()

    {

    delete iCharConv;

    }

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

// CMsgTextUtils::ConvertToBuffer8LC

// 

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

//

EXPORT_C HBufC8* CMsgTextUtils::ConvertToBuffer8LC(

        const TDesC& aText,

        TUint aCharacterSetIdentifier )

    {

    TInt origLength = aText.Length();

    TInt maxLength = origLength;

    HBufC8* resultBuffer = HBufC8::NewLC( maxLength ); 

    if ( !iCharConv )

        {

        iCharConv = CCnvCharacterSetConverter::NewL();

        }

    if ( iCharConv->PrepareToConvertToOrFromL( aCharacterSetIdentifier, iFs ) !=

        CCnvCharacterSetConverter::EAvailable )

        {

        User::Leave( KErrNotSupported );

        }

    iCharConv->SetReplacementForUnconvertibleUnicodeCharactersL( KReplaceChar8 );

    TBuf8<40> outputBuffer;

    TPtrC16 remainderOfUnicode( aText );

    FOREVER

        {

        const TInt doneAll = iCharConv->ConvertFromUnicode( outputBuffer, remainderOfUnicode );

        if ( doneAll == CCnvCharacterSetConverter::EErrorIllFormedInput )

            {

            User::Leave( KErrCorrupt );

            }

        else if ( doneAll < 0 )

            {

            // For future expansion of errors

            User::Leave( KErrGeneral );

            }

        else

            { // lint

            }

        // Make sure outputBuffer fits into resultBuffer

        while ( resultBuffer->Length() + outputBuffer.Length() > maxLength )

            {

            // Increase resultBuffer length by origLength

            maxLength += origLength;

            resultBuffer = resultBuffer->ReAllocL( maxLength );

            CleanupStack::Pop(); // resultBuffer

            CleanupStack::PushL(resultBuffer);

            }

        // Append to result

        resultBuffer->Des().Append( outputBuffer );

        if ( doneAll == 0 )

            {

            return resultBuffer; // All converted

            }

        remainderOfUnicode.Set( remainderOfUnicode.Right( doneAll ));

        }

    }       

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

// CMsgTextUtils::ConvertToBuffer16LC

// 

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

//

EXPORT_C HBufC* CMsgTextUtils::ConvertToBuffer16LC(

        const TDesC& aText,

        TUint aCharacterSetIdentifier )

    {

    HBufC8* resultBuffer = ConvertToBuffer8LC( aText, aCharacterSetIdentifier );

    HBufC* finalresult = HBufC::NewL( resultBuffer->Length() );

    finalresult->Des().Copy( *resultBuffer );

    CleanupStack::PopAndDestroy(); // resultbuffer

    CleanupStack::PushL( finalresult );

    return finalresult;

    }

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

// CMsgTextUtils::ConvertToFileL

// 

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

//

EXPORT_C void CMsgTextUtils::ConvertToFileL(

        const TDesC& aText,

        RFile& aFile,

        TUint aCharacterSetIdentifier )

    {

    // Takes ownership of "aFile".

    RFileWriteStream writer( aFile );

    writer.PushL();

    if ( !iCharConv )

        {

        iCharConv = CCnvCharacterSetConverter::NewL();

        }

    if ( iCharConv->PrepareToConvertToOrFromL( aCharacterSetIdentifier, iFs )

        != CCnvCharacterSetConverter::EAvailable )

        {

        User::Leave( KErrNotSupported );

        }

    iCharConv->SetReplacementForUnconvertibleUnicodeCharactersL( KReplaceChar8 );

    TBuf8<128> outputBuffer;

    TPtrC16 remainderOfUnicodeText( aText );

    FOREVER

        {

        TInt doneAll = iCharConv->ConvertFromUnicode(

            outputBuffer, remainderOfUnicodeText );

        if ( doneAll == CCnvCharacterSetConverter::EErrorIllFormedInput )

            {

            User::Leave( KErrCorrupt );

            }

        else if ( doneAll < 0 ) // future-proof against "TError" expanding

            {

            User::Leave( KErrGeneral );

            }

        else

            { // lint

            }

        writer.WriteL( outputBuffer );

        if ( doneAll == 0 )

            {

            // All of aText has been converted and handled

            writer.CommitL();

            writer.Pop();

            writer.Close();

            return;

            }

        remainderOfUnicodeText.Set( remainderOfUnicodeText.Right( doneAll ) );

        }

    }

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

// CMsgTextUtils::CharconvIdToMibIdL

// 

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

//

EXPORT_C TUint CMsgTextUtils::CharconvIdToMibIdL( TUint aCharconvCharsetId )

    {

    // Switch-case is here for performance optimization

    TUint charset = 0;

    switch ( aCharconvCharsetId )

        {

        case 0:

            // Symbian OS native charset

            charset = KCharacterSetMIBEnumIso10646Ucs2;

            break;

        case KCharacterSetIdentifierAscii:

            charset = KCharacterSetMIBEnumUsAscii;

            break;

        case KCharacterSetIdentifierUtf8:

            charset = KCharacterSetMIBEnumUtf8;

            break;

        case KCharacterSetIdentifierIso88591:

            charset = KCharacterSetMIBEnumISO_8859_1;

            break;

        case KCharacterSetIdentifierIso88592:

            charset = KCharacterSetMIBEnumISO_8859_2;

            break;

        case KCharacterSetIdentifierIso88593:

            charset = KCharacterSetMIBEnumISO_8859_3;

            break;

        case KCharacterSetIdentifierIso88594:

            charset = KCharacterSetMIBEnumISO_8859_4;

            break;

        case KCharacterSetIdentifierIso88595:

            charset = KCharacterSetMIBEnumISO_8859_5;

            break;

        case KCharacterSetIdentifierIso88596:

            charset = KCharacterSetMIBEnumISO_8859_6;

            break;

        case KCharacterSetIdentifierIso88597:

            charset = KCharacterSetMIBEnumISO_8859_7;

            break;

        case KCharacterSetIdentifierIso88598:

            charset = KCharacterSetMIBEnumISO_8859_8;

            break;

        case KCharacterSetIdentifierIso88599:

            charset = KCharacterSetMIBEnumISO_8859_9;

            break;

        case KCharacterSetIdentifierIso885910:

            charset = KCharacterSetMIBEnumISO_8859_10;

            break;

        case KCharacterSetIdentifierIso885913:

            charset = KCharacterSetMIBEnumISO_8859_13;

            break;

        case KCharacterSetIdentifierIso885914:

            charset = KCharacterSetMIBEnumISO_8859_14;

            break;

        case KCharacterSetIdentifierIso885915:

            charset = KCharacterSetMIBEnumISO_8859_15;

            break;

        case KCharacterSetIdentifierUtf7:

            charset = KCharacterSetMIBEnumUtf7;

            break;

        case KCharacterSetIdentifierCodePage1252:

            charset = KCharacterSetMIBEnumCodePage1252;

            break;

        // Chinese charsets

        case KCharacterSetIdentifierGb2312:

            charset = KCharacterSetMIBEnumGb2312;

            break;

        case KCharacterSetIdentifierHz:

            charset = KCharacterSetMIBEnumHz;

            break;

        case KCharacterSetIdentifierGbk:

            charset = KCharacterSetMIBEnumGbk;

            break;

        case KCharacterSetIdentifierBig5:

            charset = KCharacterSetMIBEnumBig5;

            break;

        // Japanese charsets

        case KCharacterSetIdentifierShiftJis:

            charset = KCharacterSetMIBEnumShiftJis;

            break;

        case KCharacterSetIdentifierIso2022Jp:

            charset = KCharacterSetMIBEnumIso2022Jp;

            break;

        case KCharacterSetIdentifierJis:

            charset = KCharacterSetMIBEnumJis;

            break;

        case KCharacterSetIdentifierEucJpPacked:

            charset = KCharacterSetMIBEnumEucJpPacked;

            break;

        default:

            {

            if ( !iCharConv )

                {

                iCharConv = CCnvCharacterSetConverter::NewL();

                }

            charset = iCharConv->ConvertCharacterSetIdentifierToMibEnumL(

                aCharconvCharsetId, iFs );

            if ( charset == 0 )

                {

                charset = KDefaultMIBCharset;

                }

            break;

            }

        }

    return charset;

    }

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

// CMsgTextUtils::MibIdToCharconvIdL

// 

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

//

EXPORT_C TUint CMsgTextUtils::MibIdToCharconvIdL( TUint aMibId )

    {

    // Switch-case is here for performance optimization

    TUint charset = 0;

    switch ( aMibId )

        {

        case KCharacterSetMIBEnumIso10646Ucs2:

        case KCharacterSetMIBEnumUTF16:

            //no conversion for Unicode

            charset = 0;

            break;

        case KCharacterSetMIBEnumUTF16BE:

            charset = KCharacterSetIdentifierUnicodeBig; 

            break;

        case KCharacterSetMIBEnumUTF16LE:

            charset = KCharacterSetIdentifierUnicodeLittle;  

            break;

        case KCharacterSetMIBEnumUsAscii:

            charset = KCharacterSetIdentifierAscii;

            break;

        case KCharacterSetMIBEnumUtf8:

            charset = KCharacterSetIdentifierUtf8;

            break;

        case KCharacterSetMIBEnumISO_8859_1:

            charset = KCharacterSetIdentifierIso88591;

            break;

        case KCharacterSetMIBEnumISO_8859_2:

            charset = KCharacterSetIdentifierIso88592;

            break;

        case KCharacterSetMIBEnumISO_8859_3:

            charset = KCharacterSetIdentifierIso88593;

            break;

        case KCharacterSetMIBEnumISO_8859_4:

            charset = KCharacterSetIdentifierIso88594;

            break;

        case KCharacterSetMIBEnumISO_8859_5:

            charset = KCharacterSetIdentifierIso88595;

            break;

        case KCharacterSetMIBEnumISO_8859_6:

            charset = KCharacterSetIdentifierIso88596;

            break;

        case KCharacterSetMIBEnumISO_8859_7:

            charset = KCharacterSetIdentifierIso88597;

            break;

        case KCharacterSetMIBEnumISO_8859_8:

            charset = KCharacterSetIdentifierIso88598;

            break;

        case KCharacterSetMIBEnumISO_8859_9:

            charset = KCharacterSetIdentifierIso88599;

            break;

        case KCharacterSetMIBEnumISO_8859_10:

            charset = KCharacterSetIdentifierIso885910;

            break;

        case KCharacterSetMIBEnumISO_8859_13:

            charset = KCharacterSetIdentifierIso885913;

            break;

        case KCharacterSetMIBEnumISO_8859_14:

            charset = KCharacterSetIdentifierIso885914;

            break;

        case KCharacterSetMIBEnumISO_8859_15:

            charset = KCharacterSetIdentifierIso885915;

            break;

        case KCharacterSetMIBEnumUtf7:

            charset = KCharacterSetIdentifierUtf7;

            break;

        case KCharacterSetMIBEnumCodePage1252:

            charset = KCharacterSetIdentifierCodePage1252;

            break;

        // Chinese charsets

        case KCharacterSetMIBEnumGb2312:

            charset = KCharacterSetIdentifierGb2312;

            break;

        case KCharacterSetMIBEnumHz:

            charset = KCharacterSetIdentifierHz;

            break;

        case KCharacterSetMIBEnumGbk:

            charset = KCharacterSetIdentifierGbk;

            break;

        case KCharacterSetMIBEnumBig5:

            charset = KCharacterSetIdentifierBig5;

            break;

        // Japanese charsets

        case KCharacterSetMIBEnumShiftJis:

            charset = KCharacterSetIdentifierShiftJis;

            break;

        case KCharacterSetMIBEnumIso2022Jp:

            charset = KCharacterSetIdentifierIso2022Jp;

            break;

        case KCharacterSetMIBEnumJis:

            charset = KCharacterSetIdentifierJis;

            break;

        case KCharacterSetMIBEnumEucJpPacked:

            charset = KCharacterSetIdentifierEucJpPacked;

            break;

        default:

            {

            if ( !iCharConv )

                {

                iCharConv = CCnvCharacterSetConverter::NewL();

                }

            charset = iCharConv->ConvertMibEnumOfCharacterSetToIdentifierL( aMibId, iFs );

            if ( charset == 0 )

                {

                charset = KDefaultCharConvCharset;

                }

            break;

            }

        }

    return charset;

    }

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

// ConvertParagraphSeparatorsLC

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

//

EXPORT_C HBufC* CMsgTextUtils::ConvertParagraphSeparatorsLC( const TDesC& aText )

    {

    TInt position;

    TPtrC ptr;

    TInt numberOfSeparators = 0;

    position = 0;

    ptr.Set( aText.Mid( 0 ) ); 

    while ( position != KErrNotFound && position < aText.Length() )

        {

        ptr.Set( ptr.Mid( position ) ); 

        position = ptr.Locate( TChar( KCharParagraphSeparator ) );

        if ( position != KErrNotFound )

            {

            numberOfSeparators++;

            position++; // point past separator just found

            }

        }

    HBufC* convertedText = HBufC::NewLC( aText.Length() + numberOfSeparators );

    ptr.Set( aText.Mid( 0 ) );

    TInt start = 0;

    position = aText.Locate( TChar( KCharParagraphSeparator ) );

    while ( position != KErrNotFound && start < aText.Length() )

        {

        ptr.Set( aText.Mid( start ) ); 

        position = ptr.Locate( TChar( KCharParagraphSeparator ) );

        if ( position != KErrNotFound )

            {

            convertedText->Des().Append( ptr.Left( position ) );

            convertedText->Des().Append( TChar( KCharCarriageReturn ) );

            convertedText->Des().Append( TChar( KCharLineFeed ) );

            start = start + position + 1; // point past separator

            }

        }

    // append what is left after last separator has been found

    if ( start < aText.Length() )

        {

        convertedText->Des().Append( aText.Mid( start ) );

        }

    return convertedText;

    }