/*

* Copyright (c) 2006-2009 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:  

 *

*/

#include <e32svr.h>

#include "harvestereventmanager.h"

#include "harvesterlog.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "harvestereventmanagerTraces.h"

#endif

const TInt KHarvesterEventManagerTLSKey = 0x200104D9;

CHarvesterEventManager::CHarvesterEventManager()

	{

	}

void CHarvesterEventManager::ConstructL()

	{

	}

CHarvesterEventManager::~CHarvesterEventManager()

	{

	for ( TInt i = 0; i < iEventQueues.Count(); i++)

		{

		iEventQueues[i]->Close();

		}

	iEventQueues.ResetAndDestroy();

	iEventQueues.Close();

	iRegisteredObservers.ResetAndDestroy();

	iRegisteredObservers.Close();

	iEventStatuses.Close();

	}

EXPORT_C CHarvesterEventManager* CHarvesterEventManager::GetInstanceL()

	{

	WRITELOG( "CHarvesterEventManager::GetInstanceL" );

	OstTrace0( TRACE_NORMAL, CHARVESTEREVENTMANAGER_GETINSTANCEL, "CHarvesterEventManager::GetInstanceL" );	

	CHarvesterEventManagerStaticData* data = 

		static_cast<CHarvesterEventManagerStaticData*>( 

				UserSvr::DllTls( KHarvesterEventManagerTLSKey ) );

	CHarvesterEventManager* instance = NULL;

	if ( !data )

        {

        instance = new (ELeave) CHarvesterEventManager();

        CleanupStack::PushL( instance );

        instance->ConstructL();

        UserSvr::DllSetTls( KHarvesterEventManagerTLSKey,

        	new (ELeave) CHarvesterEventManagerStaticData(instance) );

        CleanupStack::Pop( instance );

        }

    else

        {

        instance = data->iHEM;

        data->iRefCount++;

        }

    return instance;

	}

EXPORT_C void CHarvesterEventManager::ReleaseInstance()

    {

    WRITELOG( "CHarvesterEventManager::ReleaseInstance" );

    OstTrace0( TRACE_NORMAL, CHARVESTEREVENTMANAGER_RELEASEINSTANCE, "CHarvesterEventManager::ReleaseInstance" );

    CHarvesterEventManagerStaticData* data =

        static_cast<CHarvesterEventManagerStaticData*>( 

        		UserSvr::DllTls( KHarvesterEventManagerTLSKey ) );

    if ( data )

        {

        data->iRefCount--;

        if ( data->iRefCount <= 0 )

            {

            // destroy the singleton and free TLS

            delete data;

            UserSvr::DllFreeTls( KHarvesterEventManagerTLSKey );

            }

        }

    }

EXPORT_C void CHarvesterEventManager::IncreaseItemCount( 

		HarvesterEventObserverType aHEObserverType, TUint aCount )

	{

	TEventStatus* eventStatus = GetEventStatus( aHEObserverType );

	WRITELOG2( "CHarvesterEventManager::IncreaseItemCount(%d) type = %d", aCount, aHEObserverType); 

#ifdef _DEBUG

	switch(aHEObserverType)

	    {

	    case EHEObserverTypePlaceholder:

	        {

	        WRITELOG( "CHarvesterEventManager::IncreaseItemCount() EHEObserverTypePlaceholder");

	        OstTrace0( TRACE_NORMAL, CHARVESTEREVENTMANAGER_INCREASEITEMCOUNT, "CHarvesterEventManager::IncreaseItemCount EHEObserverTypePlaceholder" );	        

	        break;

	        }	        

	    case EHEObserverTypeMMC:

	        {

	        WRITELOG( "CHarvesterEventManager::IncreaseItemCount() EHEObserverTypeMMC");

	        OstTrace0( TRACE_NORMAL, DUP1_CHARVESTEREVENTMANAGER_INCREASEITEMCOUNT, "CHarvesterEventManager::IncreaseItemCount EHEObserverTypeMMC" );	        

	        break;

	        }

	    case EHEObserverTypeOverall:

	        {

	        WRITELOG( "CHarvesterEventManager::IncreaseItemCount() EHEObserverTypeOverall");

	        OstTrace0( TRACE_NORMAL, DUP2_CHARVESTEREVENTMANAGER_INCREASEITEMCOUNT, "CHarvesterEventManager::IncreaseItemCount EHEObserverTypeOverall" );	        

	        break;

	        }

	    default:

	        {

	        WRITELOG( "CHarvesterEventManager::IncreaseItemCount() Unknown type!");

	        OstTrace0( TRACE_NORMAL, DUP3_CHARVESTEREVENTMANAGER_INCREASEITEMCOUNT, "CHarvesterEventManager::IncreaseItemCount Unknown type!" );

	        }

	    };

#endif

	if( eventStatus )

		{

		WRITELOG1( "CHarvesterEventManager::IncreaseItemCount() itemsleft = %d old ", eventStatus->iItemsLeft);

		OstTrace1( TRACE_NORMAL, DUP4_CHARVESTEREVENTMANAGER_INCREASEITEMCOUNT, "CHarvesterEventManager::IncreaseItemCount) itemsleft = %d old", eventStatus->iItemsLeft );

		eventStatus->iItemsLeft += aCount;

		WRITELOG1( "CHarvesterEventManager::IncreaseItemCount() itemsleft = %d ", eventStatus->iItemsLeft);

		OstTrace1( TRACE_NORMAL, DUP5_CHARVESTEREVENTMANAGER_INCREASEITEMCOUNT, "CHarvesterEventManager::IncreaseItemCount itemsleft = %d", eventStatus->iItemsLeft );

		}

	else

		{

		TEventStatus eventStatus;

		eventStatus.iCurrentState = EHEStateStarted;

		WRITELOG1( "CHarvesterEventManager::IncreaseItemCount() itemsleft = %d old", aCount);

		OstTrace1( TRACE_NORMAL, DUP6_CHARVESTEREVENTMANAGER_INCREASEITEMCOUNT, "CHarvesterEventManager::IncreaseItemCount itemsleft = %d old", aCount );

		eventStatus.iItemsLeft = aCount;

		WRITELOG1( "CHarvesterEventManager::IncreaseItemCount() itemsleft = %d ", aCount);

		OstTrace1( TRACE_NORMAL, DUP7_CHARVESTEREVENTMANAGER_INCREASEITEMCOUNT, "CHarvesterEventManager::IncreaseItemCount itemsleft = %d", aCount );

		eventStatus.iObserverType = aHEObserverType;

		iEventStatuses.Append( eventStatus );

		}

	}

