/*
* 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:  write right class implemetation
*
*/

//  INCLUDE FILES
#include "cimcacheupdater.h"

#include <imcachedefs.h>
// logs
#include "imcachedebugtrace.h"

#include <e32base.h>
#include <s32mem.h>

//Received message maximum length is 400 character if received message is 
//longer than 400 character truncate it to 400 character
//This must always be in sync with imcvuiapp KReceiveMsgMaxLength
const TInt KReceiveMsgMaxLength = 400; 
_LIT(KPercentage, "%");
// -----------------------------------------------------------------------------
// CIMCacheUpdater::NewL()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CIMCacheUpdater* CIMCacheUpdater::NewL(TInt aServiceId,
											const TDesC& aSenderId ,TBool aRegistrationNeeded )
    {
    TRACE( T_LIT("CIMCacheUpdater::NewL begin") );
    CIMCacheUpdater* self = new ( ELeave ) CIMCacheUpdater( aServiceId ) ;
    CleanupStack::PushL( self );
    self->ConstructL( aSenderId, aRegistrationNeeded );
    CleanupStack::Pop( self );  //self
    TRACE( T_LIT("CIMCacheUpdater::NewL end") );
    return self;
    }
// -----------------------------------------------------------------------------
// CIMCacheUpdater::ConstructL()
// Symbian OS default constructor can leave.
// -----------------------------------------------------------------------------
//
void CIMCacheUpdater::ConstructL( const TDesC& aSenderId ,TBool aRegistrationNeeded )
    {
    TRACE( T_LIT("CIMCacheUpdater::ConstructL begin") );
    iUserId = aSenderId.AllocL();
    User::LeaveIfError( iClient.Connect() );
    EIMCacheOperations opration = EIMCacheInitUpdate;
    if( aRegistrationNeeded )
	    {
	    opration = EIMCacheInitConvesation;	
	    }
    iClient.StartTransactionL(opration, iServiceId, *iUserId );
	TRACE( T_LIT("CIMCacheUpdater::ConstructL end") );
    }
// -----------------------------------------------------------------------------
// CIMCacheUpdater::~CIMCacheUpdater()
// Destructor
// -----------------------------------------------------------------------------
//
CIMCacheUpdater::~CIMCacheUpdater()
    {
    TRACE( T_LIT("CIMCacheUpdater::~CIMCacheUpdater begin") );
    delete iUserId;
    //do not close the client session here. since there is also accessor class which is closing the session
    //moved this part of code which is common to both udpater and Accessor i.e, client ~CIMCacheClient()
    //iClient.Close();
    TRACE( T_LIT("CIMCacheUpdater::~CIMCacheUpdater end") );
    }
// -----------------------------------------------------------------------------
// CIMCacheUpdater::CIMCacheUpdater()
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CIMCacheUpdater::CIMCacheUpdater(TInt aServiceId )
	:iServiceId( aServiceId )
	{
	TRACE( T_LIT("CIMCacheUpdater::CIMCacheUpdater ") );
	}


// -----------------------------------------------------------------------------
// CIMCacheUpdater::StartNewConversationL()
// -----------------------------------------------------------------------------
//
void CIMCacheUpdater::StartNewConversationL(const TDesC& aBuddyId )
	{
	TRACE( T_LIT("CIMCacheUpdater::StartNewConversationL begin") );
	if( !aBuddyId.Length() )
		{
		User::Leave( KErrArgument )	;
		}
	iClient.StartTransactionL(EIMCacheStartNewConversation, iServiceId , aBuddyId  );
	
	TRACE( T_LIT("CIMCacheUpdater::StartNewConversationL end") );
	}
	
