/*

* Copyright (c) 2004-2006 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:  Utils for IM modules.

*

*/

#include "CAUtils.h"

#include "CCAStorageManagerFactory.h"

#include "MCAStoredContacts.h"

#include "ChatDebugPrint.h"

#include "impsbuilddefinitions.h"

#include <EscapeUtils.h>

#include <collate.h>

// needed to skip prefixes in domain-neutral comparison (TUint version)

const TUint KColonUInt( ':' );

// needed to skip domains in domain-neutral comparison (TUint version)

const TUint KAtUInt( '@' );

// general colon needed in various places

_LIT( KColon, ":" );

// general slash needed in various places

_LIT( KSlash, "/" );

// needed to skip domains in domain-neutral comparison

_LIT( KAt, "@" );

// "test character identity and accents, ignore case"

const TInt KCollationLevel = 1;

// max number to store any values

const TInt KMAX_NUMBER = 12;

// max number to fit

const TInt KMAX_LIMIT = 255;

// max number base

const TInt KMAX_NUMBERBASE = 10;

// some character value constants

//const TUint K7LSBMask       = 0x7f     // bitmask for 7 lsb bits

const TUint K8BitMask       = 0xff;     // full bitmask

//const TUint KCharCodeZero   = 0x30     // '0'

//const TUint KCharCodeSmallZ = 0x7a     // 'z'

//const TUint KCharCodeSpace  = 0x20     // ' '

const TUint KCharToArea     = 0x030;

// Unused areas (2) in ISO 8859-1 specification

//const TUint KUnused8859start1 = 0x00

const TUint KUnused8859end1 = 0x1F;

const TUint KUnused8859start2 = 0x7F;

const TUint KUnused8859end2 = 0x9F;

// forbidden characters that cannot appear in Wireless Village Ids

_LIT( KWVForbiddenCharacters, "/@+ \t:" );

/**

 * Constants to use in validation.

 *

 */

_LIT( KCUImpsId_WhiteSpace, " " );

_LIT( KCUImpsId_At, "@" );

_LIT( KCUImpsId_Dot, "." );

_LIT( KCUImpsId_TwoDots, ".." );

_LIT( KCUImpsId_Slash, "/" );

_LIT( KCUImpsId_Plus, "+" );

_LIT( KCUImpsId_Tabulator, "\t" );

_LIT( KCUImpsId_WVPrefix, "wv:" );

_LIT( KCUImpsId_AtEnc, "%40" );

_LIT( KCUImpsId_SlashEnc, "%2F" );

_LIT( KCUImpsId_PlusEnc, "%2B" );

_LIT( KCUImpsId_TabulatorEnc, "%09" );

_LIT( KCUImpsId_WhiteSpaceEnc, "%20" );

// length of "wv:" prefix

const TInt KCUImpsId_WVPrefixLength = 3;

// maximum length of user id

const TInt KServerWVUserIdMaxLength = 50;

// defines how far we are going to search for the protocol part in user id

const TInt KMaxLengthSearchProtPart = 4;

// maximum numerical value to append to generated WVID.

const TInt KMaxAppendNumber = 9999;

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

// CAUtils::NeutralCompare

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

//