EXPORT_C TBool CHarvesterEventManager::DecreaseItemCountL( 

		HarvesterEventObserverType aHEObserverType, TUint aCount )

	{

	TEventStatus* eventStatus = GetEventStatus( aHEObserverType );

	WRITELOG2( "CHarvesterEventManager::DecreaseItemCountL(%d) type = %d ", aCount, aHEObserverType);

#ifdef _DEBUG

    switch(aHEObserverType)

        {

        case EHEObserverTypePlaceholder:

            {

            WRITELOG( "CHarvesterEventManager::DecreaseItemCountL() EHEObserverTypePlaceholder");

            OstTrace0( TRACE_NORMAL, CHARVESTEREVENTMANAGER_DECREASEITEMCOUNTL, "CHarvesterEventManager::DecreaseItemCountL EHEObserverTypePlaceholder" );            

            break;

            }

        case EHEObserverTypeMMC:

            {

            WRITELOG( "CHarvesterEventManager::DecreaseItemCountL() EHEObserverTypeMMC");

            OstTrace0( TRACE_NORMAL, DUP1_CHARVESTEREVENTMANAGER_DECREASEITEMCOUNTL, "CHarvesterEventManager::DecreaseItemCountL EHEObserverTypeMMC" );            

            break;

            }

        case EHEObserverTypeOverall:

            {

            WRITELOG( "CHarvesterEventManager::DecreaseItemCountL() EHEObserverTypeOverall");

            OstTrace0( TRACE_NORMAL, DUP2_CHARVESTEREVENTMANAGER_DECREASEITEMCOUNTL, "CHarvesterEventManager::DecreaseItemCountL EHEObserverTypeOverall" );            

            break;

            }

        default:

            {

            WRITELOG( "CHarvesterEventManager::DecreaseItemCountL() Unknown type!");

            OstTrace0( TRACE_NORMAL, DUP3_CHARVESTEREVENTMANAGER_DECREASEITEMCOUNTL, "CHarvesterEventManager::DecreaseItemCountL Unknown type!" );

            }

        };

#endif

	if( eventStatus )

		{

		WRITELOG1( "CHarvesterEventManager::DecreaseItemCountL() iItemsLeft = %d old", eventStatus->iItemsLeft);

		OstTrace1( TRACE_NORMAL, DUP4_CHARVESTEREVENTMANAGER_DECREASEITEMCOUNTL, "CHarvesterEventManager::DecreaseItemCountL iItemsLeft = %d old", eventStatus->iItemsLeft );

		TUint newCount = eventStatus->iItemsLeft - aCount;

		// check for wrap

		if( newCount > eventStatus->iItemsLeft )

			{

			newCount = 0;

			}

		// event doesn't need to be sent, if count hasn't changed 

		if( newCount == eventStatus->iItemsLeft )

			{

			return EFalse;

			}

		eventStatus->iItemsLeft = newCount;

		}

	else

		{

		return EFalse;

		}

	WRITELOG1( "CHarvesterEventManager::DecreaseItemCountL() iItemsLeft = %d", eventStatus->iItemsLeft );

	OstTrace1( TRACE_NORMAL, DUP5_CHARVESTEREVENTMANAGER_DECREASEITEMCOUNTL, "CHarvesterEventManager::DecreaseItemCountL iItemsLeft = %d", eventStatus->iItemsLeft );

	// send finished event to all matching observers

	if ( eventStatus->iItemsLeft <= 0 )

		{

		eventStatus->iItemsLeft = 0;

		eventStatus->iCurrentState = EHEStateFinished;

		// EHEObserverTypeOverall state is handled directly in harvesterao during harvesting

        if( aHEObserverType != EHEObserverTypeOverall )

		    {

		    const TInt err = SendEventL( aHEObserverType, eventStatus->iCurrentState, eventStatus->iItemsLeft );

		    return err == KErrNone;

		    }

		}

	// still harvesting

	eventStatus->iCurrentState = EHEStateHarvesting;

	// send harvesting event to all matching observers

	TBool wasSent = EFalse;

	TInt count = iRegisteredObservers.Count();

	for ( TInt i = count; --i >= 0; )

		{

		THarvesterEventObserverInfo& observer = *(iRegisteredObservers[i]);

		if( CheckObserverType( observer.iObserverType, aHEObserverType ) )

			{

			observer.iDelta += aCount;

			// observers interval full

			if ( observer.iDelta >= observer.iNotificationInterval )

				{

				TInt err = SendSingleEvent( observer, aHEObserverType, 

						eventStatus->iCurrentState, eventStatus->iItemsLeft );

				if ( err == KErrNone )

					{

					wasSent = ETrue;

					}

				}

			}

		}

	return wasSent;

	}

