/*
* Copyright (c) 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 <bamdesca.h>
#include <s32strm.h>
#include "presencecachebuddyinfo.h"
#include <utf.h>

#define STRCNST(x)  (const_cast<TDesC*>( &x ))

// -----------------------------------------------------------------------------
CPresenceCacheBuddyInfo::CPresenceCacheBuddyInfo()
    {
    // No implementation required
    }

// -----------------------------------------------------------------------------
CPresenceCacheBuddyInfo::~CPresenceCacheBuddyInfo()
    {      
    iHashMap.Close();  
    delete iAvailabilityTextBuf;
    delete iStatusTextBuf;
    delete iBuddyId;
    
    iIds.ResetAndDestroy();
    iIds.Close();
    iValues.ResetAndDestroy();
    iValues.Close();    
    }

// ---------------------------------------------------------------------------
// MPresenceBuddyInfo2::NewL()
// ---------------------------------------------------------------------------
//
EXPORT_C MPresenceBuddyInfo2* MPresenceBuddyInfo2::NewL( )
    {
    return CPresenceCacheBuddyInfo::NewL( );
    }
    
EXPORT_C MPresenceBuddyInfo2* MPresenceBuddyInfo2::NewLC( )
    {
    CPresenceCacheBuddyInfo* info = CPresenceCacheBuddyInfo::NewLC( );
    CleanupStack::Pop(info);
    MPresenceBuddyInfo2* minfo = info;  
    CleanupDeletePushL(minfo);
    return minfo; 
    }
    
// -----------------------------------------------------------------------------
CPresenceCacheBuddyInfo* CPresenceCacheBuddyInfo::NewL()
    {
    CPresenceCacheBuddyInfo* self = NewLC();
    CleanupStack::Pop(); // self;    
    return self;
    }
    
// -----------------------------------------------------------------------------
CPresenceCacheBuddyInfo* CPresenceCacheBuddyInfo::NewLC()
    {
    CPresenceCacheBuddyInfo* self = new (ELeave)CPresenceCacheBuddyInfo();
    CleanupStack::PushL(self);
    self->ConstructL();  
    return self;
    }    
    
// -----------------------------------------------------------------------------
static TUint32 StringPtrHash( TDesC* const& aValue )
    {
    return DefaultHash::Des16( *aValue );
    }

// -----------------------------------------------------------------------------
static TBool StringIdentity( TDesC* const& aA, TDesC* const& aB )
    {
    return !aA->CompareF( *aB );
    }

// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::ConstructL()
    {
    iHashMap.Close();
    iHashMap = RHashMap<TDesC*, TInt>(    
        THashFunction32<TDesC*>( StringPtrHash ),
        TIdentityRelation<TDesC*>( StringIdentity ) );
    }

// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::SetIdentityL( 
    const TDesC& aBuddyId )
    {
    delete iBuddyId;
    iBuddyId = NULL;
    iBuddyId = aBuddyId.AllocL( );        
    }
    
// -----------------------------------------------------------------------------
TPtrC CPresenceCacheBuddyInfo::BuddyId( ) const
    {
    return iBuddyId ? iBuddyId->Des() : TPtrC();
    }

// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::SetAvailabilityL( 
    TAvailabilityValues aAvailability,
    const TDesC& aAvailabilityText )
    {  
    iAvailability = aAvailability;    
    DoSet16BitValueL( NPresenceCacheFieldName::KAvailability, aAvailabilityText );
    }

// -----------------------------------------------------------------------------
MPresenceBuddyInfo2::TAvailabilityValues CPresenceCacheBuddyInfo::Availability( )
    {
    return iAvailability;    
    }
    
// -----------------------------------------------------------------------------
TPtrC CPresenceCacheBuddyInfo::AvailabilityText( )
    {
    return DoGet16BitValue( NPresenceCacheFieldName::KAvailability );
    }

// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::DoSet16BitValueL( 
    const TDesC& aKey,    
    const TDesC& aValue )
    {   
      
    // Remove old values first
    RemoveField( aKey );
    
    //Convert Unicode to Utf-8
    HBufC8* convertBuffer =  CnvUtfConverter::ConvertFromUnicodeToUtf8L( aValue );
    CleanupStack::PushL( convertBuffer );
    HBufC* keyBuffer = aKey.AllocLC();    
    
    TInt insertPos = iIds.Find(0);
    if ( insertPos < 0 )
        {
        insertPos = iIds.Count();
        iIds.Append( keyBuffer );
        iValues.Append( convertBuffer );
        }
    else
        {
        iIds[insertPos] = keyBuffer;
        iValues[insertPos] = convertBuffer;
        }
    
    iHashMap.InsertL( keyBuffer, insertPos  );
        
    CleanupStack::Pop( keyBuffer );
    CleanupStack::Pop( convertBuffer );       
    }

// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::RemoveField(const TDesC& aKey )
    {
    TInt* pos = iHashMap.Find( STRCNST( aKey ) );    
    if ( pos )
        {
        TInt mypos = *pos;
        iHashMap.Remove( iIds[mypos ]);
        
        delete iIds[mypos];
        iIds[mypos] = NULL;
        
        delete iValues[mypos];
        iValues[mypos] = NULL;               
        }    
    }

// -----------------------------------------------------------------------------
TPtrC CPresenceCacheBuddyInfo::DoGet16BitValue(const TDesC& aKey )
    {
    HBufC8* val = NULL;        
    TInt* pos = iHashMap.Find( STRCNST( aKey ) );
    TPtrC result( KNullDesC() );
    
    if ( pos )
        {       
        val = iValues[*pos];
        if ( val )
            {
            HBufC* temp = NULL;
            // Convert  Utf-8 to Unicode
            TRAPD( errx,  temp = CnvUtfConverter::ConvertToUnicodeFromUtf8L( *val ) );
            if ( !errx && temp )
                { 
                // Avalibility text handled here
                if ( !aKey.CompareF( NPresenceCacheFieldName::KAvailability ) )
                	{
                    delete iAvailabilityTextBuf;
                    iAvailabilityTextBuf = NULL;                 	
                    iAvailabilityTextBuf = temp; 
                    result.Set( iAvailabilityTextBuf->Des() );
                	}
                // Status message handled here
                else if( !aKey.CompareF( NPresenceCacheFieldName::KStatusMessage ) )
                	{
                    delete iStatusTextBuf;
                    iStatusTextBuf = NULL;                 	
                    iStatusTextBuf = temp;  
                    result.Set( iStatusTextBuf->Des() );
                	}
                }
            }
        }
    return result;
    }
    
// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::SetAvatarL( 
    const TDesC8& aAvatar )
    {
    SetAnyFieldL( NPresenceCacheFieldName::KAvatar, aAvatar);
    }
    
// -----------------------------------------------------------------------------
TPtrC8 CPresenceCacheBuddyInfo::Avatar( )
    {
    return GetAnyField( NPresenceCacheFieldName::KAvatar ); 
    }
    
// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::SetStatusMessageL( 
    const TDesC& aStatusMessage )
    {
    DoSet16BitValueL( NPresenceCacheFieldName::KStatusMessage, aStatusMessage );
    }


// -----------------------------------------------------------------------------
TPtrC CPresenceCacheBuddyInfo::StatusMessage(  )
    {
    return DoGet16BitValue( NPresenceCacheFieldName::KStatusMessage );
    }
    
// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::SetAnyFieldL( 
    const TDesC16& aKey,
    const TDesC8& aValue )
    {
    if( NPresenceCacheFieldName::KExpiry().CompareF( aKey ) == 0 )
        {
        TPckg<TInt64> expiryPck( iExpiryTime );
        expiryPck.Copy( aValue );
        // write also to key-value map
        }
    
    // Remove old values first
    RemoveField( aKey );    
    
    HBufC8* valueBuffer = aValue.AllocLC();      
    HBufC* keyBuffer = aKey.AllocLC();  
    
    TInt insertPos = iIds.Find(0);
    if ( insertPos < 0 )
        {
        insertPos = iIds.Count();
        iIds.Append( keyBuffer );
        iValues.Append( valueBuffer );
        }
    else
        {
        iIds[insertPos] = keyBuffer;
        iValues[insertPos] = valueBuffer;
        }
    
    iHashMap.InsertL( keyBuffer, insertPos  ); 
    
    CleanupStack::Pop( keyBuffer );
    CleanupStack::Pop( valueBuffer );    
    }

// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::SetAnyFieldPtrL( 
    HBufC16* aKey,
    HBufC8* aValue )
    {  
    if ( !aKey )
        {
        User::Leave( KErrArgument );
        }
    // Remove old values first
    RemoveField( aKey->Des() );
         
    TInt insertPos = iIds.Find(0);
    if ( insertPos < 0 )
        {
        insertPos = iIds.Count();
        iIds.Append( aKey );
        iValues.Append( aValue );
        }
    else
        {
        iIds[insertPos] = aKey;
        iValues[insertPos] = aValue;
        }
    iHashMap.InsertL( aKey, insertPos  );       
    }
    
// -----------------------------------------------------------------------------
TPtrC8 CPresenceCacheBuddyInfo::GetAnyField( 
    const TDesC16& aKey )
    {
    HBufC8* val = NULL;    
    TInt* pos = iHashMap.Find( STRCNST( aKey ) );
    if ( pos )
        {       
        val = iValues[*pos];        
        } 
    return val ? val->Des() : TPtrC8();    
    }
    
// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::GetFieldKeysL( 
    CDesCArrayFlat& aKeys )
    {
    aKeys.Reset();
    THashMapIter<TDesC*, TInt> iter(iHashMap);    
    TDesC* const* nextKey = iter.NextKey();
    while (nextKey)
        {
        aKeys.AppendL( **nextKey );
        nextKey = iter.NextKey();
        }    
    }
                                                                          
// -----------------------------------------------------------------------------
TBool CPresenceCacheBuddyInfo::EqualsIdentity(
    const MPresenceBuddyInfo2& aOtherInstance ) const
    {
    TBool same = ETrue;

    TBool x;
    x = 0 == BuddyId().CompareF( aOtherInstance.BuddyId() );
    same &= x;

    return same;
    }  

// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::ExternalizeL( RWriteStream& aStream ) const
    {
    aStream.WriteInt32L( iAvailability ); 
    ExternalizeFieldL( BuddyId(), aStream );
           
    // externalize expiry time
    TUint32 time_high = I64HIGH( iExpiryTime );
    TUint32 time_low = I64LOW( iExpiryTime );
    aStream.WriteUint32L(time_high);
    aStream.WriteUint32L(time_low);
    
    TInt count = iIds.Count();
    aStream.WriteInt32L( count );     
    for ( TInt i=0; i < count; i++ )
        {
        if ( iIds[i] )
            {
            TPtrC key = iIds[i]->Des();
            TPtrC8 value = iValues[i] ? iValues[i]->Des() : TPtrC8();        
            ExternalizeFieldL( key, aStream );        
            ExternalizeFieldL( value, aStream );             
            }
        else
            {
            // nothing to insert, special case if replacement has been failed earlier
            }
        }
    } 

// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::InternalizeL( RReadStream& aStream )
    {
    iAvailability = (MPresenceBuddyInfo2::TAvailabilityValues)aStream.ReadInt32L( ); 
    
    HBufC* temp  = InternalizeFieldL( aStream );
    iBuddyId = temp;
       
    iIds.ResetAndDestroy();
    iValues.ResetAndDestroy();
    
    HBufC* key = NULL;
    HBufC8* value = NULL;

    // internalize expiry time
    TUint32 time_high = aStream.ReadUint32L();
    TUint32 time_low = aStream.ReadUint32L();
    iExpiryTime = MAKE_TINT64( time_high, time_low );
    
    TInt count = aStream.ReadInt32L( );    
    for ( TInt i=0; i < count; i++ )
        {
        key = InternalizeFieldL( aStream ); 
        
        CleanupStack::PushL( key );
        value = InternalizeField8L( aStream );
        CleanupStack::Pop( key );          
        // This takes ownership anyway.
        SetAnyFieldPtrL( key, value );                       
        }      
    } 

// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::ExternalizeFieldL( const TDesC& aData, RWriteStream& aStream ) const
    {
    TInt32 length = aData.Length();    
    aStream.WriteInt32L( length  );
    aStream.WriteL( aData, length );
    }

// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::ExternalizeFieldL( const TDesC8& aData, RWriteStream& aStream ) const
    {
    TInt32 length = aData.Length();    
    aStream.WriteInt32L( length  );
    aStream.WriteL( aData, length );
    }

// -----------------------------------------------------------------------------
HBufC* CPresenceCacheBuddyInfo::InternalizeFieldL( RReadStream& aStream )
    {
    HBufC16* temp = NULL;    
    TInt32 length = aStream.ReadInt32L();
    if ( length > 0 )
        { 
        temp = HBufC::NewLC( length);
        TPtr stringPtr = temp->Des(); 
        aStream.ReadL( stringPtr, length );
        CleanupStack::Pop( temp );
        } 
    else
        {
        }
    return temp;
    }

// -----------------------------------------------------------------------------
HBufC8* CPresenceCacheBuddyInfo::InternalizeField8L( RReadStream& aStream )
    {
    HBufC8* temp = NULL;    
    TInt32 length = aStream.ReadInt32L();
    if ( length > 0 )
        { 
        temp = HBufC8::NewLC( length);
        TPtr8 stringPtr = temp->Des(); 
        aStream.ReadL( stringPtr, length );
        CleanupStack::Pop( temp );
        } 
    else
        {
        }
    return temp;
    }