/*

* Copyright (c) 2007-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:  message handler class implementation

*

*/

#include "cimcvenginemessagehandler.h"

#include "mimcvenginechatinterface.h"

#include "mimcvenginemessageswriteinterface.h"

#include "imcvlogger.h"

#include "mimcvenginenewmessagehandler.h"

#include "imcvenginemessageutils.h"

#include "imcvuiliterals.h"

// presence cache

#include <presencecachereader2.h>

#include <imfeatures.h>

#include <imconversation.h>

#include <imobjectfactory.h>

#include <ximpobjectfactory.h>

#include <imconversationinfo.h>

#include <servicepresenceinfo.h>

#include <avabilitytext.h>

#include <apmstd.h> // KMaxDataTypeLength

#include <utf.h>    // CnvUtfConverter

// imcache  related headers

#include    <cimcachefactory.h>

#include	<mimcacheupdater.h>

#include    <mimcacheeventhandler.h>

#include <spsettings.h>

#include <spentry.h>

#include "cimcvengineopenchats.h"

#include "mimcvenginebuffermemoryhandler.h"

#include "cimcvenginestoragelistener.h"

const TInt KMemorySafeValue = 1024; // One kbyte for safe memory allocation.

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

// CIMCVEngineMessageHandler::CIMCVEngineMessageHandler

// ( Other items commented in header )

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

CIMCVEngineMessageHandler::CIMCVEngineMessageHandler( MIMCVEngineChatInterface& aChatInterface,

                                                      MIMCVEngineMessageCreator& aMessageCreator,

				                                      MXIMPContext* aContext, 

				                                      TInt aServiceId )

	: iMessageCreator( aMessageCreator ),

 	 iChatInterface( aChatInterface ),

 	 iContext(aContext),

 	iServiceId( aServiceId )

	{

	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::CIMCVEngineMessageHandler() start") );

	iPresenceStatus =EUnknown; // default status

	iServiceName = NULL;

	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::CIMCVEngineMessageHandler() end") );

	}

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

// CIMCVEngineMessageHandler::~CIMCVEngineMessageHandler

// ( Other items commented in header )

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

CIMCVEngineMessageHandler::~CIMCVEngineMessageHandler()

    {

  	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::~CIMCVEngineMessageHandler() start") );

  	delete iStorageListener;

  	iObserver = NULL;

  	delete iServiceName;

  	delete iPresenceCacheReader ; 

  	if( iIMCacheUpdater )

	  	{

	  	iIMCacheUpdater->UnRegisterObserver(*this);	

	  	}

	if( iIMCacheFactory )

		{

		CIMCacheFactory::Release();

		iIMCacheUpdater = NULL;

		iIMCacheFactory = NULL;

		}

    if(iImFeatures )

	    {

	    delete iImFeatures;

	    iImFeatures = NULL;	

	    }

    iHoldingMessages.Close();

    delete iOpenChats;

    IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::~CIMCVEngineMessageHandler() end") );

    }

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

// CIMCVEngineMessageHandler::NewL

// ( Other items commented in header )

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

CIMCVEngineMessageHandler* CIMCVEngineMessageHandler::NewL( 

					        MIMCVEngineChatInterface& aChatInterface, 

					        MIMCVEngineMessageCreator& aMessageCreator,

					        MXIMPContext* aContext,

					        TInt aServiceId,

						    const TDesC& aOwnId)

    {

  	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::NewL() start") );

    CIMCVEngineMessageHandler* self = CIMCVEngineMessageHandler::NewLC( 

            aChatInterface, 

            aMessageCreator,

            aContext,

		    aServiceId,

		    aOwnId );

    CleanupStack::Pop( self );

    IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::NewL() end") );

    return self;

    }

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

// CIMCVEngineMessageHandler::NewLC

// ( Other items commented in header )

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

CIMCVEngineMessageHandler* CIMCVEngineMessageHandler::NewLC( 

					        MIMCVEngineChatInterface& aChatInterface, 

					        MIMCVEngineMessageCreator& aMessageCreator,

					        MXIMPContext* aContext,

					        TInt aServiceId,

							const TDesC& aOwnId)

    {

    IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::NewLC() start") );

    CIMCVEngineMessageHandler* self = new ( ELeave ) CIMCVEngineMessageHandler( 

            aChatInterface, 

            aMessageCreator, 

             aContext,

             aServiceId );

    CleanupStack::PushL( self );

    self->ConstructL(aOwnId);

    IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::NewLC() end") );

    return self;

    }

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

