/*
* Copyright (c) 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:  Implementation for Open ConversationList 
*
*/


// INCLUDE FILES

#include "cimcvengineopenchats.h"
#include "cimcvenginemessagehandler.h"
#include "mimcvenginechatinterface.h"
#include "mimcvenginemessagecontainerinfo.h"

#include <escapeutils.h>
#include <collate.h>
#include "imcvuiliterals.h"
#include "imcvlogger.h"


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


// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats : Ctor
//
// -----------------------------------------------------------------------------
//
CIMCVEngineOpenChats::CIMCVEngineOpenChats(CIMCVEngineMessageHandler& aMessageHandler, 
								MIMCVEngineChatInterface& aChatInterface) :    
     iActiveItem(-1),
     iMessageHandler(aMessageHandler),
     iChatInterface(aChatInterface)
    {
    }


// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats : NewL
//
// -----------------------------------------------------------------------------
//
CIMCVEngineOpenChats* CIMCVEngineOpenChats::NewL(CIMCVEngineMessageHandler& aMessageHandler,
								MIMCVEngineChatInterface& aChatInterface,TInt aServiceId )
    {
    CIMCVEngineOpenChats* self = new ( ELeave ) CIMCVEngineOpenChats(aMessageHandler, aChatInterface);     
    self->ConstructL(aServiceId);       
    return self;
    }

// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats : Destructor
//
// -----------------------------------------------------------------------------
//
CIMCVEngineOpenChats::~CIMCVEngineOpenChats()
    {
    iChatInterface.UnregisterNewMsgObserver();  
    iChatInterface.UnregisterChatListObserver(this);  
    iOpenChatsArray.Reset();
    }


// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: GetDisplayNameL
// -----------------------------------------------------------------------------
//
TPtrC CIMCVEngineOpenChats::GetDisplayNameL(TInt aIndex) const
	{
	if ( (aIndex >= iOpenChatsArray.Count()) || (aIndex <0) )
	    {	      
	    User::LeaveIfError(KErrArgument);
	    }
    else 
		{		
		
		MIMCVEngineMessageReadInterface* arrayItem = 
						(MIMCVEngineMessageReadInterface*) iOpenChatsArray[aIndex];
		
		if (arrayItem)
			{
			return arrayItem->Name();				
			}			
		}
		
		return TPtrC(KNullDesC);
	}
	

// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: GetTargetIdL
// -----------------------------------------------------------------------------
//
const TDesC& CIMCVEngineOpenChats::GetTargetIdL(TInt aIndex) const
	{
	if ( ( aIndex < iOpenChatsArray.Count() ) && (aIndex >= 0 ) )
	    {	      
			MIMCVEngineMessageReadInterface* arrayItem = 
						(MIMCVEngineMessageReadInterface *)iOpenChatsArray[aIndex];
			if (arrayItem)
				{
				return arrayItem->TargetId().Target();	
				}     
			}
	return (KNullDesC);		
	}



// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: FindIndexL
// -----------------------------------------------------------------------------
//
TInt CIMCVEngineOpenChats::FindIndexL(const TDesC& aItem)
	{
	
	HBufC* decodedItemId = EscapeUtils::EscapeDecodeL( aItem );	
	
	// Create custom collation method to ignore punctuations
    // index 0 gets the default method
    TCollationMethod collation =
        *Mem::CollationMethodByIndex( 0 );
        
    collation.iFlags |= TCollationMethod::EIgnoreNone;
	
	for (TInt index=0; index<iOpenChatsArray.Count(); index++)
		{
		TPtrC ptrId1( GetTargetIdL(index) );
		TPtrC ptrId2( decodedItemId->Des() );

	    // domains are compared only when it is really needed
	    // check if userid part is the same in both ids   
	    TInt idResult = ptrId1.CompareC( ptrId2, KCollationLevel, &collation );

		if( !idResult )
			{
			delete decodedItemId;
			return index;
			}
		}
	
	delete decodedItemId;
	return KErrNotFound;
	}
	
// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: Count
// -----------------------------------------------------------------------------
//
TInt CIMCVEngineOpenChats::Count() const
	{
	return iOpenChatsArray.Count();
	}


// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: SetActiveItemL
// -----------------------------------------------------------------------------
//
void CIMCVEngineOpenChats::SetActiveItemL( const TInt aIndex )
	{
	
	if ( (aIndex >= iOpenChatsArray.Count()) || (aIndex <0) )
	    {	      
	    User::LeaveIfError(KErrArgument);
	    }
	    
	iActiveItem = aIndex;

	}


// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: GetActiveItem
// -----------------------------------------------------------------------------
//
const TDesC& CIMCVEngineOpenChats::GetActiveItem() const
	{
	
	if ( (iActiveItem < iOpenChatsArray.Count()) && (iActiveItem >= 0) )
	    {	      
	    MIMCVEngineMessageReadInterface *arrayItem = 
	    (MIMCVEngineMessageReadInterface *)iOpenChatsArray[iActiveItem];
	    if (arrayItem)
	        {
	        return arrayItem->TargetId().Target();	
	        }
	    }
	return (KNullDesC); 
	
	}


// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: IsMsgPendingL
// -----------------------------------------------------------------------------
//
TBool CIMCVEngineOpenChats::IsMsgPendingL( const TInt aIndex ) const
	{
	if(aIndex >= (iOpenChatsArray.Count()) || aIndex <0)
	    {	      
	    User::LeaveIfError(KErrArgument);
	    }
    else 
		{
		MIMCVEngineMessageReadInterface *arrayItem = 
								(MIMCVEngineMessageReadInterface *)iOpenChatsArray[aIndex];
		if (arrayItem)
			{
			return arrayItem->UnreadCount();        	
			}
		}
	return EFalse;			
	}


// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: ConstructL
// -----------------------------------------------------------------------------
//
void CIMCVEngineOpenChats::ConstructL( TInt aServiceId )
	{
	IM_CV_LOGS(TXT("CIMCVEngineOpenChats ::CONSTRUCTL () ") );
	iChatInterface.RegisterNewMsgObserver( this ); 
	iChatInterface.RegisterChatListObserver( this );	

	RArray<SIMCacheChatItem> chatItem = iMessageHandler.GetChatListL( aServiceId ); 
	IM_CV_LOGS(TXT("CIMCVEngineOpenChats :: CHAT ITEMS COUNT %d"), chatItem.Count () );
	
	for (int index=0; index<chatItem.Count(); index++)
		{
		
		iChatInterface.MessageReadInterfaceL(chatItem[index].iServiceId,
		                                           *chatItem[index].iBuddyId );
		
		delete chatItem[index].iBuddyId;	    
    			
		}
	chatItem.Reset();
	chatItem.Close();
	}
	

// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: Insert
// -----------------------------------------------------------------------------
//
void CIMCVEngineOpenChats::Insert( MIMCVEngineMessageReadInterface* aContainerInfo )
	{	
    iOpenChatsArray.Append( aContainerInfo );
    
    if (iChatObserver)
	    {    
	    TRAP_IGNORE( iChatObserver->HandleChangeL(iMessageHandler.ServiceId(), iOpenChatsArray.Count()-1, ENewChat) );	  
	    }
	}


// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: RemoveL
// -----------------------------------------------------------------------------
//
void CIMCVEngineOpenChats::RemoveL( MIMCVEngineMessageReadInterface& aContainerInfo )
	{
	TInt index = FindIndexL(aContainerInfo.TargetId().Target());
	
	if (KErrNotFound != index)
		{
		iOpenChatsArray.Remove(index);
		iOpenChatsArray.Compress();
		if (iChatObserver)
			{
			iChatObserver->HandleChangeL(iMessageHandler.ServiceId(), index, EChatClosed);		
			}
		}
	}


// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: RegisterObserver
// -----------------------------------------------------------------------------
//
void CIMCVEngineOpenChats::RegisterObserver(MIMCVEngineOpenChatsObserver* aChatObserver)
	{
	iChatObserver = aChatObserver;
	}


// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: UnRegisterObserver
// -----------------------------------------------------------------------------
//
void CIMCVEngineOpenChats::UnRegisterObserver()
	{
	iChatObserver = NULL;
 	}


// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: HandleChatEventL
// -----------------------------------------------------------------------------
//
void CIMCVEngineOpenChats::HandleChatEventL( TChatEventType /*aEvent*/, 
											MIMCVEngineMessage* aMessage /*= NULL*/ ) 
	{
	if (aMessage)
		{
		TInt index = KErrNotFound;
		
		 index = FindIndexL(aMessage->Recipient()) ;
		
		if (KErrNotFound != index)
			{
			MIMCVEngineMessageReadInterface *arrayItem = 
								(MIMCVEngineMessageReadInterface *)iOpenChatsArray[index];
			if (arrayItem && iChatObserver)
				{
				TInt serviceId = iMessageHandler.ServiceId();
				iChatObserver->SetStatusMsgL(serviceId, index,aMessage->Text());
				iChatObserver->HandleChangeL(serviceId, index, EUnReadCountChanged);			
				}	
			}		
		}	
	}


// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: HandleChatListEvent
// -----------------------------------------------------------------------------
//
void CIMCVEngineOpenChats::HandleChatListEvent( TInt aServiceId ,TChatListEventType aEvent, 
									MIMCVEngineMessageReadInterface* aContainerInfo
									) 
	{
		
	switch (aEvent)
		{
		case EChatItemAdded:
			{				
			Insert(aContainerInfo);
			break;
			}

		case EChatItemDeleted:
			{				
			TRAP_IGNORE(RemoveL(*aContainerInfo));
			break;
			}
		case EChatAllItemDeleted:
		    {
		    // not owns
		    iOpenChatsArray.Reset();
		    if (iChatObserver)
		        {
		        TRAP_IGNORE( iChatObserver->HandleChangeL( aServiceId, KErrNotFound, EChatAllClosed ) );      
		        }
		    }
		default:
			break;
		}
	
	}
	
// -----------------------------------------------------------------------------
// CIMCVEngineOpenChats: ResetL
// -----------------------------------------------------------------------------
//
void CIMCVEngineOpenChats::ResetL()
	{
	iOpenChatsArray.Reset();
	iActiveItem = -1;		
	}
		
// End of File