/*
* Copyright (c) 2002-2007 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:  A class for converts characters into SMS 7 bit format and
*                decides if the data is too long.
*
*/


#include "CPsu2CharConv.h"

// System includes

// Debug headers
#include <Pbk2Debug.h>

/// Unnamed namespace for local definitions
namespace {

const TInt KMaxSizeOfConvertedChar = 5;
const TInt KReductionSize = 3;
const TInt KOneCharacter = 1;
const TInt KTwoBytes = 2;
_LIT( KAtSign, "@" );
const TInt KLineSeparator( 0x2028 );
const TInt KParagraphSeparator( 0x2029 );

} // namespace

// -----------------------------------------------------------------------------
// CPsu2CharConv::CPsu2CharConv
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPsu2CharConv::CPsu2CharConv( RFs& aFs, const TUint aCharacterSet ) :
    iFs( aFs ),
    iCharacterSetIdentifier( aCharacterSet )
    {
    }

// -----------------------------------------------------------------------------
// CPsu2CharConv::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPsu2CharConv::ConstructL()
    {
    iConverter = CCnvCharacterSetConverter::NewL();
    iConverter->PrepareToConvertToOrFromL(
        iCharacterSetIdentifier,
        iFs );
    }

void CPsu2CharConv::SetDownGradeLf( CCnvCharacterSetConverter::
        TDowngradeForExoticLineTerminatingCharacters aDowngrade )
    {
    iConverter->SetDowngradeForExoticLineTerminatingCharacters( aDowngrade );
    }

