/*

* 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:  Engine class for Events Management UI.

*

*/

#include <lbt.h> 

#include "evtevent.h"

#include "evtmgmtuilbtadapter.h"

#include "evteventmanager.h"

#include "evtmgmtuiengine.h"

#include "evtdebug.h"

#include "evttoneaction.h"

// Constants

static const TInt KHighAccValue = 500;

static const TInt KMidAccValue = 1500;

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

// CEvtMgmtUiModel::ConstructL()

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

//

void CEvtMgmtUiEngine::ConstructL()

    {

    EVTUIDEBUG("+ CEvtMgmtUiEngine::ConstructL()" );

    iEventManager = CEvtEventManager::NewL();

    iEventManager->SetObserver(this);

    EVTUIDEBUG("Create lbtadapter object" );      

    iLbtAdapter = CEvtMgmtUiLbtAdapter::NewL(*this);

    EVTUIDEBUG("- CEvtMgmtUiEngine::ConstructL()" );

    }

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

// CEvtMgmtUiEngine::NewL()

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

//

EXPORT_C CEvtMgmtUiEngine* CEvtMgmtUiEngine::NewL()

    {

    CEvtMgmtUiEngine* self = CEvtMgmtUiEngine::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CEvtMgmtUiEngine::NewLC()

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

//

EXPORT_C CEvtMgmtUiEngine* CEvtMgmtUiEngine::NewLC()

    {

    CEvtMgmtUiEngine* self = new( ELeave ) CEvtMgmtUiEngine();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CEvtMgmtUiEngine::CEvtMgmtUiEngine()

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

//

CEvtMgmtUiEngine::CEvtMgmtUiEngine()

    {       

    }

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

// CEvtMgmtUiEngine::~CEvtMgmtUiEngine()

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

//

CEvtMgmtUiEngine::~CEvtMgmtUiEngine()

    {        

    // Reseting the Observer array

    iObserverArray.Reset();

    iObserverArray.Close();

    delete iEventManager;   

    iEventManager = NULL;

    delete iLbtAdapter;

    iLbtAdapter = NULL;

    }

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

// CEvtMgmtUiEngine::SetObserver()

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

//

EXPORT_C void CEvtMgmtUiEngine::SetObserver(MEvtMgmtUiEngineObserver* aObserver)

    {

    // Append the observer to the observer array waiting for notifications

    iObserverArray.Append( aObserver );

    }

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

// CEvtMgmtUiEngine::RemoveObserver()

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

//

EXPORT_C void CEvtMgmtUiEngine::RemoveObserver(MEvtMgmtUiEngineObserver* aObserver)

    {

    // Remove the observer from receiving notifications

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

        {

        if ( iObserverArray[i] == aObserver )

            {

            iObserverArray.Remove( i );

            break;   

            }

        }

    }

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

// CEvtMgmtUiEngine::EventL()

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

//

EXPORT_C CEvtEvent* CEvtMgmtUiEngine::EventL( TEvtEventId aId )

    {        

    EVTUIDEBUG1("+ CEvtMgmtUiEngine::EventL() event id = %d", aId);

    CEvtEvent* evt = NULL;

    if( aId!= 0 )

	    {

	    evt = iEventManager->GetEventL( aId ); 

	    CleanupStack::PushL( evt );

	    RetrieveLocationL( aId, evt->Location() );

	    CleanupStack::Pop();

	    }

    else

	    {

	    evt = CEvtEvent::NewL();	

	    }

    EVTUIDEBUG("- CEvtMgmtUiEngine::EventL()" );

    return evt;

    }

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

// CEvtMgmtUiEngine::AddEventL()

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

//

EXPORT_C void CEvtMgmtUiEngine::AddEventL( CEvtEvent& aEvtEvent )

    {  

    EVTUIDEBUG("+ CEvtMgmtUiEngine::AddEventL()" );

    CLbtTriggerEntry::TLbtTriggerState state;

    if(aEvtEvent.EventStatus()==EActive)

        {

        state = CLbtTriggerEntry::EStateEnabled;

        }

    else

        {

        state = CLbtTriggerEntry::EStateDisabled;

        }

    iEvent = &aEvtEvent;

    //create trigger

    if(iEvent->Subject().Compare(KNullDesC) == 0)

       iLbtAdapter->CreateTrigger(iEvent->Location(),TReal(iEvent->Radius()),_L("Un Named Location Event"), state );

    else

       iLbtAdapter->CreateTrigger(iEvent->Location(),TReal(iEvent->Radius()),iEvent->Subject(), state );

    EVTUIDEBUG("- CEvtMgmtUiEngine::AddEventL()" );  

    }

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

// CEvtMgmtUiEngine::ModifyEventL()

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

//

EXPORT_C void CEvtMgmtUiEngine::ModifyEventL( CEvtEvent& aEvtEvent, TEvtEventAttributeMask aEventAttributeMask )

    {  

    EVTUIDEBUG("+ CEvtMgmtUiEngine::ModifyEventL()" );

    //if loc and/or state information are changed

    if( (aEventAttributeMask & EEvtEventAttributeStatus) == EEvtEventAttributeStatus ||

       (aEventAttributeMask & EEvtEventAttributePlace) == EEvtEventAttributePlace ||

       (aEventAttributeMask & EEvtEventAttributeRadius) == EEvtEventAttributeRadius )

        {

        CLbtTriggerEntry::TLbtTriggerState state;

        if( aEvtEvent.EventStatus() == EActive )

          {

          state = CLbtTriggerEntry::EStateEnabled;

          }

        else

          {

          state = CLbtTriggerEntry::EStateDisabled;

          }

        iEvent = &aEvtEvent;

        iLbtAdapter->UpdateTriggerL(aEvtEvent.EventId(), aEvtEvent.Location(), 

                                aEvtEvent.Radius(), state );

        } 

    else

        {

        iEventManager->UpdateEventL(aEvtEvent);

        if ( iObserverArray.Count())

            {

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

                {

                iObserverArray[i]->NotifyEventChangeL( KErrNone,CEvtMgmtUiLbtAdapter::ELbtAdapterUpdate );

                }

            }

        }

    EVTUIDEBUG("- CEvtMgmtUiEngine::ModifyEventL()" );  

    }

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

// CEvtMgmtUiEngine::DeleteEventL()

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

//

EXPORT_C void CEvtMgmtUiEngine::DeleteEventL( TEvtEventId aEventId )

    {   

    EVTUIDEBUG1("+ CEvtMgmtUiEngine::DeleteEventL() event id =%d", aEventId );   

    TInt err = KErrNone;

    if( aEventId!=0 ) //if it is present in lbt database        

        {      

        iLbtAdapter->DeleteTriggerL( aEventId );

        iEventManager->RemoveEventL( aEventId );

        }

    if ( iObserverArray.Count())

        {

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

            {

            iObserverArray[i]->NotifyEventChangeL( err,CEvtMgmtUiLbtAdapter::ELbtAdapterDelete );

            }

        }

    EVTUIDEBUG("- CEvtMgmtUiEngine::DeleteEventL()" );  

    }

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

// CEvtMgmtUiEngine::DeleteEventsL()

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

//

EXPORT_C void CEvtMgmtUiEngine::DeleteEventsL( const RArray<TEvtEventId>* aEvtIdArray )

    {    

    iEvtIdArray = aEvtIdArray;

    iLbtAdapter->DeleteTriggersL( *aEvtIdArray );  

    }

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

// CEvtMgmtUiEngine::SetEventStateL()

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

//

EXPORT_C void CEvtMgmtUiEngine::SetEventStateL( TEvtEventStatus aEvtStatus, TEvtEventId aEventId)

    {

    EVTUIDEBUG("+ CEvtMgmtUiEngine::SetEventStateL()" );  

    TInt err = KErrNone;

    if( aEventId != 0 )

    	{ 

	    switch(aEvtStatus)

	        {

	        case EActive:

	            {            

	            iLbtAdapter->SetTriggerStateL( aEventId, CLbtTriggerEntry::EStateEnabled);

                iEventManager->UpdateEventStatusL( aEventId, aEvtStatus );

	            break;

	            }

	        case EDraft:

	            { 

	            iLbtAdapter->SetTriggerStateL( aEventId, CLbtTriggerEntry::EStateDisabled );

                iEventManager->UpdateEventStatusL( aEventId, aEvtStatus ); 

	            break;

	            }  

	        case ECompleted:

	            { 

                iEventManager->UpdateEventStatusL( aEventId, aEvtStatus ); 

	            iLbtAdapter->SetTriggerStateL( aEventId, CLbtTriggerEntry::EStateDisabled );

	            break;

	            }  

	        default:

	        	break;                  

	        } 

        }   

    if ( iObserverArray.Count())

        {

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

            {

            iObserverArray[i]->NotifyEventChangeL( err,CEvtMgmtUiLbtAdapter::ELbtAdapterSetTriggerState );

            }

        }

	EVTUIDEBUG("- CEvtMgmtUiEngine::SetEventStateL()" ); 

    }

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

// CEvtMgmtUiEngine::SetEventsStateL()

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

//

EXPORT_C void CEvtMgmtUiEngine::SetEventsStateL( TEvtEventStatus aEvtStatus, const RArray<TEvtEventId>* aEvtIdArray )

    {

    EVTUIDEBUG("+ CEvtMgmtUiEngine::SetEventsStateL()" );

    iEvtIdArray = aEvtIdArray;

    iEvtStatus = aEvtStatus;

    switch(aEvtStatus)

        {

        case EActive:

            {            

            iLbtAdapter->SetTriggersStateL( *aEvtIdArray, CLbtTriggerEntry::EStateEnabled);

            break;

            }

        case EDraft:

        case ECompleted:

            {  

            iLbtAdapter->SetTriggersStateL( *aEvtIdArray, CLbtTriggerEntry::EStateDisabled);

            break;

            }  

        default:

            break;                  

        }                

    EVTUIDEBUG("- CEvtMgmtUiEngine::SetEventsStateL()" );

    }

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

// CEvtMgmtUiEngine::UpdateModelL()

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

//

EXPORT_C void CEvtMgmtUiEngine::UpdateModelL( RPointerArray<CEvtBasicEventInfo>& aEventsArray,

												TEvtEventStatusFilter  aEventStatusFilter )

    {

    EVTUIDEBUG("+ CEvtMgmtUiEngine::UpdateModelL()" );

    if( aEventsArray.Count() )

         {

         aEventsArray.ResetAndDestroy();         

         } 

    if( aEventStatusFilter == EEvtFilterAll )

        iEventManager->GetEventsL( aEventsArray );

    else

        iEventManager->GetEventsL( static_cast<TEvtEventStatus>(aEventStatusFilter), aEventsArray );

    EVTUIDEBUG("- CEvtMgmtUiEngine::UpdateModelL()" );  

    }

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

// CEvtMgmtUiEngine::SyncDbsL()

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

//

EXPORT_C void CEvtMgmtUiEngine::SyncDbsL()

    {

    EVTUIDEBUG("+ CEvtMgmtUiEngine::SyncDbsL()" );

	TInt err;

    // Handle the Enabled and Disabled Trigger list from LBT 

    RArray<TLbtTriggerId> enabledtriggerList;

    RArray<TLbtTriggerId> disabledtriggerList;

	TRAP(err, iLbtAdapter->GetTriggerListL(disabledtriggerList, CLbtTriggerEntry::EStateDisabled ) );

	if(err != KErrNone)

		{

		EVTUIDEBUG1("CEvtMgmtUiEngine::SyncDbsL:Error while retrieving trigger ids = %d", err);

		disabledtriggerList.Close();

		enabledtriggerList.Close();

		User::Leave( err );

		}

	TRAP(err, iLbtAdapter->GetTriggerListL(enabledtriggerList, CLbtTriggerEntry::EStateEnabled ) );

	if(err != KErrNone)

		{

		EVTUIDEBUG1("CEvtMgmtUiEngine::SyncDbsL:Error while retrieving trigger ids = %d", err);

		disabledtriggerList.Close();

		enabledtriggerList.Close();

		User::Leave( err );

		}

	// Get Events list from EvtStorage

	RPointerArray<CEvtBasicEventInfo> eventsArray;

	RArray<TEvtEventId> removeArray;

	iEventManager->GetEventsL( eventsArray );

	// Compute

	TInt count = eventsArray.Count();

	TInt index=KErrNotFound;

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

	{

    if( eventsArray[i]->EventStatus() == EActive )

		{

        if( KErrNotFound != (index = disabledtriggerList.Find(eventsArray[i]->EventId())) )

            {

			iEventManager->UpdateEventStatusL( eventsArray[i]->EventId(), EDraft );

			disabledtriggerList.Remove(index);

            }

		else if( KErrNotFound == (index = enabledtriggerList.Find(eventsArray[i]->EventId())) )

		    {

			removeArray.Append(eventsArray[i]->EventId());

		    }

		else

		    {

		    enabledtriggerList.Remove(index);

		    }

		}

	else

		{

        if( KErrNotFound != (index = enabledtriggerList.Find(eventsArray[i]->EventId())) )

            {

			iEventManager->UpdateEventStatusL( eventsArray[i]->EventId(), EActive );

			enabledtriggerList.Remove(index);

            }

		else if( KErrNotFound == (index = disabledtriggerList.Find(eventsArray[i]->EventId())) )

		    {

			removeArray.Append(eventsArray[i]->EventId());

		    }

        else

            {

            disabledtriggerList.Remove(index);

            }

		}

	}

	// Update the Storage Db for removed triggers.

	if( removeArray.Count() != 0 )

		iEventManager->RemoveEventsL( removeArray );

	// Update the LBT Db for non existant triggers.

	count = enabledtriggerList.Count();

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

	    disabledtriggerList.Append(enabledtriggerList[i]);

	// We Nullify iEvtIdArray to ensure that observers are not notified of this delete triggers

	iEvtIdArray = NULL;

	if( disabledtriggerList.Count() != 0 )

    	iLbtAdapter->DeleteTriggersL( disabledtriggerList );  

	removeArray.Close();

	disabledtriggerList.Close();

	enabledtriggerList.Close();

	eventsArray.ResetAndDestroy();

	eventsArray.Close();

	EVTUIDEBUG("- CEvtMgmtUiEngine::SyncDbsL()" );

    }

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

// CEvtMgmtUiEngine::CalculateFiredAccuracyL()

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

//

EXPORT_C TEvtFireAccuracy CEvtMgmtUiEngine::CalculateFiredAccuracyL( 

											const TEvtEventId aEventId )

	{

	EVTUIDEBUG1("+ CEvtMgmtUiEngine::CalculateFiredAccuracyL() - %d", aEventId );

	TEvtFireAccuracy accuracy = ELowAccuracy;

	TReal32 distance(KMidAccValue+1);

	iLbtAdapter->GetFiredTriggerAccuracyL(aEventId, distance);

	EVTUIDEBUG1("= CalculateFiredAccuracyL() distance = %d", distance );

	if( distance <= KHighAccValue )

		accuracy = EHighAccuracy;

	else if( distance <= KMidAccValue )

		accuracy = EMidAccuracy;

	else

		accuracy = ELowAccuracy;

	EVTUIDEBUG("- CEvtMgmtUiEngine::CalculateFiredAccuracyL()" );

	return accuracy;

	}

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

// CEvtMgmtUiEngine::HandleFiredTriggerStateL()

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

//

EXPORT_C void CEvtMgmtUiEngine::HandleFiredTriggerStateL( 

											const TEvtEventId aEventId )

	{	

	EVTUIDEBUG1("+ CEvtMgmtUiEngine::HandleFiredTriggerStateL() - %d", aEventId );    

    CEvtEvent* evt = NULL;

    if( aEventId!= 0 )

	    {

	    evt = iEventManager->GetEventL( aEventId ); 

	    if( evt )

		    {

		    CleanupStack::PushL( evt );	

			if( !evt->Repeat() )

				{

				SetEventStateL( ECompleted, aEventId );

				}

		    CleanupStack::PopAndDestroy( evt );

		    }	

	    }

	EVTUIDEBUG("- CEvtMgmtUiEngine::HandleFiredTriggerStateL()" );

	}

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

// CEvtMgmtUiEngine::CancelRequest()

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

//

EXPORT_C void CEvtMgmtUiEngine::CancelRequest()

    {     

    EVTUIDEBUG("+ CEvtMgmtUiEngine::CancelRequest()" );

	if( iLbtAdapter->IsActive() )

    	iLbtAdapter->CancelRequest();

    EVTUIDEBUG("- CEvtMgmtUiEngine::CancelRequest()" );

    }

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

// CEvtMgmtUiEngine::HandleStorageDbChangedL()

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

//

void CEvtMgmtUiEngine::HandleStorageDbChangedL()

    {     

    // Notify all observers

    if ( iObserverArray.Count())

        {

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

            {

            iObserverArray[i]->NotifyModelChangeL();

            }

        }

    }

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

// CEvtMgmtUiEngine::RetrieveLocationL()

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