TInt CHarvesterEventManager::SendSingleEvent( 

		THarvesterEventObserverInfo& aEventObserverInfo, 

		HarvesterEventObserverType aObserverType, 

		HarvesterEventState aEventState, TUint aItemsLeft )

	{

	aEventObserverInfo.iDelta = 0;

	THarvesterEventNotification notification;

	notification.iObserverId = aEventObserverInfo.iObserverId;

	notification.iObserverType = aObserverType;

	notification.iCurrentState = aEventState;

	notification.iItemsLeft = aItemsLeft;

	THarvesterEventQueue& eventQueue = *(aEventObserverInfo.iQueuePtr);

	TInt err = eventQueue.Send( notification );

	return err;

	}

EXPORT_C TUint CHarvesterEventManager::ItemCount( 

		HarvesterEventObserverType aHEObserverType )

	{

	TEventStatus* eventStatus = GetEventStatus( aHEObserverType );

	if( eventStatus )

		{

		return eventStatus->iItemsLeft;

		}

	return 0;

	}

EXPORT_C TInt CHarvesterEventManager::SendEventL( 

		HarvesterEventObserverType aHEObserverType,

		HarvesterEventState aHEState, TUint aItemsLeft )

	{

	TEventStatus* eventStatus = GetEventStatus( aHEObserverType );

	if( eventStatus )

		{

		eventStatus->iCurrentState = aHEState;

		}

	THarvesterEventNotification notification;

	notification.iObserverType = aHEObserverType;

	notification.iCurrentState = aHEState;

	notification.iItemsLeft = aItemsLeft;

	TInt err = KErrNone;

	TInt count = iRegisteredObservers.Count();

	for ( TInt i = count; --i >= 0; )

		{

		THarvesterEventObserverInfo& observer = *(iRegisteredObservers[i]);

		if( CheckObserverType( observer.iObserverType, aHEObserverType ) )

			{

			notification.iObserverId = observer.iObserverId;

			THarvesterEventQueue& eventQueue = *(observer.iQueuePtr);

			TInt sendErr = eventQueue.Send( notification );

			// Take first error

			if( err == KErrNone )

				{

				err = sendErr;

				}

			}

		}

	return err;

	}

