/*

* Copyright (c) 2007 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:  Handles deletion

*

*/

// INCLUDES

#include <Calendar.rsg>

#include <calendateutils.h>

#include <calenagendautils.h>

#include <aknnotewrappers.h>

#include <AknWaitDialog.h>

#include <calcommon.h>

#include <calentryview.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <caltime.h>

#include <centralrepository.h>

#include <eikenv.h>

#include <StringLoader.h>

#include <sysutil.h>

#include <calenglobaldata.h>

#include <calrrule.h>

#include <calsession.h>

#include <calencommands.hrh>            // Calendar commands

#include <calencontext.h>

#include <caleninstanceid.h>            // TCalenInstanceId

#include <calenactionuiutils.h>

#include <calcalendarinfo.h>

#include <calentoolbar.h>

#include <akntoolbar.h>

#include "calendarui_debug.h"           // Debug

#include "calendeleteui.h"

#include "calencontroller.h"

#include "CleanupResetAndDestroy.h"

#include "CalenInterimUtils2.h"

#include "CalendarPrivateCRKeys.h"      // For CalendarInternalCRKeys.h

#include "calenmultipledbmanager.h"

// Local constants

const TInt KEntriesToDelete = 1;

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

// CCalenDeleteUi::NewL

// Two phased constructor

// (other items were commented in a header).

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

//