TInt CAUtils::NeutralCompare( const TDesC& aId1,

                              const TDesC& aId2, TBool aDomainNeutral )

    {

    // points to user part of id

    TPtrC ptrId1( aId1 );

    TPtrC ptrId2( aId2 );

    // Reduce looking for protocol part only to beginning of the WVID and

    // skip protocol part ("anything:") in the beginning of the WVID

    TInt colonPos1 = aId1.Left( KMaxLengthSearchProtPart ).Locate( KColonUInt );

    // first id

    if ( ( KErrNotFound != colonPos1 ) && ( aId1.Length() - 1 != colonPos1 ) )

        {

        // contains ":", and it is not the last char

        ptrId1.Set( aId1.Mid( colonPos1 + 1 ) );

        }

    TInt colonPos2 = aId2.Left( KMaxLengthSearchProtPart ).Locate( KColonUInt );

    // second id

    if ( ( KErrNotFound != colonPos2 ) && ( aId2.Length() - 1 != colonPos2 ) )

        {

        // contains ":", and it is not the last char

        ptrId2.Set( aId2.Mid( colonPos2 + 1 ) );

        }

    // find out if we have domains in the ids

    TInt domainPos1( ptrId1.Locate( KAtUInt ) );

    TInt domainPos2( ptrId2.Locate( KAtUInt ) );

    TBool domainIn1( KErrNotFound != domainPos1 );

    TBool domainIn2( KErrNotFound != domainPos2 );

    // points to domains in the neutral id

    TPtrC ptrDom1( KNullDesC );

    TPtrC ptrDom2( KNullDesC );

    // points to user parts in the neutral id

    TPtrC ptrUid1( ptrId1 );

    TPtrC ptrUid2( ptrId2 );

    // separate user id parts and domain parts

    if ( domainIn1 )

        {

        ptrDom1.Set( ptrId1.Mid( domainPos1 + 1 ) );

        ptrUid1.Set( ptrId1.Mid( 0, domainPos1 ) );

        }

    if ( domainIn2 )

        {

        ptrDom2.Set( ptrId2.Mid( domainPos2 + 1 ) );

        ptrUid2.Set( ptrId2.Mid( 0, domainPos2 ) );

        }

    // Create custom collation method to ignore punctuations

    // index 0 gets the default method

    TCollationMethod collation =

        *Mem::CollationMethodByIndex( 0 );

    collation.iFlags |= TCollationMethod::EIgnoreNone;

    // domains are compared only when it is really needed

    // check if userid part is the same in both ids

    TInt idResult = ptrUid1.CompareC( ptrUid2, KCollationLevel, &collation );

    if ( idResult != 0 )

        {

        return idResult;

        }

    // id part is same, we have to compare domain

    // If domain comparison is neutral and one id is without domain

    // -> Domains are same. Other situation domainResult stays valid.

    if ( aDomainNeutral && ( domainIn1 ^ domainIn2 ) )

        {

        return 0;

        }

    else

        {

        return ptrDom1.CompareC( ptrDom2, KCollationLevel, &collation );

        }

    }

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

// CAUtils::DisplayId

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

//

TPtrC CAUtils::DisplayId( const TDesC& aId, TBool aListHiding )

    {

    TPtrC ret( aId );

    MCAStoredContacts* contacts = NULL;

    TRAPD( err, contacts = CCAStorageManagerFactory::ContactListInterfaceL() );

    if ( err != KErrNone || !contacts )

        {

        // some error, don't modify

        CHAT_DP_FUNC_DP( "DisplayId", "Got some error, not hiding" );

        return ret;

        }

    // if we've branded the feature out, don't modify anything

    // UI CR : 101-39728:  Check for prefix hiding or Wv hiding.

    if ( contacts->WVHiding() || contacts->WVHidingPrefixOnly() )

        {

        // locate ":" for userid, groupid.

        // locate "/" for list id.

        TInt pos = aId.FindC( aListHiding ? KSlash : KColon );

        if ( ( pos != KErrNotFound ) && ( pos != aId.Length() - 1 ) )

            {

            // contains the special character, and it is not the last char

            // remove everything before the special char (including the char)

            ret.Set( aId.Mid( pos + 1 ) );

            }

        if ( contacts->WVHiding() || aListHiding )

            {

            // remove also the domain part

            TInt domainPos = ret.FindC( KAt );

            if ( ( domainPos != KErrNotFound ) && ( domainPos != 0 ) )

                {

                ret.Set( ret.Mid( 0, domainPos ) );

                }

            }

        }

    return ret;

    }

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

// CAUtils::GenerateIdLC

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

//

