/*

* 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:  container class for im messages

*

*/

#include "cimcvenginechatcontainer.h"

#include "cimcvenginemessagecontainer.h"

#include "mimcvenginenewmsgobserver.h"

#include "mimcvenginemessage.h"

#include <hal.h>

#include "imcvlogger.h"

#include "mimcvenginechatlistobserver.h"

#include <hal.h>

const TInt KMinAvailableMemory = 0x32000; // 200kb

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

// CIMCVEngineChatContainer::CIMCVEngineChatContainer

// ( Other items commented in header )

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

CIMCVEngineChatContainer::CIMCVEngineChatContainer(TInt aServiceId):

    iServiceId( aServiceId )

	{	

	}

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

// CIMCVEngineChatContainer::CIMCVEngineChatContainer

// ( Other items commented in header )

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

CIMCVEngineChatContainer::~CIMCVEngineChatContainer()

	{

	iChatContainer.ResetAndDestroy();	

	iSendContainer.ResetAndDestroy();

	iNewMsgObserver = NULL;

	iChatListObservers.Reset();

	}

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

// CIMCVEngineChatContainer::NewL

// ( Other items commented in header )

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

CIMCVEngineChatContainer* CIMCVEngineChatContainer::NewL(TInt aServiceId)

	{

	CIMCVEngineChatContainer* self = 

	        new ( ELeave ) CIMCVEngineChatContainer(aServiceId);

	return self;

	}	

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

// CIMCVEngineChatContainer::MessageReadInterfaceL

// ( Other items commented in header )

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

MIMCVEngineMessageReadInterface& CIMCVEngineChatContainer::MessageReadInterfaceL(                  

                 TInt aServiceId, 

                 const TDesC& aTargetId,

                 const TDesC& aDisplayName,

                 const TDesC8& aContactLink,

                 MIMCVEngineMessageReadInterface::TContainerType aType )

	{

	return *ChatL( ChatL( aServiceId, aTargetId,aDisplayName,aContactLink,aType ) );

	}

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

// CIMCVEngineChatContainer::MessageWriteInterfaceL

// ( Other items commented in header )

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

MIMCVEngineMessageWriteInterface& CIMCVEngineChatContainer::MessageWriteInterfaceL(                 

                TInt aServiceId, 

                const TDesC& aTargetId,

                const TDesC& aDisplayName,

                const TDesC8& aContactLink,

                MIMCVEngineMessageReadInterface::TContainerType aType )

	{

	return *ChatL( ChatL( aServiceId, aTargetId, aDisplayName, aContactLink , aType ) );

	}

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

// CIMCVEngineChatContainer::DeleteChatL

// ( Other items commented in header )

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

void CIMCVEngineChatContainer::DeleteChatL(  

		                            TInt aServiceId,

		                            const TDesC& aTargetId )

    {

    // Find out if chat exist or not. ChatExists() not used, 

    // because we need index.

    CIMCVEngineMessageContainer* tempChat = CreateContainerLC(                         

                        aServiceId, 

                        aTargetId,

                        KNullDesC,

                        KNullDesC8,

                        *this, 

                        MIMCVEngineMessageReadInterface::ENoneContainer );

	TInt index( FindChat( *tempChat ) );

	CleanupStack::PopAndDestroy( tempChat );

    // If index is positive  value, Chat exists and we can remove it.	

	if( index >= 0 )

	    {

        CIMCVEngineMessageContainer* target = ChatL( index, EFalse );

        // Get count of pending messages before removing chat

        TInt ignore;

        TInt pendignMsgs = MessagesPendingCount( ignore );

        RemoveChat( index );

        // Check if removed chat had unread messages

        if( pendignMsgs != MessagesPendingCount( ignore ) )

            {

            // Notify about changed unread count

            HandleChatEventL( EUnreadCountChanged );

            }

        // Observers are notified, delete target.

        delete target;

	    }    

	else if( index != KErrNotFound ) 

	    {

	    // some other error than not found occurred. Inform caller.

	    User::Leave( index );

	    }	   

    }

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

// CIMCVEngineChatContainer::CloseAllContainers

// ( Other items commented in header )

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

