/*

* 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 <hbaction.h>

#include <hblabel.h>

#include <hbradiobuttonlist.h>

#include <centralrepository.h>

#include <agendaentry.h>

// User includes

#include "calendarui_debug.h"

#include "calendeleteui.h"

#include "hb_calencommands.hrh"

#include "calencontext.h"

#include "calencontroller.h"

#include "CleanupResetAndDestroy.h"

#include "caleninstanceid.h"

#include "calenactionuiutils.h"

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

#include "calendateutils.h"

#include "calenagendautils.h"

// Local constants

const TInt KEntriesToDelete = 1;

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

// CalenDeleteUi::NewL

// Two phased constructor

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

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

//

CalenDeleteUi* CalenDeleteUi::NewL( CCalenController& aController )

    {

    TRACE_ENTRY_POINT;

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CalenDeleteUi::CalenDeleteUi

// ?implementation_description

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

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

//

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

    :QObject(parent), iController( aController )

    {

    TRACE_ENTRY_POINT;

    iIsDeleting = false;

    TRACE_EXIT_POINT;

    }

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

// CalenDeleteUi::~CalenDeleteUi

// Destructor

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

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

//

CalenDeleteUi::~CalenDeleteUi()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CalenDeleteUi::ConstructL

// Second phase of construction

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

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

//

void CalenDeleteUi::ConstructL()

    {

    TRACE_ENTRY_POINT;

    iController.RegisterForNotificationsL( this, ECalenNotifyCancelDelete );

    iMoreEntriesToDelete = EFalse;

    iDisplayQuery = EFalse;

    iEntriesToDelete = KEntriesToDelete;

    TRACE_EXIT_POINT;

    }

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

// CalenDeleteUi::HandleNotification

// Handles notifications.

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

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

//

void CalenDeleteUi::HandleNotification(const TCalenNotification aNotification )

    {

    TRACE_ENTRY_POINT;

    if( aNotification == ECalenNotifyCancelDelete)

        {

        if(iMutlipleContextIdsCount)

            {

            // get the context

            MCalenContext& context = iController.context();

            // reset the multiple contexts

            context.resetMultipleContextIds();          

            }

        }

    TRACE_EXIT_POINT;

    }

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

// CalenDeleteUi::HandleCommandL

// Handles action ui commands

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

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

//

TBool CalenDeleteUi::HandleCommandL( const TCalenCommand& aCommand )

    {

    TRACE_ENTRY_POINT;

    TBool continueCommand(EFalse);

    switch( aCommand.Command() )

        {

        case ECalenDeleteCurrentEntry:

            DeleteCurrentEntryL(); // Entry & instance

            break;

        case ECalenDeleteSeries:

            DeleteThisOrAllL( AgendaUtil::ThisAndAll );

            break;

        case ECalenDeleteCurrentOccurrence:

            DeleteThisOrAllL( AgendaUtil::ThisOnly );

            break;

        case ECalenDeleteEntryWithoutQuery:

            continueCommand = DeleteEntryWithoutQueryL();

            break;

        case 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;

        }

    TRACE_EXIT_POINT;

    return continueCommand;

    }

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

// CalenDeleteUi::DeleteThisOrAllL

// Deletes series repeating entry

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

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

//

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

    {

    TRACE_ENTRY_POINT;

    bool isDeleted( false );

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

        {

        AgendaEntry instance = 

            CalenActionUiUtils::findPossibleInstanceL(iController.context().instanceId(),

                                                   iController.Services().agendaInterface() );

         if( !instance.isNull() )

            {

            isDeleted = DeleteSingleInstanceL( instance, aRepeatType );

            }

        }

    iController.BroadcastNotification( isDeleted? ECalenNotifyEntryDeleted :

                                                               ECalenNotifyDeleteFailed );

    TRACE_EXIT_POINT;

    }

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

// CalenDeleteUi::DeleteEntryWithoutQueryL()

// Deletes the current entry

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

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

//

TBool CalenDeleteUi::DeleteEntryWithoutQueryL()

    {

    TRACE_ENTRY_POINT;

	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);    

            }

    TRACE_EXIT_POINT;

    return continueCommand;

    }

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

// CalenDeleteUi::DeleteCurrentEntryL

// Deletes the current entry

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

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

//

void CalenDeleteUi::DeleteCurrentEntryL()

{

    TRACE_ENTRY_POINT;

    bool deleted( false );

    TCalenNotification notification = ECalenNotifyDeleteFailed;

    // 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()) {

            if(!entry.isNull()) {

                deleted = DeleteEntryL(entry);

                if(deleted) {

                    // Delete is successful

                    notification = ECalenNotifyEntryDeleted;

                }

            }

        }

        else {

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

                // Show a confirmation note whether the user

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

                showRepeatingEntryDeleteQuery();

            } else {

                // If the entry is not a repeating entry,

                // delete it directly

                deleted = DeleteEntryL(entry);

                if (deleted) {

                    // Delete is successful

                    notification = ECalenNotifyEntryDeleted;

                }

            }

        }

    }

    iController.BroadcastNotification( notification );

    TRACE_EXIT_POINT;

}

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

// CalenDeleteUi::DeleteAllEntriesL

// Deletes all entries

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

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

//

void CalenDeleteUi::DeleteAllEntriesL()

    {

    TRACE_ENTRY_POINT;

    ASSERT( !iIsDeleting );

    const int buttonId = CalenActionUiUtils::showDeleteConfirmationQueryL( 

                                                                        CalenActionUiUtils::EDeleteAll );   

    if( buttonId )

        {

        HandleDeleteMultipleEventsL( AgendaUtil::minTime(), AgendaUtil::maxTime(),1 );

        }

    else

        {

        // notify delete failed

        iController.BroadcastNotification(ECalenNotifyDeleteFailed); 

        }

    TRACE_EXIT_POINT;

    }

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

// CalenDeleteUi::DeleteEntriesBeforeDateL

// Deletes all entries before a set date.

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

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

//

void CalenDeleteUi::DeleteEntriesBeforeDateL()

    {

    TRACE_ENTRY_POINT;

    ASSERT( !iIsDeleting );

    TCalenNotification notification = ECalenNotifyDeleteFailed;

    // launch the datepicker

    mIsDateValid = false;

    dateQuery();

    if( mIsDateValid )

        {

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

        if( mDateTime > AgendaUtil::minTime() )

            {

            // Two pass delete:

            // 1. pass

            // To prevent destroying entries starting and ending midnight

            mDateTime = ( mDateTime > AgendaUtil::minTime()? mDateTime :  AgendaUtil::minTime());

            HandleDeleteMultipleEventsL( AgendaUtil::minTime(),

                                                    mDateTime,1 );

            notification = ECalenNotifyMultipleEntriesDeleted;

            }

        }

    iController.BroadcastNotification( notification );

    TRACE_EXIT_POINT;

    }

void CalenDeleteUi::dateQuery()

	{

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

	QDateTime currentDateTime(CalenDateUtils::today());

	QDate currentDate(currentDateTime.date());

	mDatePicker = new  HbDateTimePicker(currentDate);

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

	mDatePicker->setMaximumDate(currentDate);

	HbDialog popUp;

	popUp.setDismissPolicy(HbDialog::NoDismiss);

	popUp.setTimeout(HbDialog::NoTimeout );

	popUp.setHeadingWidget(new HbLabel(hbTrId("txt_calendar_title_set_date")));

	popUp.setContentWidget(mDatePicker);  

	HbAction *okAction = new HbAction(hbTrId("txt_calendar_button_dialog_delete"));

	popUp.setPrimaryAction(okAction);

	connect(okAction,SIGNAL(triggered()),this,SLOT(getSelectedDate()));

	connect(okAction,SIGNAL(triggered()),&popUp,SLOT(close()));

	popUp.setSecondaryAction(new HbAction(hbTrId("txt_common_button_cancel"),&popUp));

	popUp.exec();

	}

void CalenDeleteUi::showRepeatingEntryDeleteQuery()

{

    HbDialog popUp;

    popUp.setDismissPolicy(HbDialog::NoDismiss);

    popUp.setTimeout(HbDialog::NoTimeout);

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

    HbWidget *editWidget = new HbWidget();

    editWidget->setLayout(layout);

    HbRadioButtonList *editButtonList = new HbRadioButtonList();

    QStringList list;

    list << hbTrId("txt_calendar_info_this_occurrence_only")

    		<< hbTrId("txt_calendar_info_all_occurences");

    editButtonList->setItems(list);

    layout->addItem(editButtonList);

    popUp.setContentWidget(editWidget);

    popUp.setHeadingWidget(new HbLabel(

						hbTrId("txt_calendar_title_delete_repeated_entry")));

    connect(editButtonList, SIGNAL(itemSelected(int)), this,

            SLOT(handleRepeatedEntryDelete(int)));

    connect(editButtonList, SIGNAL(itemSelected(int)), &popUp, SLOT(close()));

    // Create secondary action

    HbAction *cancelAction = new HbAction(

							hbTrId("txt_calendar_button_softkey1_cancel"));

    popUp.setSecondaryAction(cancelAction);

    connect(cancelAction, SIGNAL(triggered()), this, SLOT(handleCancel()));

    connect(cancelAction, SIGNAL(triggered()), &popUp, SLOT(close()));

    // Show the popup

    popUp.exec();

}

void CalenDeleteUi::getSelectedDate()

	{  

    QDate selectedDate(mDatePicker->date());

	// Check if the date is within the range.

	if(selectedDate.isValid())

		{

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

		mDateTime.setDate(selectedDate);

		mDateTime.setTime(time);

		mIsDateValid = true;

		}

    }

void CalenDeleteUi::handleRepeatedEntryDelete(int index)

{

    // Fetch the entry

    // Find all possible instances

    AgendaEntry instance = CalenActionUiUtils::findPossibleInstanceL(

                                iController.context().instanceId(),

                                iController.Services().agendaInterface());

    if (!instance.isNull()) {

        connect(iController.Services().agendaInterface(), SIGNAL(entryDeleted(ulong)),

                this, SLOT(entryDeleted(ulong)));

        switch(index) {

            case 0:

                // User wants to delete only this occurence

                iController.Services().agendaInterface()->deleteRepeatedEntry(instance, AgendaUtil::ThisOnly);

                break;

            case 1:

                // User wants to delete all the occurences

                iController.Services().agendaInterface()->deleteRepeatedEntry(instance, AgendaUtil::ThisAndAll);

                break;

        }

    }

}

void CalenDeleteUi::entryDeleted(ulong id)

{

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