// -----------------------------------------------------------------------------
// CIMCacheUpdater::AppendReceiveMessageL()
// -----------------------------------------------------------------------------
//
void CIMCacheUpdater::AppendReceiveMessageL( const TDesC& aBuddyId, 
											 const TDesC& aText )
    {
    TRACE( T_LIT("CIMCacheUpdater::AppendReceiveMessageL begin") );	
    if( !aBuddyId.Length() )
        {
        User::Leave( KErrArgument )	;
        }
    TInt len = aText.Length();
    HBufC* bigmsg = NULL;
    bigmsg = HBufC::NewLC(KReceiveMsgMaxLength + 1) ; // 1 for  %
    if( bigmsg )
        {
        TRACE( T_LIT("Inside if( bigmsg )") );
        TPtr bigmsgPtr = bigmsg->Des();
        //If message is more than 400 character take only first 400 character
        //rest of the message will be lost
        bigmsgPtr.Append( aText.Left( KReceiveMsgMaxLength ) ); 
        if( len > KReceiveMsgMaxLength)
            {
            //append % as 401st character to identify on UI that it is a 
            //long message which is truncated        
            bigmsgPtr.Append(KPercentage); 
            }

        iClient.StartTransactionL(EIMCacheAppendReceiveMessage, iServiceId, aBuddyId , bigmsgPtr );

        CleanupStack::PopAndDestroy(bigmsg); // bigmsg
        }
	TRACE( T_LIT("CIMCacheUpdater::AppendReceiveMessageL end") );
	}
// -----------------------------------------------------------------------------
// CIMCacheUpdater::AppendSendMessageL()
// -----------------------------------------------------------------------------
//
void CIMCacheUpdater::AppendSendMessageL(const TDesC& aText )
	{
  	TRACE( T_LIT("CIMCacheUpdater::AppendSendMessageL begin") );
  	
	iClient.StartTransactionL( EIMCacheAppendSendMessage , aText);	
	TRACE( T_LIT("CIMCacheUpdater::AppendSendMessageL end") );
	}

// -----------------------------------------------------------------------------
// CIMCacheUpdater::AppendMessageL()
// -----------------------------------------------------------------------------
//
void CIMCacheUpdater::AppendMessageL(const TDesC& aBuddyId, const TDesC& aText )
	{
  	TRACE( T_LIT("CIMCacheUpdater::AppendMessageL begin") );
	if( !aBuddyId.Length() )
		{
		User::Leave( KErrArgument )	;
		}
	iClient.StartTransactionL(EIMCacheAppendMessage, iServiceId, aBuddyId, aText);	
	TRACE( T_LIT("CIMCacheUpdater::AppendMessageL end") );
	}

// -----------------------------------------------------------------------------
// CIMCacheUpdater::CloseConversation()
// -----------------------------------------------------------------------------
//
void CIMCacheUpdater::CloseConversationL( const TDesC& aBuddyId )
    {
    TRACE( T_LIT("CIMCacheUpdater::CloseConversationL begin") ); 
    
	if( !aBuddyId.Length() )
		{
		User::Leave( KErrArgument )	;
		}
    iClient.StartTransactionL( EIMCacheCloseConversation,
								iServiceId, 
								aBuddyId                                
								);
    TRACE( T_LIT("CIMCacheUpdater::CloseConversationL end") );
   }

// -----------------------------------------------------------------------------
// CIMCacheUpdater::CloseConversation()
// -----------------------------------------------------------------------------
//
void CIMCacheUpdater::CloseAllConversationL()
    {
    TRACE( T_LIT("CIMCacheUpdater::CloseAllConversationL begin") ); 
    iClient.StartTransactionL( EIMCacheCloseAllConversation );
    TRACE( T_LIT("CIMCacheUpdater::CloseAllConversationL end") );
    }
// -----------------------------------------------------------------------------
// CIMCacheUpdater::DeactivateConversationL()
// -----------------------------------------------------------------------------
//
TInt CIMCacheUpdater::DeactivateConversationL( )
	{
	TRACE( T_LIT("CIMCacheUpdater::DeactivateConversationL begin") );
	
	TInt error = iClient.StartTransactionL( EIMCacheDeactivateConversation );
								 
	TRACE( T_LIT("CIMCacheUpdater::DeactivateAllConversationsL end") );
	return error;
	}
// -----------------------------------------------------------------------------
// CIMCacheUpdater::ServiceId()
// -----------------------------------------------------------------------------
//
TInt CIMCacheUpdater::ServiceId() const 
	{
	return iServiceId;	
	}