void CIMCVEngineChatContainer::CloseAllContainers()

    {

    IM_CV_LOGS(TXT("CIMCVEngineChatContainer::CloseAllContainers() START") );

    TInt count( iChatListObservers.Count() );

    for( TInt a( 0 ); a < count; ++a )

        {

    	IM_CV_LOGS(TXT("CIMCVEngineChatContainer::CloseAllContainers() closing container ") );    

        iChatListObservers[ a ]->HandleChatListEvent( iServiceId, EChatAllItemDeleted, NULL  );

        }   

	iChatContainer.ResetAndDestroy();

	IM_CV_LOGS(TXT("CIMCVEngineChatContainer::CloseAllContainers() End") );

	}

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

// CIMCVEngineChatContainer::ChatCount

// ( Other items commented in header )

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

TInt CIMCVEngineChatContainer::ChatCount() const

    {

    return iChatContainer.Count();

    }

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

// CIMCVEngineChatContainer::ChatAt

// ( Other items commented in header )

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

MIMCVEngineMessageReadInterface& CIMCVEngineChatContainer::ChatAt( TInt aIndex ) const

    {

    //__CHAT_ASSERT_DEBUG( aIndex >= 0 && aIndex < ChatCount() )

    return *iChatContainer[ aIndex ];    

    }

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

// CIMCVEngineChatContainer::RegisterNewMsgObserver

// ( Other items commented in header )

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

void CIMCVEngineChatContainer::RegisterNewMsgObserver( MIMCVEngineNewMsgObserver* aObserver )

    {

    iNewMsgObserver = aObserver;

    }

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

// CIMCVEngineChatContainer::UnregisterNewMsgObserver

// ( Other items commented in header )

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

void CIMCVEngineChatContainer::UnregisterNewMsgObserver()

    {

    iNewMsgObserver = NULL;

    }

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

// CIMCVEngineChatContainer::RegisterChatListObserver

// ( Other items commented in header )

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

TInt CIMCVEngineChatContainer::RegisterChatListObserver( MIMCVEngineChatListObserver* aObserver )

    {

    TInt index = iChatListObservers.Find( aObserver );

    if( index == KErrNotFound )

        {

        return iChatListObservers.Append( aObserver );

        }

    return KErrAlreadyExists;

    }

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

// CIMCVEngineChatContainer::UnregisterChatListObserver

// ( Other items commented in header )

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

TInt CIMCVEngineChatContainer::UnregisterChatListObserver( MIMCVEngineChatListObserver* aObserver )

    {

    TInt index = iChatListObservers.Find( aObserver );

    if( index >= 0 )

        {

        iChatListObservers.Remove( index );

        return KErrNone;

        }

    return index;

    }

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

// CIMCVEngineChatContainer::PendingMessagesCount

// ( Other items commented in header )

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

TInt CIMCVEngineChatContainer::MessagesPendingCount( TInt& aCountOfChats,

    MIMCVEngineMessageReadInterface::TUnreadFilter aUnreadFilter

    /*= MIMCVEngineMessageReadInterface::EUnreadAll*/ ) const

    {

    TInt count( ChatCount() );

    TInt pendingCount( 0 );

    aCountOfChats = 0;

    for( TInt a( 0 ); a < count; ++a )

        {

        TInt unreadCount = ChatAt( a ).UnreadCount( aUnreadFilter );

        if( unreadCount > 0 )

            {

            pendingCount += unreadCount;

            ++aCountOfChats;

            }        

        }

    return pendingCount;

    }

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

// CIMCVEngineChatContainer::MessageInterface

// ( Other items commented in header )

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