// -----------------------------------------------------------------------------
// CPsu2CharConv::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPsu2CharConv* CPsu2CharConv::NewL( RFs& aFs, const TUint aChacterSet )
    {
    CPsu2CharConv* self = NewLC( aFs, aChacterSet );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CPsu2CharConv::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPsu2CharConv* CPsu2CharConv::NewLC( RFs& aFs, const TUint aChacterSet )
    {
    CPsu2CharConv* self = new( ELeave ) CPsu2CharConv( aFs, aChacterSet );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------------
// ~CPsu2CharConv
// -----------------------------------------------------------------------------
//
CPsu2CharConv::~CPsu2CharConv()
    {
    delete iConverter;
    }

// -----------------------------------------------------------------------------
// CPsu2CharConv::CheckFieldValidityL
// -----------------------------------------------------------------------------
//
TPtrC CPsu2CharConv::CheckFieldValidityL(
        const TDesC& aData, 
        TInt aMaxLength,
        TPsu2FieldValidity& aValidity )
    {
    TPtrC result( aData );
    aValidity = EOk;

    TBuf8<KMaxSizeOfConvertedChar> convBuf;
    TInt unConv = 0;
    TInt simLength = 0;
    TInt maxUiLength = 0;
    TInt uiLength = aData.Length();
    TBool hasConvertedChar = EFalse;

    // Make the conversion one character at a time
    for ( TInt i = 0; i < uiLength; ++i )
        {
        convBuf.Zero();
        TPtrC ch( aData.Mid( i, KOneCharacter ) );
        User::LeaveIfError( 
            iConverter->ConvertFromUnicode( convBuf, ch, unConv ) );

        if ( unConv > 0 )
            {
            // If the character can't be converted it's unicode,
            // in that case it's assumed that all characters take two bytes as
            // in UCS2 coding scheme 1
            simLength = uiLength * KTwoBytes;
            maxUiLength = aMaxLength / KTwoBytes;
            }
        else
            {
            // Character was converted. If the converted character
            // differs from original, it requires more space from SIM.
            // Make the reduction only once, since it appears not matter
            // how many funny characters there are.
            if ( !hasConvertedChar )
                {
                TBuf16<KMaxSizeOfConvertedChar> convBuf16;
                convBuf16.Copy( convBuf );
                if ( ch.Compare( convBuf16 ) != 0 && ch.Compare( KAtSign ) != 0 )
                    {
                    // SIM max.length is decreased once by 3 chars, if special
                    // char is other than @. This kind of behaviour seems to
                    // be in all SIMs with different name field sizes.
                    aMaxLength -= KReductionSize;
                    hasConvertedChar = ETrue;
                    }
                }
            simLength += convBuf.Length();
            maxUiLength = i;
            }

        if ( simLength > aMaxLength )
            {
            // If length is too long no need to continue checking
            aValidity = ETooLong;
            result.Set( aData.Left( maxUiLength ) );
            break;
            }
        }    

    return result;
    }

// -----------------------------------------------------------------------------
// CPsu2CharConv::CheckFieldLengthL
// -----------------------------------------------------------------------------
//
TPtrC CPsu2CharConv::CheckFieldLengthL(
        const TDesC& aData, 
        TInt aMaxLength,
        TInt& aUnconvertedCount )
    {
    TPtrC result( aData );
    HBufC8* convertedData = HBufC8::NewLC( aData.Length() * KMaxSizeOfConvertedChar );
    TPtr8 convertedDataPtr = convertedData->Des();

    // Start with full length data and remove one character on each iteration
    for( TInt i( aData.Length() ); i > 0; i-- )
        {
        TPtrC convertableData( aData.Left( i ) );
        convertedDataPtr.Zero();

        User::LeaveIfError(
                iConverter->ConvertFromUnicode(
                        convertedDataPtr, convertableData, aUnconvertedCount ) );
        TInt convertedLength = convertedDataPtr.Length();

        // Check if any extra space needs to be reserved (there is some
        // differences in special character conversions between Symbian
        // character converter and SAT)
        ReviseLength( convertableData, convertedLength );

        // Check if the conversion will fit to the space available
        if( convertedLength <= aMaxLength )
            {
            PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING
                ("CPsu2CharConv::CheckFieldLengthL passed, max len: %i"), i );
            // Maximum allowed data length found, no need to continue
            result.Set( convertableData );
            break;
            }
        }

    CleanupStack::PopAndDestroy( convertedData );
    return result;
    }

// -----------------------------------------------------------------------------
// CPsu2CharConv::ReviseMaxLength
// Checks some special cases to need if extra space needs to be reserved for
// the data when saving to (U)SIM.
// -----------------------------------------------------------------------------
//
void CPsu2CharConv::ReviseLength(
        const TDesC& aData, TInt& aConvertedLength )
    {
    // Check if the data contains unicode line/paragraph separator(s).
    // If it does it will require some extra space when saved to (U)SIM.
    for( TInt i(0); i < aData.Length(); i++ )
        {
        if( aData[i] == KLineSeparator || aData[i] == KParagraphSeparator )
            {
            PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING
                ("CPsu2CharConv::CheckFieldLengthL separator found" ) );
            const TInt KParagraphSeparatorExtraSpace(3);
            aConvertedLength += KParagraphSeparatorExtraSpace;
            // Search no more, reserve more space only once
            break;
            }
        }
    }

// -----------------------------------------------------------------------------
// CPsu2CharConv::IsUnicodeL
// 
// -----------------------------------------------------------------------------
//
TBool CPsu2CharConv::IsUnicodeL( const TDesC& aText )
    {
    TBool isUnicode( EFalse );
    TInt unconvertedCount(0);
    HBufC8* convertedText = HBufC8::NewLC( aText.Length() );
    TPtr8 convertedTextPtr = convertedText->Des(); 

    iConverter->ConvertFromUnicode( convertedTextPtr, aText, unconvertedCount );

    // If any characters were not converted or if the converted text is longer
    // than the original the text must be unicode
    if( unconvertedCount > 0 ||
        aText.Length() < convertedText->Length() )
        {
        isUnicode = ETrue;
        }

    CleanupStack::PopAndDestroy( convertedText );
    return isUnicode;
    }

// End of File