/*

* 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:  Handles deletion

*

*/

// System includes

#include <QString>

#include <QtGui>

#include <hbdatetimepicker.h>

#include <hbdialog.h>

#include <hbmessagebox.h>

#include <hbaction.h>

#include <hblabel.h>

#include <hbradiobuttonlist.h>

#include <centralrepository.h>

#include <agendaentry.h>

// User includes

#include "calendarui_debug.h"

#include "calendeleteui.h"

#include "calencontext.h"

#include "calencontroller.h"

#include "CleanupResetAndDestroy.h"

#include "caleninstanceid.h"

#include "calenactionuiutils.h"

#include "calendateutils.h"

#include "calenagendautils.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "calendeleteuiTraces.h"

#endif

// Local constants

const TInt KEntriesToDelete = 1;

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

// CalenDeleteUi::NewL

// Two phased constructor

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

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

//

CalenDeleteUi* CalenDeleteUi::NewL( CCalenController& aController )

    {

    OstTraceFunctionEntry0( CALENDELETEUI_NEWL_ENTRY );

    CalenDeleteUi* self = new( ELeave ) CalenDeleteUi( aController, NULL );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CALENDELETEUI_NEWL_EXIT );

    return self;

    }

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

// CalenDeleteUi::CalenDeleteUi

// ?implementation_description

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

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

//

CalenDeleteUi::CalenDeleteUi( CCalenController& aController, QObject *parent )

    :QObject(parent), iController( aController )

    {

    OstTraceFunctionEntry0( CALENDELETEUI_CALENDELETEUI_ENTRY );

    iIsDeleting = false;

    OstTraceFunctionExit0( CALENDELETEUI_CALENDELETEUI_EXIT );

    }

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

// CalenDeleteUi::~CalenDeleteUi

// Destructor

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

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

//

CalenDeleteUi::~CalenDeleteUi()

    {

    OstTraceFunctionEntry0( DUP1_CALENDELETEUI_CALENDELETEUI_ENTRY );

    OstTraceFunctionExit0( DUP1_CALENDELETEUI_CALENDELETEUI_EXIT );

    }

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

// CalenDeleteUi::ConstructL

// Second phase of construction

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

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

//

void CalenDeleteUi::ConstructL()

    {

    OstTraceFunctionEntry0( CALENDELETEUI_CONSTRUCTL_ENTRY );

    iMoreEntriesToDelete = EFalse;

    iDisplayQuery = EFalse;

    iEntriesToDelete = KEntriesToDelete;

    OstTraceFunctionExit0( CALENDELETEUI_CONSTRUCTL_EXIT );

    }

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

// CalenDeleteUi::HandleNotification

// Handles notifications.

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

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

//

void CalenDeleteUi::HandleNotification(const TCalenNotification aNotification )

    {

    OstTraceFunctionEntry0( CALENDELETEUI_HANDLENOTIFICATION_ENTRY );

    if( aNotification == ECalenNotifyCancelDelete)

        {

        if(iMutlipleContextIdsCount)

            {

            // get the context

            MCalenContext& context = iController.context();

            // reset the multiple contexts

            context.resetMultipleContextIds();          

            }

        }

    OstTraceFunctionExit0( CALENDELETEUI_HANDLENOTIFICATION_EXIT );

    }

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

// CalenDeleteUi::HandleCommandL

// Handles action ui commands

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

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

//

TBool CalenDeleteUi::HandleCommandL( const TCalenCommand& aCommand )

    {

    OstTraceFunctionEntry0( CALENDELETEUI_HANDLECOMMANDL_ENTRY );

    TBool continueCommand(EFalse);

    switch( aCommand.Command() )

        {

        case ECalenDeleteCurrentEntry:

        	mDeleteCommand = ECalenDeleteCurrentEntry;

        	DeleteCurrentEntryL(); // Entry & instance

            break;

        case ECalenDeleteSeries:

        	mDeleteCommand = ECalenDeleteSeries;

        	DeleteThisOrAllL( AgendaUtil::ThisAndAll );

            break;

        case ECalenDeleteCurrentOccurrence:

        	mDeleteCommand = ECalenDeleteCurrentOccurrence;

        	DeleteThisOrAllL( AgendaUtil::ThisOnly );

            break;

        case ECalenDeleteEntryWithoutQuery:

        	//TODO:

        	// This case is not handled currently as no such commands

        	// has been issued. So this has to be handled once we start 

        	// issuing the command. 

        	/*continueCommand = DeleteEntryWithoutQueryL();*/

            break;

        case ECalenDeleteAllEntries:

        	mDeleteCommand = ECalenDeleteAllEntries;

        	DeleteAllEntriesL(); // EntryView & instance

            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;

        }

    OstTraceFunctionExit0( CALENDELETEUI_HANDLECOMMANDL_EXIT );

    return continueCommand;

    }

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