HBufC* CAUtils::GenerateIdLC( const TDesC& aId, TInt aNum )

    {

    // copy ID

    HBufC* result = HBufC::NewLC( KServerWVUserIdMaxLength );

    TPtr resultPtr( result->Des() );

    resultPtr.Copy( aId );

    TInt len( resultPtr.Length() );

    // Start from end of data

    for ( TInt i( len - 1 ); i >= 0; --i )

        {

        // Do quick and dirty UNICODE to ISO-8859-1 conversion

        // and modify all non-ISO-8859-1 characters

        // to be in valid ranges

        const TInt& currentChar = resultPtr[ i ];

        TUint ch = currentChar & K8BitMask;

        // is ch in first unused area

        if ( ch <= KUnused8859end1 )

            {

            ch += KUnused8859end1 + 1;

            }

        // is ch in second unused area

        if ( ch >= KUnused8859start2 && ch <= KUnused8859end2 )

            {

            TInt difference = ch - KUnused8859start2;

            ch = KUnused8859end2 + difference + 1;

            }

        TChar isoFixedChar = TChar( ch );

        // put it into the string

        HBufC* isoFixed = HBufC::NewLC( 1 );

        isoFixed->Des().Append( isoFixedChar );

        resultPtr.Replace( i, 1, *isoFixed );

        CleanupStack::PopAndDestroy( isoFixed );

        // now all the specials get removed

        TPtrC c = resultPtr.Mid( i, 1 );  // next character

        TInt position = KWVForbiddenCharacters().FindF( c );

        if ( position != KErrNotFound )

            {

            // the current character is a FORBIDDEN CHARACTER,

            // remove it

            resultPtr.Delete( i, 1 );

            }

        }

    CHAT_DP( D_CHAT_LIT( "CAUtils::GenerateIdLC conversion '%S' -> '%S'" ), &aId, &resultPtr );

    // "Append" number

    if ( aNum > 0 && aNum <= KMaxAppendNumber )

        {

        TBuf<KMAX_NUMBER> number; // 12, enough space to store a very large number

        number.AppendNum( aNum );

        TInt numLength = number.Length();

        TInt resultLength = resultPtr.Length();

        if ( numLength + resultLength > KServerWVUserIdMaxLength )

            {

            // can't append directly because we would exceed the space.

            // use replace instead

            TInt usableSpace = KServerWVUserIdMaxLength - resultLength;

            TInt startPos = resultLength - numLength + usableSpace;

            TInt replaceAmount = numLength - usableSpace;

            resultPtr.Replace( startPos, replaceAmount, number );

            }

        else

            {

            // enough space in the end, just append

            resultPtr.AppendNum( aNum );

            }

        }

    CHAT_DP( D_CHAT_LIT( "CAUtils::GenerateIdLC returning '%S'" ), &resultPtr );

    return result;

    }

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

//  CAUtils::ExternalizeBufferToStreamL

//  Helper method for externalize the buffer

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

//

void CAUtils::ExternalizeBufferToStreamL( const TDesC& aBuffer, RWriteStream& aStream )

    {

    aStream.WriteInt32L( aBuffer.Length() );

    aStream.WriteL( aBuffer );

    }

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

//  CAUtils::ExternalizeBufferToStreamL

//  Helper method for externalize the buffer

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

//

void CAUtils::ExternalizeBufferToStreamL( const TDesC8& aBuffer, RWriteStream& aStream )

    {

    aStream.WriteInt32L( aBuffer.Length() );

    aStream.WriteL( aBuffer );

    }

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

// CAUtils::InternalizeBufferFromStreamL

// Helper method for internalize the buffer

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

//

HBufC* CAUtils::InternalizeBufferFromStreamLC( RReadStream& aStream )

    {

    HBufC* buffer = NULL;

    TInt length = aStream.ReadInt32L();

    if ( length == 0 )

        {

        buffer = KNullDesC().AllocLC();

        }

    else

        {

        buffer = HBufC::NewLC( length );

        TPtr ptr( buffer->Des() );

        aStream.ReadL( ptr, length );

        }

    return buffer;

    }

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

// CAUtils::InternalizeBufferFromStreamL

// Helper method for internalize the buffer

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

//

HBufC8* CAUtils::InternalizeBuffer8FromStreamLC( RReadStream& aStream )

    {

    HBufC8* buffer = NULL;

    TInt length = aStream.ReadInt32L();

    if ( length == 0 )

        {

        buffer = KNullDesC8().AllocLC();

        }

    else

        {

        buffer = HBufC8::NewLC( length );

        TPtr8 ptr( buffer->Des() );

        aStream.ReadL( ptr, length );

        }

    return buffer;

    }

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

// CAUtils::InternalizeBufferFromStreamL

// Helper method for internalize the buffer

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

//

HBufC* CAUtils::InternalizeBufferFromStreamL( RReadStream& aStream )

    {

    HBufC* buffer = InternalizeBufferFromStreamLC( aStream );

    CleanupStack::Pop( buffer );

    return buffer;

    }

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

