/*

* 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:  Class that capsulates single service data members

*

*/

//  INCLUDES

#include "cvimpstengineimsubservice.h"

#include "cvimpstenginecchhandler.h"

#include "cvimpstengineservicetablefetcher.h"

#include "mvimpstengineimsubserviceeventobserver.h"

#include "mvimpstengineserviceconnectioneventobserver.h"

#include <e32std.h>

#include <barsc.h>

#include <gulutil.h>

#include <coemain.h>

#include <e32base.h>

#include "tvimpstconsts.h"

// imcache  related headers

#include "cimcachefactory.h"

#include "mimcacheaccessor.h"

#include "vimpstdebugtrace.h"

//system includes

#include <e32property.h>

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

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

// CVIMPSTEngineIMSubService::NewL

// 

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

CVIMPSTEngineIMSubService* CVIMPSTEngineIMSubService::NewL(

								TUint aServiceId,

								CVIMPSTEngineCchHandler& aCchHandler,

								CVIMPSTEngineServiceTableFetcher& aTableFetcher,

								MVIMPSTEngineServiceConnectionEventObserver& aObserver

								 )

    {

    TRACE( T_LIT("CVIMPSTEngineIMSubService::NewL start"));

    TRACE( T_LIT("NewL() ServiceId: %d"), aServiceId );

    CVIMPSTEngineIMSubService* self = CVIMPSTEngineIMSubService::NewLC(

    												aServiceId,

    												aCchHandler,

    												aTableFetcher,    												

    												aObserver );

    CleanupStack::Pop( self );

	TRACE( T_LIT("CVIMPSTEngineIMSubService::NewL end"));

    return self;

    }

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

// CVIMPSTEngineIMSubService::NewLC

// 

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