// CalenDeleteUi::DeleteThisOrAllL

// Deletes series repeating entry

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

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

//

void CalenDeleteUi::DeleteThisOrAllL( AgendaUtil::RecurrenceRange aRepeatType )

{

    OstTraceFunctionEntry0( CALENDELETEUI_DELETETHISORALLL_ENTRY );

	if( iController.context().instanceId().mEntryLocalUid )

	{

		AgendaEntry instance = CalenActionUiUtils::findPossibleInstanceL(

									iController.context().instanceId(),

									iController.Services().agendaInterface() );

		if( !instance.isNull() )

		{

			DeleteSingleInstanceL( instance, aRepeatType );

		}

	}

	OstTraceFunctionExit0( CALENDELETEUI_DELETETHISORALLL_EXIT );

}

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

// CalenDeleteUi::DeleteEntryWithoutQueryL()

// Deletes the current entry

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

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

//

TBool CalenDeleteUi::DeleteEntryWithoutQueryL()

    {

    OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRYWITHOUTQUERYL_ENTRY );

	bool continueCommand(EFalse);

	// get the context

	MCalenContext& context = iController.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

			QList<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

			    ulong entryLocalUid = multipleContextIds[0].mEntryLocalUid;

			    if(entryLocalUid)

			        {

			        DeleteEntryL(entryLocalUid);

			        }

			    // remove mutliple context based on the instanceid

			    context.removeMultipleContextId(multipleContextIds[0]);

			    index++;

			   }

			if(!iMoreEntriesToDelete)

			    {

			    MarkedEntriesDeletedL();    

			    }

			}

        else

            {

            context.resetMultipleContextIds();

            // notify delete failed

            iController.BroadcastNotification(ECalenNotifyDeleteFailed);    

            }

    OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRYWITHOUTQUERYL_EXIT );

    return continueCommand;

    }

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

// CalenDeleteUi::DeleteCurrentEntryL

// Deletes the current entry

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

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

//

void CalenDeleteUi::DeleteCurrentEntryL()

{

    OstTraceFunctionEntry0( CALENDELETEUI_DELETECURRENTENTRYL_ENTRY );

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

	if (iController.context().instanceId().mEntryLocalUid) {

		// Fetch the entry

		AgendaEntry entry = iController.Services().agendaInterface()->fetchById(

				iController.context().instanceId().mEntryLocalUid);

			// Check if the entry is a To-Do

			if (AgendaEntry::TypeTodo == entry.type()) {

				showDeleteQuery(EDeleteToDo);

			} else {

				// Show the repeat entry delete query for repeating entries except Anniversary

				// Even though the anniversary is repeating 

				// all the instances will be deleted

				if ((entry.isRepeating() || !entry.recurrenceId().isNull()) 

							&& (AgendaEntry::TypeAnniversary != entry.type())) {

					// Show a confirmation note whether the user

					// wants to delete the single instance or all of them

					showRepeatingEntryDeleteQuery();

				} else if (CalenAgendaUtils::isAlldayEvent(entry)) {

					showDeleteQuery(EDeleteEvent);

				} else {

					// If the entry is not a repeating entry,

					// delete it directly

					// Save the entry for later reference in the slot

					showDeleteQuery(EDeleteEntry);

				}

			}

	}

	OstTraceFunctionExit0( CALENDELETEUI_DELETECURRENTENTRYL_EXIT );

}

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

// CalenDeleteUi::DeleteAllEntriesL

// Deletes all entries

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

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

//

void CalenDeleteUi::DeleteAllEntriesL()

    {

    OstTraceFunctionEntry0( CALENDELETEUI_DELETEALLENTRIESL_ENTRY );

	if(iIsDeleting) {

		OstTraceFunctionExit0( CALENDELETEUI_DELETEALLENTRIESL_EXIT );

		return;

	}

    showDeleteQuery(EDeleteAll );

	OstTraceFunctionExit0( DUP1_CALENDELETEUI_DELETEALLENTRIESL_EXIT );

	}

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