// CIMCVEngineMessageHandler::ConstructL

// ( Other items commented in header )

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

void CIMCVEngineMessageHandler::ConstructL( const TDesC& aOwnId )

	{

	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::ConstructL() start") );

	 iStorageListener = CIMCVEngineStorageListener::NewL(*this);

	// read the service name	

	ReadServiceNameL( iServiceId );

	// ximp im plugin

	if (iContext)

		{

	    iImFeatures = MImFeatures::NewL(iContext); 

		}

	//initialize the presence cache.

	iPresenceCacheReader = MPresenceCacheReader2::CreateReaderL();													 

    iPresenceCacheReader->SetObserverForSubscribedNotifications(this);

    // im cache factory

    iIMCacheFactory = CIMCacheFactory::InstanceL(); 

    // im cache update interface

    iIMCacheUpdater = iIMCacheFactory->CreateUpdaterL(iServiceId, aOwnId, ETrue );//registration required (ETrue).

    iIMCacheUpdater->RegisterObserverL(*this);

    iOpenChats = CIMCVEngineOpenChats::NewL(*this, iChatInterface,iServiceId );

    IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::ConstructL() end") );

	}	

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

// CIMCVEngineMessageHandler::ReadServiceNameL()

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

//

void CIMCVEngineMessageHandler::ReadServiceNameL(TInt aServiceId )

	{

	CSPSettings* settings = CSPSettings::NewLC();

	// read service name 	

	CSPEntry* entry = CSPEntry::NewLC();

    settings->FindEntryL( aServiceId, *entry ) ;

	iServiceName = NULL;

	iServiceName = entry->GetServiceName().AllocL();

	CleanupStack::PopAndDestroy(2); // entry, settings	

	}

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

// CIMCVEngineMessageHandler::HandleDeliveryReportL

// ( Other items commented in header )

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

void CIMCVEngineMessageHandler::HandleDeliveryReportL(TXIMPRequestId aOperatioCode, TInt aResult)  

	{

	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::HandleDeliveryReportL() start") );

	TInt holdingMessages = iHoldingMessages.Count();

    MIMCVEngineMessage* message = NULL;

    // Check if holding messages hold one ready message

    for(TInt index= 0 ; index < holdingMessages && !message; ++index )

        {

        MIMCVEngineMessage* msg = iHoldingMessages[ index ];

        if(  msg->OperationCode() == aOperatioCode  )

            {

            IM_CV_LOGS(TXT("CIMCVEngineMessageHandler:: pending message index = %d "), index );

            message = msg;

            if( aResult != KErrNone )

				{

				IM_CV_LOGS(TXT("CIMCVEngineMessageHandler:: message failed to deliver") );

				HandleMessageSentFailedL( *iHoldingMessages[ index ] );

				}

			iHoldingMessages.Remove(index);

			NotifyOperationCompletdL(message->MessagerType(), aResult );

            }

        }

	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::HandleDeliveryReportL() end") );	

	}

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

// CIMCVEngineMessageHandler::HandleIMCacheMessageEventL

// ( Other items commented in header )

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

 void CIMCVEngineMessageHandler::HandleConnectionEventL( TIMCVConnectionState aState, TInt aReason )

      {

      if( iObserver )

          {

          iObserver->HandleConnectionEventL( iServiceId, aState, aReason );

          }

      }

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

// CIMCVEngineMessageHandler::HandleIMCacheMessageEventL

// ( Other items commented in header )

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