EXPORT_C void CHarvesterEventManager::RegisterEventObserverL( const RMessage2& aMessage )

	{

	THarvesterEventObserverInfo* observerInfo = new (ELeave) THarvesterEventObserverInfo;

	CleanupStack::PushL( observerInfo );

    TPckg<THarvesterEventObserverInfo> pckgObserverInfo( *observerInfo );

    TInt err = aMessage.Read( 0, pckgObserverInfo );

    // Init server side values

    observerInfo->iQueuePtr = NULL;

    observerInfo->iDelta = 0;

    observerInfo->iProcessUid = aMessage.Identity().iUid;

    // Check if observer ID is not yet used

    // and if event queue already exists

    TBool found = EFalse;

	for(TInt i = iRegisteredObservers.Count(); --i >= 0;)

		{

		THarvesterEventObserverInfo* info = iRegisteredObservers[i];

		if( info->iProcessUid == observerInfo->iProcessUid && 

			info->iQueueHandle == observerInfo->iQueueHandle )

			{

			if( info->iObserverId == observerInfo->iObserverId )

				{

				User::Leave( KErrAlreadyExists );

				}

			observerInfo->iQueuePtr = info->iQueuePtr;

			found = ETrue;

			}

		}

	// create new event queue if no match was found 

	if ( !found )

		{

		THarvesterEventQueue* msgQueue = new (ELeave) THarvesterEventQueue;

		CleanupStack::PushL( msgQueue );

		User::LeaveIfError( msgQueue->Open( aMessage, 1 ) );

		User::LeaveIfError( iEventQueues.InsertInOrderAllowRepeats(msgQueue, 

		                                 TLinearOrder<THarvesterEventQueue>(CHarvesterEventManager::CompareProperties))); 

		observerInfo->iQueuePtr = msgQueue;

		CleanupStack::Pop( msgQueue );

		}	

	iRegisteredObservers.AppendL( observerInfo );

	// send event if register is coming in the middle of harvesting

	for( TInt i = iEventStatuses.Count(); --i >= 0; )

		{

		TEventStatus& eventStatus = iEventStatuses[i];

		if( CheckObserverType( observerInfo->iObserverType, 

				eventStatus.iObserverType) )

			{

			TRAP_IGNORE( SendEventL( eventStatus.iObserverType, 

					eventStatus.iCurrentState, eventStatus.iItemsLeft ) );

			}

		}

	//no events in queue, signal registered client anyways 

	if( !iEventStatuses.Count() )

	    {

        if(observerInfo->iObserverType & EHEObserverTypeOverall)

            {

            SendSingleEvent(*observerInfo, EHEObserverTypeOverall, EHEStateUninitialized, 0);

            }

        if(observerInfo->iObserverType & EHEObserverTypeMMC)

            {

            SendSingleEvent(*observerInfo, EHEObserverTypeMMC, EHEStateUninitialized, 0);

            }

        if(observerInfo->iObserverType & EHEObserverTypePlaceholder)

            {

            SendSingleEvent(*observerInfo, EHEObserverTypePlaceholder, EHEStateUninitialized, 0);

            }

	    }

	CleanupStack::Pop( observerInfo );

	}

EXPORT_C TInt CHarvesterEventManager::UnregisterEventObserver( const RMessage2& aMessage )

	{

	TUint observerId = (TUint)aMessage.Int0();

	TInt queueHandle = aMessage.Int1();

	TInt serverQueueHandle = KNullHandle;

	TUint processUid = aMessage.Identity().iUid;

	TBool otherObserverFound = EFalse;

	for(TInt i = iRegisteredObservers.Count(); --i >= 0;)

		{

		THarvesterEventObserverInfo* observer = iRegisteredObservers[i];

		if( observer->iProcessUid == processUid && 

			observer->iQueueHandle == queueHandle )

			{

			// Remove registered observer

			if( observer->iObserverId == observerId )

				{

				serverQueueHandle = observer->iQueuePtr->Handle();

				iRegisteredObservers.Remove( i );

				delete observer;

				}

			// Find if any other observer is using the same queue

			else

				{

				otherObserverFound = ETrue;

				}

			}

		}

	if( serverQueueHandle )

		{

		// Remove the queue if removed observer 

		// was the last observer which used it

		if( !otherObserverFound )

			{

	        TInt low( 0 );

	        TInt high( iEventQueues.Count() );

	        while( low < high )

	            {

	            TInt mid( (low+high)>>1 );

	            const TInt compare( serverQueueHandle - iEventQueues[mid]->Handle() );

	            if( compare == 0 )

	                {

	                THarvesterEventQueue* queue = iEventQueues[mid];

                    iEventQueues.Remove( mid );

                    queue->Close();

                    delete queue;

                    break;

	                }

	            else if( compare > 0 )

	                {

	                low = mid + 1;

	                }

	            else

	                {

	                high = mid;

	                }

	            }

			iEventQueues.Compress();

			}

		iRegisteredObservers.Compress();

		return KErrNone;

		}

	else

		{

		return KErrNotFound;

		}

	}

EXPORT_C HarvesterEventState CHarvesterEventManager::CurrentState( 

		HarvesterEventObserverType aHEObserverType )

	{

	TInt count = iEventStatuses.Count();

	for( TInt i = count; --i >= 0; )

		{

		TEventStatus& eventStatus = iEventStatuses[i];

		if( eventStatus.iObserverType == aHEObserverType )

			{

			return eventStatus.iCurrentState;

			}

		}

	return EHEStateUninitialized;

	}

TBool CHarvesterEventManager::CheckObserverType( TInt aObserverType, TInt aEventType )

	{

	return aObserverType & aEventType;

	}