TBool CIMCVEngineChatContainer::FreeMemoryIfNeededL( TInt aSize )

	{

	//CHAT_DP_FUNC_ENTER( "CIMCVEngineChatContainer::FreeMemoryIfNeededL" );

    TInt halSize;

    TInt biggestBlock;

    HAL::Get( HALData::EMemoryRAMFree, halSize );	

    TInt maxHeap = Min( User::Heap().MaxLength(), halSize );	

	TInt available = maxHeap - ( User::Heap().Size() - User::Heap().Available( biggestBlock ) );

	TInt memoryNeed = KMinAvailableMemory + aSize;

    TTime oldestUnread;

    TInt unreadIndex;

    IM_CV_LOGS(TXT( "CIMCVEngineChatContainer::FreeMemoryIfNeededL, heapSize = %d"), maxHeap );

    IM_CV_LOGS(TXT( "****heapSize, available, need = %d, %d, %d"), 

                              maxHeap, available, memoryNeed );

    TBool ready = EFalse;

    TBool memLowNotified = EFalse;

    while( !ready )

        {

        TBool freeMemoryNeeded( EFalse );

        if( iExternalMemoryHandler )

            {

            freeMemoryNeeded = !iExternalMemoryHandler->FreeMemoryIfNeededL( aSize );

            }

        if( freeMemoryNeeded || memoryNeed > available )

            {

            // we have to react.

            TInt count = ChatCount();

            // Check how much memory can be made free

            TInt freeableBytes = 0;

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

                {

                TBool locked = iChatContainer[i]->IsLocked();

                if ( iChatContainer[i]->AllMessagesCount() && !locked )

                    {

                    freeableBytes += iChatContainer[i]->ContainerSizeInBytes();

                    }

                }

            if ( ( ( available + freeableBytes ) < memoryNeed )

                && !memLowNotified )

                {

                // Can't free enough memory

                return EFalse;

                }

            oldestUnread.HomeTime();

            unreadIndex = KErrNotFound;            

            for( TInt a( 0 ); a < count; ++a )

                {

                MIMCVEngineMessageReadInterface& chat = ChatAt( a );

                TBool locked = iChatContainer[ a ]->IsLocked();

                if( iChatContainer[ a ]->AllMessagesCount() && !locked )

                    {

                    MIMCVEngineMessage& message = iChatContainer[ a ]->MessageFromAll( 0 );

                    if( oldestUnread > message.TimeStamp() )

                        {

                        oldestUnread = message.TimeStamp();

                        unreadIndex = a;                        

                        }

                    }

                }

            if( unreadIndex == KErrNotFound )

                {

                return EFalse;

                }

            else

                {

                // Inform observers about memory handling

                if ( !memLowNotified )

                    {

                    HandleChatEventL( EMemoryLow );

                    memLowNotified = ETrue;

                    }                

                iChatContainer[ unreadIndex ]->DeleteMessageFromAll( 0 );

                }

	        available = maxHeap - ( User::Heap().Size() - User::Heap().Available( biggestBlock ) );

            IM_CV_LOGS(TXT( "****heapSize, available, need = %d, %d, %d"), 

                                      maxHeap, available, memoryNeed );

            }

        else

            {

            ready = ETrue;

            }                    

        }

	//CHAT_DP_FUNC_DONE( "CIMCVEngineChatContainer::FreeMemoryIfNeededL" );           

	return ETrue;

	}

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

// CIMCVEngineChatContainer::HandleChatEventL

// ( Other items commented in header )

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

void CIMCVEngineChatContainer::HandleChatEventL( TChatEventType aEvent, 

                                        MIMCVEngineMessage* aMessage )

    {

    if( iNewMsgObserver )

        {

        iNewMsgObserver->HandleChatEventL( aEvent, aMessage );

        }

    }

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

// CIMCVEngineChatContainer::ChatL

// ( Other items commented in header )

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