CCalenDeleteUi* CCalenDeleteUi::NewL( CCalenController& aController )

    {

    TRACE_ENTRY_POINT;

    CCalenDeleteUi* self = new( ELeave ) CCalenDeleteUi( aController );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenDeleteUi::CCalenDeleteUi

// ?implementation_description

// (other items were commented in a header).

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

//

CCalenDeleteUi::CCalenDeleteUi( CCalenController& aController )

    : iEikEnv( CEikonEnv::Static() ), iController( aController )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenDeleteUi::~CCalenDeleteUi

// Destructor

// (other items were commented in a header).

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

//

CCalenDeleteUi::~CCalenDeleteUi()

    {

    TRACE_ENTRY_POINT;

    if( iWaitDialog )

        {

        delete iWaitDialog;

        iWaitDialog = NULL;

        }

    if( iGlobalData )

        {

        iGlobalData->Release();

        }

    if( iDelAllRange )

        delete iDelAllRange;

    iDeleteColIds.Reset();

    TRACE_EXIT_POINT;

    }

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

// CCalenDeleteUi::ConstructL

// Second phase of construction

// (other items were commented in a header).

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

//

void CCalenDeleteUi::ConstructL()

    {

    TRACE_ENTRY_POINT;

    iGlobalData = CCalenGlobalData::InstanceL();

    // Both the entry view and instance views are needed

    // by the deleteUi commands, there queue the construction of both

    RArray<TInt> colArray;

    iController.GetActiveCollectionidsL(colArray);

    CCalInstanceView* instanceView = iGlobalData->InstanceViewL(colArray);

    colArray.Reset();

    if( !instanceView )

        {

        iController.RegisterForNotificationsL( this, ECalenNotifyEntryInstanceViewCreated );

        }

    iController.RegisterForNotificationsL( this, ECalenNotifyCancelDelete );

    iMoreEntriesToDelete = EFalse;

    iDisplayQuery = EFalse;

    iEntriesToDelete = KEntriesToDelete;

    iDelAllRange = NULL;

    TRACE_EXIT_POINT;

    }

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

// CCalenDeleteUi::HandleECalenNotifyViewCreatedL

// Handles ECalenNotifyViewCreated.

// (other items were commented in a header).

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

//

void CCalenDeleteUi::HandleECalenNotifyViewCreatedL()

    {

    TRACE_ENTRY_POINT;

    RArray<TInt> colArray;

    iController.GetActiveCollectionidsL(colArray);

    if( iGlobalData->InstanceViewL(colArray) )

        {

        // Handle the outstanding command

        HandleCommandL( iStoredCommand );

        // Cancel the notify as the entry view is now

        // constructed.

        iController.CancelNotifications( this );

        }

    colArray.Reset();

    TRACE_EXIT_POINT;

    }

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

// CCalenDeleteUi::HandleNotification

// Handles notifications.

// (other items were commented in a header).

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

//

void CCalenDeleteUi::HandleNotification(const TCalenNotification aNotification )

    {

    TRACE_ENTRY_POINT;

    if ( aNotification == ECalenNotifyEntryInstanceViewCreated )

        {

        PIM_TRAPD_HANDLE( HandleECalenNotifyViewCreatedL() );

        }

    if( aNotification == ECalenNotifyCancelDelete)

        {

        if(iMutlipleContextIdsCount)

            {

            // get the context

            MCalenContext& context = iGlobalData->Context();

            // reset the multiple contexts

            context.ResetMultipleContextIds();

            // dismiss the waitdialog

            if(iWaitDialog)

                {

                TRAP_IGNORE(iWaitDialog->ProcessFinishedL());

                }

            }

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenDeleteUi::HandleCommandL

// Handles action ui commands

// (other items were commented in a header).

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

//

TBool CCalenDeleteUi::HandleCommandL( const TCalenCommand& aCommand )

    {

    TRACE_ENTRY_POINT;

    TBool continueCommand(EFalse);

    RArray<TInt> colArray;

    iController.GetActiveCollectionidsL(colArray);

    if( colArray.Count() && !( iGlobalData->InstanceViewL(colArray) ) )

        {

        iStoredCommand = aCommand;

        }

    else

        {

        switch( aCommand.Command() )

            {

            case ECalenDeleteCurrentEntry:

                DeleteCurrentEntryL(); // Entry & instance

                break;

            case ECalenDeleteSeries:

                DeleteThisOrAllL( CalCommon::EThisAndAll );

                break;

            case ECalenDeleteCurrentOccurrence:

                DeleteThisOrAllL( CalCommon::EThisOnly );

                break;

            case ECalenDeleteEntryWithoutQuery:

                continueCommand = DeleteEntryWithoutQueryL();

                break;

            case ECalenDeleteAllEntries:

                HandleDeleteAllEntriesL();

                break;

            case ECalenDeleteEntriesBeforeDate:

                DeleteEntriesBeforeDateL(); // EntryView & instance

                break;

            default:

                // Controller decided this class was the place to handle this

                // command but it wasn't in our list; something has gone wrong.

                //ASSERT( EFalse );

                break;

            }

        }

    colArray.Reset();

    TRACE_EXIT_POINT;

    return continueCommand;

    }

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

// CCalenDeleteUi::CalenCommandHandlerExtensionL

// Dummy implementation.

// (other items were commented in a header).

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

//

TAny* CCalenDeleteUi::CalenCommandHandlerExtensionL( TUid /*aExtensionUid*/ )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return NULL;

    }

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

// CCalenDeleteUi::DeleteThisOrAllL

// Deletes series repeating entry

// (other items were commented in a header).

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

//

void CCalenDeleteUi::DeleteThisOrAllL( CalCommon::TRecurrenceRange aRepeatType )

    {

    TRACE_ENTRY_POINT;

    TBool isDeleted( EFalse );

    RArray<TInt> colIdArray;

    colIdArray.AppendL(iGlobalData->Context().InstanceId().iColId);

    if( iGlobalData->Context().InstanceId().iEntryLocalUid )

        {

        CCalInstance* instance = 

            CalenActionUiUtils::FindPossibleInstanceL( 

                                           iGlobalData->Context().InstanceId(),

                                           *iGlobalData->InstanceViewL(colIdArray) );

            if( instance )

            {

            CleanupStack::PushL( instance );

            isDeleted = DeleteSingleInstanceL( instance, aRepeatType );

            if( isDeleted )

                {

                CleanupStack::Pop( instance );

                }

            else

                {

                CleanupStack::PopAndDestroy( instance );

                }

            }

        }

    colIdArray.Reset();

    iController.BroadcastNotification( isDeleted? ECalenNotifyEntryDeleted :

                                                               ECalenNotifyDeleteFailed );

    TRACE_EXIT_POINT;

    }

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

// CCalenDeleteUi::DeleteEntryWithoutQueryL()

// Deletes the current entry

// (other items were commented in a header).

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

//

TBool CCalenDeleteUi::DeleteEntryWithoutQueryL()

    {

    TRACE_ENTRY_POINT;

	TBool continueCommand(EFalse);

	// get the context

	MCalenContext& context = iGlobalData->Context();

	// get the multliple context ids count

	iMutlipleContextIdsCount = context.MutlipleContextIdsCount();

	ASSERT( iMutlipleContextIdsCount );

	    if(!iMoreEntriesToDelete)

		    {

		    iDisplayQuery = ShowMultipleEntriesDeleteQueryL(iMutlipleContextIdsCount);

		    }

		if(iDisplayQuery)

			{

			if(!iMoreEntriesToDelete)	

			    {

			    DisplayWaitDialogL();

			    }

			// get the multiple context instance ids

			RArray<TCalenInstanceId>& multipleContextIds = context.GetMutlipleContextIds();

			if(iMutlipleContextIdsCount <= iEntriesToDelete )

			    {

			    iMoreEntriesToDelete = EFalse; 

			    iEntriesToDelete = iMutlipleContextIdsCount;

			    }

			else

			    {

			    iMoreEntriesToDelete = ETrue;

	            // set the continue command flag if more entries are there to delete

			    continueCommand = ETrue;

			    }

			TInt index(0);

			while(index<iEntriesToDelete)

			    {

			    // get the local uid of the entry through multiple context list

			    TCalLocalUid entryLocalUid = multipleContextIds[0].iEntryLocalUid;			    

			    if(entryLocalUid)

			        {

			        DeleteEntryL(entryLocalUid, multipleContextIds[0].iColId);

			        }

			    // remove mutliple context based on the instanceid

			    context.RemoveMultipleContextId(multipleContextIds[0]);

			    index++;

			   }

			if(!iMoreEntriesToDelete)

			    {

			    MarkedEntriesDeletedL();    

			    }

			MCalenToolbar* toolbarImpl = iController.Services().ToolbarOrNull(); 

            if (toolbarImpl)

                {

                CAknToolbar& toolbar = toolbarImpl->Toolbar();

                // dim clear and clear all toolbar buttons

                toolbar.SetItemDimmed(ECalenNewMeeting, EFalse, ETrue);

                }

			}

        else

            {

            context.ResetMultipleContextIds();

            // notify delete failed

            iController.BroadcastNotification(ECalenNotifyDeleteFailed);    

            }

    TRACE_EXIT_POINT;

    return continueCommand;

    }

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

// CCalenDeleteUi::DeleteCurrentEntryL

// Deletes the current entry

// (other items were commented in a header).

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

//

void CCalenDeleteUi::DeleteCurrentEntryL()

    {

    TRACE_ENTRY_POINT;

    TBool deleted( EFalse );

    TCalenNotification notification = ECalenNotifyDeleteFailed;

    // Make sure we're focused on an entry.

    if( iGlobalData->Context().InstanceId().iEntryLocalUid )

        {

        //If todo, use the LUid.

        //Todos returns the current time if start or end time has not been saved.

        if( CCalEntry::ETodo == iGlobalData->Context().InstanceId().iType )

            {

            CCalEntry* entry = iGlobalData->EntryViewL(iGlobalData->Context().InstanceId().iColId)->FetchL(

                                    iGlobalData->Context().InstanceId().iEntryLocalUid );

            if( entry )

                {

                CleanupStack::PushL( entry );

                deleted = DeleteEntryL( iGlobalData->EntryViewL(iGlobalData->Context().InstanceId().iColId), entry );

                if( deleted )

                    {

                    CleanupStack::Pop( entry );

                    notification = ECalenNotifyEntryDeleted;

                    }

                else

                    {

                    CleanupStack::PopAndDestroy( entry );

                    }

                }

            }

        else // Not todo

            {

            RArray<TInt> colIdArray;

            colIdArray.AppendL(iGlobalData->Context().InstanceId().iColId);

            CCalInstance* instance = CalenActionUiUtils::FindPossibleInstanceL( 

                                                            iGlobalData->Context().InstanceId(),

                                                            *iGlobalData->InstanceViewL(colIdArray) );

            // if we have instance we will do delete other wise just return

            if( instance )

                {

                // Note: ownership handling of instance is dirty in this case, 

                // because DeleteSingleInstanceLtakes ownership, if it's deletes 

                // instance (property of CalInterimApi), otherwise not.

                CleanupStack::PushL( instance );

                deleted = DeleteSingleInstanceL( instance );

                if( deleted )

                    {

                    CleanupStack::Pop( instance );

                    notification = ECalenNotifyEntryDeleted;

                    }

                else

                    {

                    CleanupStack::PopAndDestroy( instance );

                    }

                }

            colIdArray.Reset();

            }

        }

    else

        {

         TBool doDelete( ETrue );

         doDelete = CalenActionUiUtils::ShowDeleteConfirmationQueryL( 

                                                                   iGlobalData->Context().InstanceId().iType == CCalEntry::ETodo ?

                                                                   CalenActionUiUtils::EDeleteToDo :

                                                                   CalenActionUiUtils::EDeleteEntry );

		if ( doDelete )

			{

			notification = ECalenNotifyEntryDeleted;	

			}

        }

    iController.BroadcastNotification( notification );

    TRACE_EXIT_POINT;

    }

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

// CCalenDeleteUi::DeleteAllEntriesL

// Deletes all entries

// (other items were commented in a header).

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

//

void CCalenDeleteUi::DeleteAllEntriesL()

    {

    TRACE_ENTRY_POINT;

    ASSERT( !iIsDeleting );

    const TInt buttonId = CalenActionUiUtils::ShowDeleteConfirmationQueryL( 

                                           CalenActionUiUtils::EDeleteAll );

    if( buttonId )

        {

        HandleDeleteMultipleEventsL( TCalTime::MinTime(), TCalTime::MaxTime(),

                                 R_QTN_CALE_CONF_ALL_NOTES_DELETED );

        }

    else

        {

        // notify delete failed

        iController.BroadcastNotification(ECalenNotifyDeleteFailed); 

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenDeleteUi::DeleteEntriesBeforeDateL

// Deletes all entries before a set date.

// (other items were commented in a header).

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

//