void CIMCVEngineMessageHandler::HandleIMCacheEventL(TIMCacheEventType aEvent, TAny* aChatMessage )

	{

	switch (aEvent)

		{

		case EIMCacheNewMessage:

			{

			if (!aChatMessage)

				{

				return;	

				}

			SIMCacheMessageData* chatMesssge =  static_cast<SIMCacheMessageData*>( aChatMessage ) ;

			MIMCVEngineMessage::TMessageType messageType =  GetEngineMessageType( chatMesssge->iMessageType ) ;

			MIMCVEngineMessage::TMessagerType messagerType = GetEngineMessagerType( chatMesssge->iMessagerType );

			MIMCVEngineMessage::TContentType contentType = GetEngineContentType( chatMesssge->iContentType ) ;

			IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::HandleIMCacheMessageEventL() Msg ") );

			TTime time = chatMesssge->iTime;

			TPtrC buddyId = chatMesssge->iBuddyId->Des();

			if ( buddyId != KNullDesC )

		        {

		        if( !iChatInterface.MemoryHandler().FreeMemoryIfNeededL( KMemorySafeValue + chatMesssge->iText->Size() ) )

		            {

		            //NotifyMessageError( KErrNoMemory, NULL );

		            User::Leave( KErrNoMemory );

		            }

		        }

			IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::HandleIMCacheMessageEventL() Msg %S"), &buddyId );

			MIMCVEngineMessageCreator::SMessageData data = 

														{

														KMessageDataVersion,

														KNullDesC,

														buddyId,

														chatMesssge->iText->Des(),

														contentType,

														messagerType

														};	

			MIMCVEngineMessageWriteInterface& messageContainer = 

		                	    iChatInterface.MessageWriteInterfaceL(iServiceId, buddyId );

			MIMCVEngineMessage* message	= iMessageCreator.CreateMessageL( data );	

			message->SetTimeStamp(time);

			// Add message

			IMCVEngineMessageUtils::AppendMessageWithDateStampL( 

			                                 *message, 

			                                 messageContainer,

			                                 iMessageCreator );

			break;	

			}

		case EIMCacheNewChat:

			{

			if (!aChatMessage)

				{

				return;	

				}

			SIMCacheChatItem* chatItem =  static_cast<SIMCacheChatItem*>( aChatMessage ) ;

            iStorageListener->GetContactLinkInfoL( chatItem->iServiceId,*(chatItem->iBuddyId));

			MIMCVEngineMessageReadInterface& messageContainer = 

		                	    iChatInterface.MessageReadInterfaceL( chatItem->iServiceId,

		                                                              chatItem->iBuddyId->Des() );

			break;	

			}

		case EIMCacheChatClosed:

			{

			if (!aChatMessage)

				{

				return;	

				}

			SIMCacheChatItem* chatItem =  static_cast<SIMCacheChatItem*>( aChatMessage ) ;

			iChatInterface.DeleteChatL( chatItem->iServiceId, chatItem->iBuddyId->Des() );						

			break;	

			}

		case EIMCacheAllChatClosed:

		    {

			IM_CV_LOGS  (TXT("CIMCVEngineMessageHandler :: HandleChatList Event AL CHAT DELETED"));

			iChatInterface.CloseAllContainers();                     

		    break;  

		    }

		case EIMCacheRequestCompleted :

			{

			NotifyOperationCompletdL(MIMCVEngineMessage::EMessageStarted,  KErrNone ) ;

			break;	

			}	

		default:

			break;

		}

	}

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

// CIMCVEngineMessageHandler::GetEngineMessageType

// ( Other items commented in header )

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

MIMCVEngineMessage::TMessageType  CIMCVEngineMessageHandler::GetEngineMessageType(TIMCacheMessageType aType )

	{

	MIMCVEngineMessage::TMessageType messageType = MIMCVEngineMessage::EMessageInvalid;

	switch( aType )

		{

		case EIMCMessagePTOP:

			{

			messageType = MIMCVEngineMessage::EMessagePTOP;

			break;	

			}

		case EIMCMessageSystem:

			{

			messageType = MIMCVEngineMessage::EMessageSystem;

			break;	

			}

		default :

			{

			break;	

			}

		}

	return messageType;

	}

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

// CIMCVEngineMessageHandler::GetEngineMessagerType

// ( Other items commented in header )

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

MIMCVEngineMessage::TMessagerType CIMCVEngineMessageHandler::GetEngineMessagerType(TIMCacheMessagerType aType )

	{

	MIMCVEngineMessage::TMessagerType messagerType = MIMCVEngineMessage::EMessageOther;

	switch( aType )

		{

		case EIMCMessageSent:

			{

			messagerType = MIMCVEngineMessage::EMessageSent;

			break;	

			}

		case EIMCMessageReceived:

			{

			messagerType = MIMCVEngineMessage::EMessageReceived;

			break;	

			}

		default :

			{

			break;	

			}

		}

	return messagerType;

	}

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