// CalenDeleteUi::DeleteEntriesBeforeDateL

// Deletes all entries before a set date.

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

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

//

void CalenDeleteUi::DeleteEntriesBeforeDateL()

    {

    OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRIESBEFOREDATEL_ENTRY );

	if(iIsDeleting) {

		OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRIESBEFOREDATEL_EXIT );

		return;

	}    

    // launch the datepicker

    dateQuery();

    OstTraceFunctionExit0( DUP1_CALENDELETEUI_DELETEENTRIESBEFOREDATEL_EXIT );

    }

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

// CalenDeleteUi::dateQuery

// Launches the popup for the date selection

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

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

//

void CalenDeleteUi::dateQuery()

	{

    OstTraceFunctionEntry0( CALENDELETEUI_DATEQUERY_ENTRY );

	// Create a popup with datepicker to select the date.

	HbDialog *popUp = new HbDialog();

	popUp->setDismissPolicy(HbDialog::NoDismiss);

	popUp->setTimeout(HbDialog::NoTimeout );

	popUp->setAttribute( Qt::WA_DeleteOnClose, true );

	popUp->setHeadingWidget(new HbLabel(hbTrId("txt_calendar_title_set_date")));

	QDateTime currentDateTime(CalenDateUtils::today());

	QDate currentDate(currentDateTime.date());

	if(mDatePicker) {

		mDatePicker = NULL;

	}

	mDatePicker = new  HbDateTimePicker(popUp);

	mDatePicker->setMinimumDate(CalenDateUtils::minTime().date());

	mDatePicker->setMaximumDate(currentDate);

	mDatePicker->setDate(currentDate);

	popUp->setContentWidget(mDatePicker);  

	mDeleteAction = new HbAction(

						hbTrId("txt_common_button_delete"), popUp);

	popUp->addAction(mDeleteAction);

	mCancelAction = new HbAction(hbTrId("txt_common_button_cancel"),popUp);

	popUp->addAction(mCancelAction);

	// Show the popup

	popUp->open(this, SLOT(handleDateQuery(HbAction*)));

	OstTraceFunctionExit0( CALENDELETEUI_DATEQUERY_EXIT );

	}

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

// CalenDeleteUi::handleDateQuery

// Handles the selection for the date query

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

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

//

void CalenDeleteUi::handleDateQuery(HbAction* action)

{

    OstTraceFunctionEntry0( CALENDELETEUI_HANDLEDATEQUERY_ENTRY );

	if(action == mDeleteAction) {

		// User selected the date before which all the entries has to be deleted

		QDate selectedDate(mDatePicker->date());

		// Check if the date is within the range.

		if(selectedDate.isValid()) {

			QTime time(0,0,0,0);

			QDateTime dateTime;

			dateTime.setDate(selectedDate);

			dateTime.setTime(time);

			// Do delete only if inputted day is after beginning of range

			if(dateTime > AgendaUtil::minTime()) {

				// Two pass delete:

				// 1. pass

				// To prevent destroying entries starting and ending midnight

				// subtract one second and do delete on that range.

				dateTime = dateTime.addSecs(-1);

				dateTime = ( dateTime > AgendaUtil::minTime()? 

											dateTime :  AgendaUtil::minTime());

				HandleDeleteMultipleEventsL( AgendaUtil::minTime(), 

																 dateTime, 1);

			}else {

				iController.BroadcastNotification(ECalenNotifyDeleteFailed);

			}

		}

	}else {

		// User pressed cancel

	}

	// Reset the member variables

	mDeleteAction = NULL;

	mCancelAction = NULL;

	OstTraceFunctionExit0( CALENDELETEUI_HANDLEDATEQUERY_EXIT );

}

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

// CalenDeleteUi::showRepeatingEntryDeleteQuery

// Launches the popup for deleting the repeating entry

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

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

//

void CalenDeleteUi::showRepeatingEntryDeleteQuery()

{

    OstTraceFunctionEntry0( CALENDELETEUI_SHOWREPEATINGENTRYDELETEQUERY_ENTRY );

    HbDialog *popUp = new HbDialog();

    popUp->setDismissPolicy(HbDialog::NoDismiss);

    popUp->setTimeout(HbDialog::NoTimeout);

    popUp->setAttribute( Qt::WA_DeleteOnClose, true );

    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Vertical);

    HbWidget *editWidget = new HbWidget();

    editWidget->setLayout(layout);

    HbRadioButtonList *editButtonList = new HbRadioButtonList();