/*

* Copyright (c) 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:  Handler for Snoozing of Event

*

*/

// INCLUDE FILES

#include <centralrepository.h>

#include "evthandlerserverconsts.h"

#include "evtdebug.h"

#include "evtsnoozehandler.h"

#include "evtstoragedomaincrkeys.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CEvtSnoozeHandler::NewL

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

CEvtSnoozeHandler* CEvtSnoozeHandler::NewL(

        	MEvtSnoozeObserver& aSnoozeObserver )

    {

    CEvtSnoozeHandler* self = new ( ELeave ) CEvtSnoozeHandler( aSnoozeObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CEvtSnoozeHandler::CEvtSnoozeHandler

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

CEvtSnoozeHandler::CEvtSnoozeHandler( 

	MEvtSnoozeObserver& aSnoozeObserver )

    : CTimer( EPriorityStandard ), iSnoozeObserver( aSnoozeObserver ), 

		iSnoozeQueue( KEvtItemArrayGranularity ), 

		iSnoozeCompleteQueue( KEvtItemArrayGranularity )

    {

    }

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

// CEvtSnoozeHandler::~CEvtSnoozeHandler

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

CEvtSnoozeHandler::~CEvtSnoozeHandler()

    {

	if( iIntervalNotifyHandler )

		{

		iIntervalNotifyHandler->StopListening();

		}

	if( iPeriodNotifyHandler )

		{

		iPeriodNotifyHandler->StopListening();

		}

    delete iIntervalNotifyHandler;

	delete iPeriodNotifyHandler;

	delete iSettingSession;

	iSnoozeQueue.Reset();

    iSnoozeQueue.Close();

	iSnoozeCompleteQueue.Reset();

    iSnoozeCompleteQueue.Close();

    }

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

// CEvtSnoozeHandler::ConstructL

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

void CEvtSnoozeHandler::ConstructL()

    {

    EVTUIDEBUG("+ CEvtSnoozeHandler::ConstructL");    

    CTimer::ConstructL();

    CActiveScheduler::Add( this );

	// Create the Session to EventsUi Settings

	iSettingSession = CRepository::NewL( TUid::Uid( KCRUidEvtStorageDb ) );

	// Create the Cenrep Key observer for Interval and Period.

    iIntervalNotifyHandler = CCenRepNotifyHandler::NewL(*this,

                                                     *iSettingSession,

                                                     CCenRepNotifyHandler::EIntKey,

                                                     KEvtSnoozeInterval);

	iPeriodNotifyHandler = CCenRepNotifyHandler::NewL(*this,

                                                     *iSettingSession,

                                                     CCenRepNotifyHandler::EIntKey,

                                                     KEvtSnoozePeriod);

	// Get the Initial values from settings.

    TInt period;

	User::LeaveIfError( iSettingSession->Get( KEvtSnoozeInterval, iSnoozeInterval ) );

    User::LeaveIfError( iSettingSession->Get( KEvtSnoozePeriod, period ) );

	// Start Listening.

    iIntervalNotifyHandler->StartListeningL();

    iPeriodNotifyHandler->StartListeningL();

    iSnoozeCount = 1;

    if( period && iSnoozeInterval/period )

        iSnoozeCount = iSnoozeInterval/period;

    EVTUIDEBUG( "- CEvtSnoozeHandler::ConstructL" );

    }

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

// CEvtSnoozeHandler::RemoveIfPresent

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

void CEvtSnoozeHandler::RemoveIfPresent(const TEvtSnoozeItem& aSnoozeItem)

	{    

    EVTUIDEBUG( "+ CEvtSnoozeHandler::RemoveIfPresent" );	

    // Remove if already present

    TIdentityRelation<TEvtSnoozeItem> matcher(TEvtSnoozeItem::Match);

    TInt index = iSnoozeCompleteQueue.Find(aSnoozeItem,matcher);

    if( index != KErrNotFound )

        { 

        iSnoozeCompleteQueue.Remove( index );

        }

    else

        {

        index = iSnoozeQueue.Find(aSnoozeItem,matcher);

        if( index != KErrNotFound )

            { 

            iSnoozeQueue.Remove( index );

            // Cancel the timer if it is already snoozing for

            // requested event id

            if( index == 0 )

                {

                Cancel();

                // Start the Timer for next Item

                if( !IsActive() && iSnoozeQueue.Count() )

                    At( iSnoozeQueue[ 0 ].iTime );

                }

            }

        }

    EVTUIDEBUG( "- CEvtSnoozeHandler::RemoveIfPresent" );

	}

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

// CEvtSnoozeHandler::IsSnoozeQueEmpty

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

TBool CEvtSnoozeHandler::IsSnoozeQueEmpty()

	{    

    EVTUIDEBUG( "+ CEvtSnoozeHandler::IsSnoozeQueEmpty" );	

    if( IsActive() || iSnoozeCompleteQueue.Count() || iSnoozeCompleteQueue.Count() )

        { 

        return EFalse;

        }

    return ETrue;

	}

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

// CEvtSnoozeHandler::Snooze

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

void CEvtSnoozeHandler::Snooze(TEvtSnoozeItem aSnoozeItem)

	{    

    EVTUIDEBUG( "+ CEvtSnoozeHandler::Snooze" );	

    TTimeIntervalMinutes interval(iSnoozeInterval); 

    aSnoozeItem.iTime.HomeTime();

    // Add the Snooze Time

    aSnoozeItem.iTime = aSnoozeItem.iTime + interval;

    TIdentityRelation<TEvtSnoozeItem> matcher(TEvtSnoozeItem::Match);

    TInt index = iSnoozeCompleteQueue.Find(aSnoozeItem,matcher);

    if( index != KErrNotFound )

        { 

        // Increment Snooze count

        aSnoozeItem.iCount = iSnoozeCompleteQueue[index].iCount + 1;

        // Remove the already present item

        iSnoozeCompleteQueue.Remove( index );

        }

    else

        {

        index = iSnoozeQueue.Find(aSnoozeItem,matcher);

        if( index != KErrNotFound )

            { 

            // Cancel the timer if it is already snoozing for

            // requested event id

            if( index == 0 )

                {

                Cancel();

                }

            // Increment Snooze count

            aSnoozeItem.iCount = iSnoozeQueue[index].iCount + 1;

            // Remove the already present item

            iSnoozeQueue.Remove( index );

            }

        else

            {

            // First Snooze

            aSnoozeItem.iCount = 1;

            }

        }

    // Append this element to the queue

    iSnoozeQueue.Append( aSnoozeItem );

    // Start the Timer if it is not already started

    if(!IsActive())

        At( iSnoozeQueue[ 0 ].iTime );

    EVTUIDEBUG( "- CEvtSnoozeHandler::Snooze" );

	}

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

// CEvtSnoozeHandler::RunL

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

void CEvtSnoozeHandler::RunL()

    {

    EVTUIDEBUG1( "+ CEvtSnoozeHandler::RunL %d", iStatus.Int() );

    if( iSnoozeQueue.Count() > 1 )

        At( iSnoozeQueue[ 1 ].iTime );

    if( iSnoozeQueue[ 0 ].iCount < iSnoozeCount )

        {

        // Notify on Snooze complete

        iSnoozeObserver.SnoozeCompleteL( iSnoozeQueue[ 0 ], ETrue ); 

        // Move the snooze item to complete

        iSnoozeCompleteQueue.Append( iSnoozeQueue[ 0 ] );

        iSnoozeQueue.Remove(0);

        }

    else

        {

        // Notify on Snooze complete

        iSnoozeObserver.SnoozeCompleteL( iSnoozeQueue[ 0 ], EFalse); 

        // Remove Snoozed Item

        iSnoozeQueue.Remove(0);

        }

    EVTUIDEBUG( "- CEvtSnoozeHandler::RunL" );

    }

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

// CEvtSnoozeHandler::HandleNotifyInt()

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

//

void CEvtSnoozeHandler::HandleNotifyInt(TUint32 aId, TInt aNewValue)

    {

   	if ( aId == KEvtSnoozeInterval )

   		{

   		iSnoozeInterval = aNewValue;

   		}

   	else if ( aId == KEvtSnoozePeriod )

		{

        if( aNewValue && iSnoozeInterval/aNewValue )

            iSnoozeCount = iSnoozeInterval/aNewValue;

   		}

    }

//  End of File