// CAUtils::InternalizeBufferFromStreamL

// Helper method for internalize the buffer

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

//

HBufC8* CAUtils::InternalizeBuffer8FromStreamL( RReadStream& aStream )

    {

    HBufC8* buffer = InternalizeBuffer8FromStreamLC( aStream );

    CleanupStack::Pop( buffer );

    return buffer;

    }

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

// CAUtils::ValidLoginIdL()

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

//

TBool CAUtils::ValidLoginIdL( const TDesC& aPresenceId )

    {

    TBool incorrectDomain ( EFalse );

    TBool forbiddenChars ( EFalse );

    TBool incorrectUserPart ( EFalse );

    HBufC* wvId = aPresenceId.AllocLC();

    TPtr wvIdPtr = wvId->Des();

    TInt maxLength ( KServerWVUserIdMaxLength );

    // let's take out the "wv:" from beginning of user id

    TInt position( KErrNotFound );

    if ( KCUImpsId_WVPrefix().CompareF( wvId->Left( KCUImpsId_WVPrefix().Length() ) ) == 0 )

        {

        wvIdPtr.Delete( 0, KCUImpsId_WVPrefix().Length() );

        position = KErrNotFound;

        // we just took out 3 characters from the id, we have to adjust the max length

        maxLength = maxLength - KCUImpsId_WVPrefixLength;

        }

    // where is "@" ?

    TInt atIndex( wvId->Find( KCUImpsId_At ) );

    // we want the domain part without the '@'

    TPtrC domainPart( wvId->Mid( atIndex + 1 ) );

    if ( atIndex > 0 )

        {

        // check if the domain part is empty

        if ( domainPart.Length() == 0 )

            {

            incorrectDomain = ETrue;

            }

        }

    else if ( atIndex == 0 )

        {

        // the '@' is the first character

        incorrectUserPart = ETrue;

        }

    TInt returnValue = domainPart.Find( KCUImpsId_At() );

    // check the correctness of the domain part

    if ( returnValue != KErrNotFound )

        {

        // extra @-mark found in the domain part

        incorrectDomain = ETrue;

        }

    returnValue = domainPart.Find( KCUImpsId_Dot() );

    if ( returnValue != KErrNotFound )

        {

        // the part after the '.'

        TPtrC partAfterDot ( domainPart.Mid( returnValue + 1 ) );

        // the part before the '.'

        TPtrC partBeforeDot ( domainPart.Left( returnValue ) );

        // if the '.' is the last character or the first character after the '@'

        // the domain part is wrong

        if ( ( 0 == partAfterDot.Length() ) || ( 0 == partBeforeDot.Length() ) )

            {

            // the '.' is the last character

            incorrectDomain = ETrue;

            }

        }

    returnValue = domainPart.Find( KCUImpsId_TwoDots() );

    if ( returnValue != KErrNotFound )

        {

        // there are two sequential dots in the domain part

        incorrectDomain = ETrue;

        }

    // check the wvid for forbidden chars

    // first we must delete one '@' char if existing

    position = wvIdPtr.Find( KCUImpsId_At );

    if ( position != KErrNotFound )

        {

        wvIdPtr.Delete( position, KCUImpsId_At().Length() );

        }

    returnValue = wvIdPtr.Find( KCUImpsId_WhiteSpace() );

    // no empty chars allowed in the user part

    if ( returnValue != KErrNotFound )

        {

        forbiddenChars = ETrue;

        }

    // no encoded empty chars allowed in the user part

    returnValue = wvIdPtr.Find( KCUImpsId_WhiteSpaceEnc() );

    if ( returnValue != KErrNotFound )

        {

        forbiddenChars = ETrue;

        }

    // no '+' allowed in the user part

    returnValue = wvIdPtr.Find( KCUImpsId_Plus() );

    if ( returnValue != KErrNotFound )

        {

        forbiddenChars = ETrue;

        }

    // no encoded '+' allowed in the user part

    returnValue = wvIdPtr.Find( KCUImpsId_PlusEnc() );

    if ( returnValue != KErrNotFound )

        {

        forbiddenChars = ETrue;

        }