// -----------------------------------------------------------------------------
// CIMCacheAccess::RegisterObserverL()
// -----------------------------------------------------------------------------
//
void CIMCacheUpdater::RegisterObserverL( MIMCacheEventHandler& aObserver  )
	{
	TRACE( T_LIT("CIMCacheAccess::RegisterObserverL begin") );
	// update case ETrue says CV is active
	// cch need not to register
	iClient.RegisterUpdateObserverL( aObserver  );
	TRACE( T_LIT("CIMCacheAccess::RegisterObserverL end") );
	}

// -----------------------------------------------------------------------------
// CIMCacheAccess::UnRegisterObserverL()
// -----------------------------------------------------------------------------
//
void CIMCacheUpdater::UnRegisterObserver( MIMCacheEventHandler& aObserver )
	{
	TRACE( T_LIT("CIMCacheAccess::UnRegisterObserverL begin") );
	iClient.UnRegisterUpdateObserver( aObserver );
	TRACE( T_LIT("CIMCacheAccess::UnRegisterObserverL end") );
	}	
  
// -----------------------------------------------------------------------------
// CIMCacheAccess::GetChatListL()
// -----------------------------------------------------------------------------
//
RArray<SIMCacheChatItem> CIMCacheUpdater::GetChatListL( const TInt aServiceId  )
	{
	TRACE( T_LIT("CIMCacheUpdater::GetChatListL") );	
	RArray<SIMCacheChatItem> chatListArray;//array to hold chat item
	TBool more = EFalse;
	TPtr8 bufferPtr =  iClient.GetChatListL( aServiceId );
	InternalizeChatListL( chatListArray, bufferPtr, more );
	
	while( more)
		{
		bufferPtr = iClient.GetBufferedDataL( EIMCacheGetBufferedPackets );
		InternalizeChatListL( chatListArray, bufferPtr, more );
		}
	return chatListArray;
	}
    
// -----------------------------------------------------------------------------
// CIMCacheUpdater::InternalizeChatListL
// -----------------------------------------------------------------------------
//
void CIMCacheUpdater::InternalizeChatListL(RArray<SIMCacheChatItem>& aChatArray, TPtr8 aChatListBuffer ,TBool& aMore )
    {
    TRACE( T_LIT("CIMCacheUpdater::InternalizeChatListL() begin") );   
    
    RDesReadStream readAllStream ;
    RDesReadStream readStream ;    
    
    readAllStream.Open( aChatListBuffer );
    CleanupClosePushL(readAllStream);
    
    TInt messageCount = readAllStream.ReadInt16L();
    
    for( TInt i=0; i< messageCount; i++)
        {
        SIMCacheChatItem chatItem =
          {
          0,
          };
                
        TInt size = readAllStream.ReadInt16L() ;
        HBufC8* mBuffer  = HBufC8::NewLC( size );
        TPtr8 mBufferPtr = mBuffer->Des();
                
        readAllStream.ReadL( mBufferPtr , size );
        
        readStream.Open( *mBuffer );        
        CleanupClosePushL(readStream) ;
        
        chatItem.iServiceId  = static_cast<TInt>( readStream.ReadInt16L() );
        
        TInt textSize = readStream.ReadInt16L();
        HBufC* buddyId = HBufC::NewLC( textSize );
        TPtr buddyIdPtr = buddyId->Des(); 
        readStream.ReadL( buddyIdPtr , textSize);
        
        chatItem.iBuddyId = buddyId;
        CleanupStack::Pop(buddyId); // ownership to structure variable
        aChatArray.Insert(chatItem, 0);
        CleanupStack::PopAndDestroy(2);//close read stream, delete mBuffer.                
        }
    aMore = static_cast<TBool>( readAllStream.ReadInt16L() );
    
    CleanupStack::PopAndDestroy();//readAllStream.    
    
    TRACE( T_LIT("CIMCacheUpdater::InternalizeChatListL() End") );
    }

//  END OF FILE