// CIMCVEngineMessageHandler::GetEngineContentType

// ( Other items commented in header )

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

MIMCVEngineMessage::TContentType  CIMCVEngineMessageHandler::GetEngineContentType(TIMCacheContentType aType )

	{

	MIMCVEngineMessage::TContentType contentType = MIMCVEngineMessage::EContentInvalid;

	switch( aType )

		{

		case EIMCContentText:

			{

			contentType = MIMCVEngineMessage::EContentText;

			break;	

			}

		case EIMCContentOther:

			{

			contentType = MIMCVEngineMessage::EContentOther;

			break;	

			}

		default :

			{

			break;	

			}

		}

	return contentType;

	}

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

// CIMCVEngineMessageHandler::MessageCreator

// ( Other items commented in header )

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

MIMCVEngineMessageCreator& CIMCVEngineMessageHandler::MessageCreator() const

    {

    return iMessageCreator;

    }

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

// CIMCVEngineMessageHandler::StartNewConversationL

// ( Other items commented in header )

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

void CIMCVEngineMessageHandler::StartNewConversationL(const TDesC& aRecipientId )

	{

	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::StartNewConversationL() start") );

	if(iIMCacheUpdater)

		{

		iIMCacheUpdater->StartNewConversationL(aRecipientId);

		}

	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::StartNewConversationL() end") );

	}

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

// CIMCVEngineMessageHandler::CloseConversationL

// ( Other items commented in header )

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

TInt CIMCVEngineMessageHandler::CloseConversationL(const TDesC& aBuddyId )

	{

	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::CloseConversationL() start ") );

	if(iIMCacheUpdater)

		{

		iIMCacheUpdater->CloseConversationL( aBuddyId );;

		}

	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::CloseConversation () %S ************"), &aBuddyId);

	UnSubscribePresenceL (aBuddyId);

	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::CloseConversationL() end ") );

	return KErrNone;

	} 

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

// CIMCVEngineMessageHandler::CloseAllConversationL

// ( Other items commented in header )

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

void CIMCVEngineMessageHandler::CloseAllConversationL()

    {

    IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::CloseAllConversationL() start") );

    iPresenceStatus = EOffline;

    if(iIMCacheUpdater  )

        {

        iIMCacheUpdater->CloseAllConversationL();

        }

	TInt count = iOpenChats->Count ();

	for (TInt i = 0; i < count; i++)

		{

			IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::CloseAllConversationL() CLOSING %d, CHAT ************"), i );

			UnSubscribePresenceL (iOpenChats->GetTargetIdL (i));

		}

    IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::CloseAllConversationL() end") );

    } 

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

// CIMCVEngineMessageHandler::DeactivateConversationL

// ( Other items commented in header )

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

TInt CIMCVEngineMessageHandler::DeactivateConversationL()

	{

	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::DeactivateConversation()") );

	if(iIMCacheUpdater)

		{

		return iIMCacheUpdater->DeactivateConversationL();

		}

	return KErrNone;

	} 

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

// CIMCVEngineMessageHandler::SendMessage

// ( Other items commented in header )

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

void CIMCVEngineMessageHandler::SendMessageL(MIMCVEngineMessage& message )

	{

	IM_CV_LOGS(TXT("CIMCVEngineMessageHandler::SendMessageL() start") );

	if(iContext == NULL || iImFeatures == NULL)

		{

		return;	

		}

	MXIMPObjectFactory& objFactory = iContext->ObjectFactory();

	MImConversation& imconversation = iImFeatures->ImConversation();    

	MImConversationInfo* imMessage = iImFeatures->ImObjectFactory().NewImConversationInfoLC();

	MXIMPIdentity* identity = objFactory.NewIdentityLC();  

	identity->SetIdentityL( KMsgId );

	imMessage->SetMessageIdL(identity);

	imMessage->SetTextMessageL( message.Text() );

	CDesCArrayFlat* recipients = new ( ELeave )CDesCArrayFlat( 2 );

	CleanupStack::PushL( recipients);  //userid's

	recipients->AppendL( message.Recipient() );