TInt CIMCVEngineChatContainer::ChatL(                 

                 TInt aServiceId, 

                 const TDesC& aTargetId,

                 const TDesC& aDisplayName,

                 const TDesC8& aContactLink,

                 MIMCVEngineMessageReadInterface::TContainerType aType 

                               /*= MIMCVEngineMessageReadInterface::ENoneContainer*/ )

	{

    IM_CV_LOGS(TXT("CIMCVEngineChatContainer::ChatL aName= %S"),&aDisplayName );

    IM_CV_LOGS(TXT("CIMCVEngineChatContainer::ChatL aLink= %S"),&aContactLink);  

	CIMCVEngineMessageContainer* tempChat = 

	     CreateContainerLC( aServiceId, aTargetId, aDisplayName, aContactLink, *this, aType );

	TInt index( FindChat( *tempChat ) );

	if( index == KErrNotFound )

		{

        IM_CV_LOGS(TXT("CIMCVEngineChatContainer::ChatL,Chat not found creating with aName %S"),&aDisplayName );  

        IM_CV_LOGS(TXT("CIMCVEngineChatContainer::ChatL,Chat not found creating with xspId %S"),&aTargetId );  

		TLinearOrder< CIMCVEngineMessageContainer > order( 

		                                    CIMCVEngineMessageContainer::OrderUid );

		// User::LeaveIfError returns value if value is positive.

		iLatestType = tempChat->ContainerType();

		switch( iLatestType )

		    {

		    case MIMCVEngineMessageReadInterface::EChatContainer:

		        {

                User::LeaveIfError( iChatContainer.InsertInOrder( tempChat, 

                                                                  order ) );			                                                  

		        index = FindChat( *tempChat );

    	        iChatContainer[ index ]->SetChatObserver( this );	

    	        HandleChatListEvent( EChatItemAdded, *tempChat );

                break;

		        }

		    case MIMCVEngineMessageReadInterface::ESendContainer:

		        {

                User::LeaveIfError( iSendContainer.InsertInOrder( tempChat, 

                                                                  order ) );

		        index = FindChat( *tempChat );

                break;

		        }

		    default:

		        {

		        User::Leave( KErrArgument );

		        break;

		        }

		    }		

		CleanupStack::Pop( tempChat );

		}

	else

	    {

	    // if contact link is null

	    if(!(iChatContainer[ index ]->ContactLink().Length()))

	        {

	        if(	(aContactLink.Length() > 0) && (iLatestType == MIMCVEngineMessageReadInterface::EChatContainer))

	            {		

	            iChatContainer[ index ]->SetLinkL(aContactLink);

	            }

	        }

	    CleanupStack::PopAndDestroy( tempChat );

	    }

	return User::LeaveIfError( index );

	}

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

// CIMCVEngineChatContainer::ChatL

// ( Other items commented in header )

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

CIMCVEngineMessageContainer* CIMCVEngineChatContainer::ChatL( TInt aIndex, 

                                              TBool aResetLatest /* = ETrue*/ )

    {

    MIMCVEngineMessageReadInterface::TContainerType type = iLatestType;

    if( aResetLatest )

        {

        iLatestType = MIMCVEngineMessageReadInterface::ENoneContainer;

        }

    switch( type )

        {

        case MIMCVEngineMessageReadInterface::EChatContainer:

            {

            return iChatContainer[ aIndex ];

            }

        case MIMCVEngineMessageReadInterface::ESendContainer:

            {

            return iSendContainer[ aIndex ];

            }

        default:

            {

            User::Leave( KErrArgument );

            break;

            }

        }

    // Can never get this far

    //__CHAT_ASSERT_DEBUG( EFalse );

    return NULL;

    }

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

// CIMCVEngineChatContainer::RemoveChatL

// ( Other items commented in header )

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

void CIMCVEngineChatContainer::RemoveChat( TInt aIndex, 

                                   TBool aResetLatest /* = ETrue */ )

    {

    MIMCVEngineMessageReadInterface::TContainerType type = iLatestType;

    if( aResetLatest )

        {

        iLatestType = MIMCVEngineMessageReadInterface::ENoneContainer;

        }

    switch( type )

        {

        case MIMCVEngineMessageReadInterface::EChatContainer:

            {

            HandleChatListEvent( EChatItemDeleted, *iChatContainer[aIndex] );

            iChatContainer.Remove( aIndex );            

            break;

            }

        case MIMCVEngineMessageReadInterface::ESendContainer:

            {

            iSendContainer.Remove( aIndex );

            break;

            }

        default:

            {

            break;

            }

        }    

    }

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

// CIMCVEngineChatContainer::FindChat

// ( Other items commented in header )

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

TInt CIMCVEngineChatContainer::FindChat( const CIMCVEngineMessageContainer& aChat )

	{

	TInt index( 0 );

    TLinearOrder< CIMCVEngineMessageContainer > order( CIMCVEngineMessageContainer::OrderUid );

    TInt status = iChatContainer.FindInOrder( &aChat, index, order );

    if( status == KErrNone )

        {

        iLatestType = MIMCVEngineMessageReadInterface::EChatContainer;

        return index;

        }

    iLatestType = MIMCVEngineMessageReadInterface::ESendContainer;

    status = iSendContainer.FindInOrder( &aChat, index, order );

    return ( status == KErrNone ? index : status );

	}