CVIMPSTEngineIMSubService* CVIMPSTEngineIMSubService::NewLC(

								TUint aServiceId,

								CVIMPSTEngineCchHandler& aCchHandler,

								CVIMPSTEngineServiceTableFetcher& aTableFetcher,

								MVIMPSTEngineServiceConnectionEventObserver& aObserver

								 )

	{

	TRACE( T_LIT("CVIMPSTEngineIMSubService::NewLC start"));

	TRACE( T_LIT("NewLC() ServiceId: %d"), aServiceId );

    CVIMPSTEngineIMSubService* self = new (ELeave) CVIMPSTEngineIMSubService(aServiceId, 

    												aCchHandler, aTableFetcher,

    												aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    TRACE( T_LIT("CVIMPSTEngineIMSubService::NewLC end"));

    return self;

	}

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

// CVIMPSTEngineIMSubService::~CVIMPSTEngineIMSubService

// 

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

CVIMPSTEngineIMSubService::~CVIMPSTEngineIMSubService()

	{

	TRACE( T_LIT("CVIMPSTEngineIMSubService::~CVIMPSTEngineIMSubService start"));

	iChatObserver.Reset();

    iChatObserver.Close();

	iCchHandler.UnRegisterCchObserver(ECCHIMSub);

	ReleaseIMCacheAccessor();	

	TRACE( T_LIT("CVIMPSTEngineIMSubService::~CVIMPSTEngineIMSubService end"));

 	}

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

// CVIMPSTEngineIMSubService::ConstructL

// 

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

void CVIMPSTEngineIMSubService::ConstructL()

	{			

	TRACE( T_LIT("CVIMPSTEngineIMSubService::ConstructL start"));

	TCCHSubserviceState serviceState = ECCHUninitialized;    

    TInt error = iCchHandler.GetServiceState( 

        			iServiceId, ECCHIMSub, serviceState );

	iServiceState = ResolveServiceStateL(serviceState, error);    	

	iCchHandler.RegisterCchObserverL(this,ECCHIMSub);       

    TRACE( T_LIT("ConstructL() ResolveServiceStateL returned ServiceState: %d"), 

							iServiceState );

    TRACE( T_LIT("CVIMPSTEngineIMSubService::ConstructL end"));

    }

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

// CVIMPSTEngineIMSubService::CVIMPSTEngine

// 

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

CVIMPSTEngineIMSubService::CVIMPSTEngineIMSubService( TUint aServiceId,

								CVIMPSTEngineCchHandler& aCchHandler,

								CVIMPSTEngineServiceTableFetcher& aTableFetcher,

								MVIMPSTEngineServiceConnectionEventObserver& aObserver) :

	iServiceId(aServiceId),

	iCchHandler(aCchHandler),

	iTableFetcher(aTableFetcher),	

	iObserver(aObserver),

	iType (TVIMPSTEnums::EIM)

	{

	}

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

// CVIMPSTEngineIMSubService::RegisterChatObserver

// 

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

void CVIMPSTEngineIMSubService::RegisterChatObserver(MVIMPSTEngineIMSubServiceEventObserver* aObserver)

	{

	TRACE( T_LIT("CVIMPSTEngineIMSubService::RegisterChatObserver start"));	

	if (aObserver)

		{

		TInt index = iChatObserver.Find(aObserver);

		        if( index == KErrNotFound )

		            {

		            iChatObserver.Append( aObserver );   

		            }

		}    	

	TRACE( T_LIT("CVIMPSTEngineIMSubService::RegisterChatObserver end"));

	}

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

// CVIMPSTEngineIMSubService::UnRegisterChatObserver

// 

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

void CVIMPSTEngineIMSubService::UnRegisterChatObserver(MVIMPSTEngineIMSubServiceEventObserver* aObserver)

	{

	TRACE( T_LIT("CVIMPSTEngineIMSubService::UnRegisterChatObserver start"));

	if (aObserver)

		{

		TInt index = iChatObserver.Find(aObserver);

		        if( index >=0 )

		            {

		            iChatObserver.Remove( index );

		            iChatObserver.Compress();

		            }

		}

	TRACE( T_LIT("CVIMPSTEngineIMSubService::UnRegisterChatObserver end"));

	}

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

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

// CVIMPSTEngineIMSubService::HandleIMCacheEventL

// ( Other items commented in header )

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

void CVIMPSTEngineIMSubService::HandleIMCacheEventL(TIMCacheEventType aEventType, TAny* aChatMessage  )

	{

	TRACE( T_LIT("CVIMPSTEngineIMSubService::HandleIMCacheEventL start"));

	TRACE( T_LIT("HandleIMCacheEventL() TIMCacheEventType: %d"), aEventType );

	switch( aEventType )

	    {

	    case EIMCacheUnreadMessage :

	        {

	        if (!aChatMessage)

	            {

	            return;	

	            }

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

	        // check that buddy id exists

	        if ( chatData->iBuddyId )

	            {

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

	            TRACE( T_LIT("HandleIMCacheEventL() EIMCacheUnreadMessage for %S"), 

	                    &buddyId );

	            NotifyObserversL(TVIMPSTEnums::EIMUnreadMessage,buddyId);               

	            }

	        break;	

	        }

	    case EIMCacheUnreadChange :

	        {

	        TRACE( T_LIT("HandleIMCacheEventL() EIMCacheUnreadChange") );

	        if (!aChatMessage)

	            {

	            return; 

	            }

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

	        if( iServiceId != chatItem->iServiceId )

	            {

	            return;

	            }

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

	        TRACE( T_LIT("HandleIMCacheEventL() EIMCacheChatClosed for %S"), 

	                &buddyId );

	        NotifyObserversL(TVIMPSTEnums::EIMUnreadChange, buddyId );  // ETrue for Closed conversation

	        break;

	        }

	    case EIMCacheChatStarted :

	        {

	        if (!aChatMessage)

	            {

	            return; 

	            }

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

	        if( iServiceId != chatItem->iServiceId )

	            {

	            return;

	            }

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

	        TRACE( T_LIT("HandleIMCacheEventL() EIMCacheChatClosed for %S"), 

	                &buddyId );

	        NotifyObserversL(TVIMPSTEnums::EIMChatStarted, buddyId );  // ETrue for Closed conversation 

	        break;  

	        }

	    case EIMCacheChatClosed:

	        {

	        if (!aChatMessage)

	            {

	            return; 

	            }

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

	        if( iServiceId != chatItem->iServiceId )

	            {

	            return;

	            }

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

	        TRACE( T_LIT("HandleIMCacheEventL() EIMCacheChatClosed for %S"), 

	                &buddyId );

	        NotifyObserversL(TVIMPSTEnums::EIMChatClosed, buddyId );                     

	        break;  

	        }

	    case EIMCacheAllChatClosed:

	        {

	        NotifyObserversL(TVIMPSTEnums::EIMAllChatClosed, KNullDesC );                 

	        break;  

	        }

	    case EIMCacheRequestCompleted:

	        {

	        NotifyObserversL(TVIMPSTEnums::EIMRequestCompleted, KNullDesC );  

	        break;

	        }

	    default:

	        {

	        break;

	        }

	    }

	TRACE( T_LIT("CVIMPSTEngineIMSubService::HandleIMCacheEventL end"));

	}

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

// CVIMPSTEngineIMSubService::GetUnreadCountL

// ( Other items commented in header )

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

TInt CVIMPSTEngineIMSubService::GetUnreadCountL(const TDesC& aBuddyId ) 

	{

	TRACE( T_LIT("CVIMPSTEngineIMSubService::GetUnreadCountL start"));

	TRACE( T_LIT("GetUnreadCountL() ServiceId: %d BuddyId: %S"), 

							iServiceId, &aBuddyId );

	TInt count = 0;

	if( iIMCacheAccessor )

		{

		count = iIMCacheAccessor->GetUnreadMessageCountL(aBuddyId);

		TRACE( T_LIT("GetUnreadCountL() iIMCacheAccessor returns with %d"), count );

		}

	TRACE( T_LIT("CVIMPSTEngineIMSubService::GetUnreadCountL end"));

	return count;

	}

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

// CVIMPSTEngineIMSubService::SubServiceState

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

// 

TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEngineIMSubService::SubServiceState() const

	{

	TRACE( T_LIT("SubServiceState() ServiceId: %d ServiceState: %d"), 

							iServiceId, iServiceState );

	return iServiceState;

	}

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

// CVIMPSTEngineIMSubService::IsConversationExistL

// ( Other items commented in header )

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

TBool CVIMPSTEngineIMSubService::IsConversationExistL(const TDesC& aBuddyId) const

	{

	TRACE( T_LIT("CVIMPSTEngineIMSubService::IsConversationExistL start"));

	TRACE( T_LIT("IsConversationExistL() Buddy Id : %S"), &aBuddyId );

	TInt exist = EFalse;

	if( iIMCacheAccessor )

		{

		exist = iIMCacheAccessor->IsConversationExistL( aBuddyId );	

		TRACE( T_LIT("IsConversationExistL() iIMCacheAccessor returns with %d"), exist );

		}

	TRACE( T_LIT("IsConversationExistL() Exist: %d"), exist );	

	TRACE( T_LIT("CVIMPSTEngineIMSubService::IsConversationExistL end"));		

	return exist; 

  	}

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

// CVIMPSTEngineIMSubService::CloseConversationL

// ( Other items commented in header )

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

void CVIMPSTEngineIMSubService::CloseConversationL( const TDesC& aContactId )

    {

    TRACE( T_LIT("CVIMPSTEngineIMSubService::CloseConversationL start"));

    TRACE( T_LIT("CloseConversationL() Buddy Id : %S"), &aContactId  );

    if( IsConversationExistL(aContactId) )

        {

        TRACE( T_LIT("CloseConversationL() iIMCacheAccessor CloseConversationL to be called") );

        iIMCacheAccessor->CloseConversationL( aContactId );

       	TRACE( T_LIT("CloseConversationL() iIMCacheAccessor CloseConversationL Done") );

        }

    TRACE( T_LIT("CVIMPSTEngineIMSubService::CloseConversationL end"));

    }

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

// CVIMPSTEngineIMSubService::GetOpenChatListL

// ( Other items commented in header )

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

RArray<SIMCacheChatItem> CVIMPSTEngineIMSubService::GetOpenChatListL()

    {

    TRACE( T_LIT("CloseConversationL() iIMCacheAccessor GetOpenChatListL called") );

    RArray<SIMCacheChatItem> item;

    if(iIMCacheAccessor)

        {

        item =  iIMCacheAccessor->GetChatListL( iServiceId );

        }

    return item;

    }

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

// CVIMPSTEngineIMSubService::ResolveServiceStateL

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

// 

TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEngineIMSubService::ResolveServiceStateL(

										TCCHSubserviceState aState, 

            							TInt aServiceError )

    {

    TRACE( T_LIT("CVIMPSTEngineIMSubService::ResolveServiceStateL start"));    

    TVIMPSTEnums::TVIMPSTRegistrationState state = TVIMPSTEnums::ESVCENotRegistered;       

    TRACE( T_LIT("ResolveServiceStateL() iServiceId: %d, ServiceState: %d"), 

    							iServiceId, aState );    	

    TBool handleServiceStates = ETrue;

    if ( aServiceError && ECCHDisabled != aState )

        {    

		//Only if the Service supports ALR, the state can goto WaitingForNetwork

		//Still API from CCH is required to know whether ALR is supported or not

        if ( (KCCHErrorInvalidSettings != aServiceError) && (ECCHConnecting == aState) )        

            {   

            TRACE( T_LIT("ResolveServiceStateL() ESVCEWaitingForNetwork") );

            handleServiceStates = EFalse;  

            state = TVIMPSTEnums::ESVCEWaitingForNetwork;	           

            }

        }

    if ( handleServiceStates )

        {        

        switch ( aState )

            {

            case ECCHEnabled:

                {

                TRACE( T_LIT("ResolveServiceStateL() ESVCERegistered") );

                CreateIMCacheAccessorL();

                state = TVIMPSTEnums::ESVCERegistered;

                }

                break;

            case ECCHDisconnecting:      

                {

                TRACE( T_LIT("ResolveServiceStateL() ESVCENetworkDisConnecting") );                

                state = TVIMPSTEnums::ESVCENetworkDisConnecting;

                }

                break;

            case ECCHUninitialized:

            case ECCHDisabled:  

                {

                TRACE( T_LIT("ResolveServiceStateL() ESVCENotRegistered") );

                ReleaseIMCacheAccessor();

                state = TVIMPSTEnums::ESVCENotRegistered;

                }

                break;

            case ECCHConnecting:               

                {

                TRACE( T_LIT("ResolveServiceStateL() ESVCENetworkConnecting") );               

                state = TVIMPSTEnums::ESVCENetworkConnecting;

                }

                break;

            default:

                break;

            }

        }        

	TRACE( T_LIT("CVIMPSTEngineIMSubService::ResolveServiceStateL end"));

    return state;  

    }

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

// CVIMPSTEngineIMSubService::Type

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

//

TVIMPSTEnums::SubServiceType CVIMPSTEngineIMSubService::Type() const	

	{

	TRACE( T_LIT("SubServiceType() Type : %d"), iType );

	TRACE( T_LIT("CVIMPSTEngineIMSubService: [0x%x]"), this );		    	

	return iType;	

	}

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

// CVIMPSTEngineIMSubService::CchEventOccuredL

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

//

void CVIMPSTEngineIMSubService::CchEventOccuredL( 

            TUint /*aServiceId*/, 

            TCCHSubserviceState aState, 

            TInt aServiceError )

	{

	TRACE( T_LIT("CVIMPSTEngineIMSubService::CchEventOccuredL start"));

	TRACE( T_LIT("CchEventOccuredL() TCCHSubserviceState : %d, ServiceErr: %d"), 

									aState, aServiceError );

    if ( aServiceError && ECCHDisabled != aState )

        {

        //we might even end up in waiting for connection state for all

        //those service which are ALR enabled

        //So better check here if you get any CCH errors

        iServiceState = ResolveServiceStateL( aState, aServiceError );

        iObserver.HandleServceConnectionEventL();

        DoHandleCchErrorL( aServiceError );

        }

    else

        {

        iServiceState = ResolveServiceStateL( aState, aServiceError );    

        iObserver.HandleServceConnectionEventL();

        }	

	TRACE( T_LIT("CVIMPSTEngineIMSubService::CchEventOccuredL end"));

	}

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

// CVIMPSTEngineIMSubService::DoHandleCchErrorL()

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

//