/*

 * 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: Definition file for class CalenEditorPrivate.

 *

 */

// System includes

#include <QObject>

#include <QTimer>

#include <QGraphicsLinearLayout>

#include <QApplication>

#include <hbdataform.h>

#include <hbmainwindow.h>

#include <hbinstance.h>

#include <hbdataformmodel.h>

#include <hbdataformmodelitem.h>

#include <hbdataformviewitem.h>

#include <hbaction.h>

#include <hbmenu.h>

#include <hbgraphicsscene.h>

#include <hblineedit.h>

#include <hbcheckbox.h>

#include <hbcombobox.h>

#include <hbpushbutton.h>

#include <hbdatetimepicker.h>

#include <hbmessagebox.h>

#include <hblabel.h>

#include <hbview.h>

#include <hbextendedlocale.h>

#include <hbi18ndef.h>

#include <qdatetime.h>

#include <hbgroupbox.h>

#include <hbradiobuttonlist.h>

#include <hbnotificationdialog.h>

#include <hbtranslator.h>

// User includes

#include <CalenLauncher>

#include <agendaentry.h>

#include <agendautil.h>

#include <caleneditor.h>

#include "caleneditor_p.h"

#include "caleneditorcustomitem.h"

#include "calendateutils.h"

#include "caleneditordocloader.h"

#include "caleneditorcommon.h"

#include "calendateutils.h"

#include "calenagendautils.h"

#include "caleneditordatahandler.h"

#include "caleneditorreminderfield.h"

#include "caleneditorrepeatfield.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "caleneditor_pTraces.h"

#endif

/*!

	\class CalenEditorPrivate

	This object loads the calendar editor view. The view is added to the top

	of the HbMainWindow.

 */

/*!

	\enum CalenEditorPrivate::Error

	This enum defines the possible errors of CalenEditorPrivate

 */

/*!

	\var CalenEditorPrivate::Error CalenEditorPrivate::CalenEditorErrorNone

	No error.

 */

/*!

	\var CalenEditorPrivate::Error CalenEditorPrivate::CalenEditorErrorAlarmTimeLaterThanNote

	Alarm time is later than entry error.

 */

/*!

	\var CalenEditorPrivate::Error CalenEditorPrivate::CalenEditorErrorAlarmTimePast

	The time for the entry alarm has already expired error.

 */

/*!

	\var CalenEditorPrivate::Error

	CalenEditorPrivate::CalenEditorErrorAlarmDateTooManyDaysBeforeNote

	Alarm date is 1000 days or more past error.

 */

/*!

	\var CalenEditorPrivate::Error

	CalenEditorPrivate::CalenEditorErrorRepeatUntilEarlierThanNote

	Repeat until date earlier than start date error.

 */

/*!

	\var CalenEditorPrivate::Error

	CalenEditorPrivate::CalenEditorErrorDurationGreaterThanRepeatInterval

	The duration of the entry is greater than repeat type interval error.

 */

/*!

	\var CalenEditorPrivate::Error

	CalenEditorPrivate::CalenEditorErrorStopTimeEarlierThanStartTime

	End date/time is earlier than start error.

 */

/*!

	\var CalenEditorPrivate::Error CalenEditorPrivate::CalenEditorErrorDbConflictEntryDeleted

	Entry was deleted by other application error.

 */

/*!

	\var CalenEditorPrivate::Error CalenEditorPrivate::CalenEditorErrorDbConflictEntryModified

	Entry was modified by other application error.

 */

/*!

	\var CalenEditorPrivate::Error CalenEditorPrivate::CalenEditorErrorOutOfSequence

	Moving a meeting out of sequence error.

 */

/*!

	\var CalenEditorPrivate::Error CalenEditorPrivate::CalenEditorErrorOverlapsExistingInstance

	Attempting to move a meeting to overlap another instance of the meeting error.

 */

/*!

	\var CalenEditorPrivate::Error

	CalenEditorPrivate::CalenEditorErrorInstanceAlreadyExistsOnThisDay

	Attempting to move an instance of a meeting to a day when an instance 

	already exists error.

 */

/*!

	\enum CalenEditorPrivate::Action

	This enum defines the actions on entry

 */

/*!

	\var CalenEditorPrivate::Action CalenEditorPrivate::ActionNothing

	Nothing to do with entry 

 */

/*!

	\var CalenEditorPrivate::Action CalenEditorPrivate::ActionSave

	Save entry 

 */

/*!

	\var CalenEditorPrivate::Action CalenEditorPrivate::ActionDelete

	Delete entry 

 */

/*!

	\enum CalenEditorPrivate::EditorItemIndex

	This enum defines the indexes of the items in the dataform

 */

/*!

	\var CalenEditorPrivate::EditorItemIndex CalenEditorPrivate::SubjectItem

	Index of the subject dataform item.

 */

/*!

	\var CalenEditorPrivate::EditorItemIndex CalenEditorPrivate::AllDayItem

	Index of the all day checkbox item.

 */

/*!

	\var CalenEditorPrivate::EditorItemIndex CalenEditorPrivate::DateTimeFromItem

	Index of the Date time (from) item.

 */

/*!

	\var CalenEditorPrivate::EditorItemIndex CalenEditorPrivate::DateTimeToItem

	Index of the Date time (to) item.

 */

/*!

	\var CalenEditorPrivate::EditorItemIndex CalenEditorPrivate::LocationItem

	Index of the location item.

 */

/*!

	\var CalenEditorPrivate::EditorItemIndex CalenEditorPrivate::ReminderItem

	Index of the reminder item.

 */

/*!

	\var CalenEditorPrivate::EditorItemIndex CalenEditorPrivate::RepeatItem

	Index of the repeat item.

 */

/*!

	\var CalenEditorPrivate::EditorItemIndex CalenEditorPrivate::RepeatUntilItem

	Index of the repest Until item.

 */

/*!

	\class CalenEditorPrivate

 */

/*!

	Constructor.

	\param agendaUtil pointer to agenda utility

	\param parent HbView pointer.

 */

CalenEditorPrivate::CalenEditorPrivate(AgendaUtil *agendaUtil, 

                                       QObject *parent) :

									QObject(parent),

									mEditorDocLoader(0),

									mEditorView(0),

									mDataHandler(NULL),

									mCalenEditorForm(0),

									mCalenEditorModel(0),

									mSubjectItem(0),

									mViewFromItem(0),

									mViewToItem(0),

                                    mViewLocationItem(0),

									mAllDayCheckBoxItem(0),		                            

									mReminderField(0),

									mRepeatField(0),

									mDescriptionItem(0),

									mEditRange(ThisAndAll),

									mOriginalEntry(NULL),

									mEditedEntry(NULL),

									mTranslator(new HbTranslator("caleneditor")),

									mNewEntry(true),

									mDescriptionItemAdded(false),

									mIsChild(false),

									mIsAllDayItemAdded(false),

									mLaunchCalendar(false),

									mMenuItemAdded(false)

{

	OstTraceFunctionEntry0( CALENEDITORPRIVATE_CALENEDITORPRIVATE_ENTRY );

	// First get the q-pointer.

	q_ptr = static_cast<CalenEditor *> (parent);

	mMainWindow = 0;

	mTranslator->loadCommon();

	if (!agendaUtil) {

		mAgendaUtil = new AgendaUtil(this);

		mOwnsAgendaUtil = true;

	} else {

		mAgendaUtil = agendaUtil;

		mOwnsAgendaUtil = false;

	}

	OstTraceFunctionExit0( CALENEDITORPRIVATE_CALENEDITORPRIVATE_EXIT );

}

/*!

	Destructor.

 */

CalenEditorPrivate::~CalenEditorPrivate()

{

	OstTraceFunctionEntry0( DUP1_CALENEDITORPRIVATE_CALENEDITORPRIVATE_ENTRY );

	if(mOwnsAgendaUtil) {

		delete mAgendaUtil;

		mAgendaUtil = 0;

	}

	if (mOriginalEntry) {

		delete mOriginalEntry;

		mOriginalEntry = NULL;

	}

	if (mEditedEntry) {

		delete mEditedEntry;

		mEditedEntry = NULL;

	}

	if(mEditorDocLoader) {

		delete mEditorDocLoader;

		mEditorDocLoader = 0;

	}

	if(mReminderField) {

		delete mReminderField;

		mReminderField = 0;

	}

	if(mRepeatField) {

		delete mRepeatField;

		mRepeatField = 0;

	}

	if(mDataHandler) {

		delete mDataHandler;

		mDataHandler = 0;

	}

	if (mCalenEditorModel) {

		delete mCalenEditorModel;

		mCalenEditorModel = 0;

	}

	// Remove the translator

	if (mTranslator) {

		delete mTranslator;

		mTranslator = 0;

	}

	// delete the mainwindow object if created any

	if (mMainWindow) {

		delete mMainWindow;

		mMainWindow = 0;

	}

	OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_CALENEDITORPRIVATE_EXIT );

}

/*!

	Shows the caleneditor by parsing a .vcs.

	\param handle reference to QFile handle.

 */

void CalenEditorPrivate::edit(const QFile &/*handle*/, bool launchCalendar)

{

	OstTraceFunctionEntry0( CALENEDITORPRIVATE_EDIT_ENTRY );

	// TODO: Needs to be implemented using importer.

	mNewEntry = false;

	mLaunchCalendar = launchCalendar;

	OstTraceFunctionExit0( CALENEDITORPRIVATE_EDIT_EXIT );

}

/*!

	Shows the caleneditor, by parsing an AgendaEntry.

	\param entry An object of AgendaEntry.

 */

void CalenEditorPrivate::edit(AgendaEntry entry, bool launchCalendar)

{

	OstTraceFunctionEntry0( DUP1_CALENEDITORPRIVATE_EDIT_ENTRY );

	mNewEntry = false;

	mLaunchCalendar = launchCalendar;

	openEditor(entry);

	OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_EDIT_EXIT );

}

/*!

	Shows the caleneditor, by using the entry id provided.

	\param id entry id.

 */

void CalenEditorPrivate::edit(ulong id, bool launchCalendar)

{

	OstTraceFunctionEntry0( DUP2_CALENEDITORPRIVATE_EDIT_ENTRY );

	mNewEntry = false;

	AgendaEntry entry = mAgendaUtil->fetchById(id);

	if(entry.isNull()) {

		OstTraceFunctionExit0( DUP2_CALENEDITORPRIVATE_EDIT_EXIT );

		return;

	}

	edit(entry, launchCalendar);

	OstTraceFunctionExit0( DUP3_CALENEDITORPRIVATE_EDIT_EXIT );

}

/*!

	Creates a new entry based on the create type.It launches the

	editor for editing

	\type type of the editor to be shown for creating new entry.

	\QDateTime newEntryDateTime is the event start time.

 */

void CalenEditorPrivate::create(CalenEditor::CreateType type,

                                QDateTime newEntryDateTime, bool launchCalendar)

{

	OstTraceFunctionEntry0( CALENEDITORPRIVATE_CREATE_ENTRY );

	mNewEntryDateTime = newEntryDateTime;

	mNewEntry = true;

	AgendaEntry entry;

	switch(type){

		case CalenEditor::TypeAppointment: {

			entry.setType(AgendaEntry::TypeAppoinment);

		}

		break;

		default:

			// What ever be the type of entry, currently editor supports only to

			// open the entries of TypeAppoinment

			entry.setType(AgendaEntry::TypeAppoinment);

			break;

	}

	mLaunchCalendar = launchCalendar;

	openEditor(entry);

	OstTraceFunctionExit0( CALENEDITORPRIVATE_CREATE_EXIT );

}

/*!

	Creates a new entry based on the create type.It launches the

	editor for editing

	\type type of the editor to be shown for creating new entry.

	\QDateTime newEntryDateTime is the event start time.

 */

void CalenEditorPrivate::create(CalenEditor::CreateType type,

                                AgendaEntry entry, bool launchCalendar)

{

	OstTraceFunctionEntry0( DUP1_CALENEDITORPRIVATE_CREATE_ENTRY );

	mNewEntry = true;

	switch(type){

		case CalenEditor::TypeAppointment: {

			entry.setType(AgendaEntry::TypeAppoinment);

		}

		break;

		default:

			// What ever be the type of entry, currently editor supports only to

			// open the entries of TypeAppoinment

			entry.setType(AgendaEntry::TypeAppoinment);

			break;

	}

	mNewEntryDateTime = entry.startTime();

	mLaunchCalendar = launchCalendar;

	openEditor(entry);

	OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_CREATE_EXIT );

}

/*!

	Queries user whether to edit whole series or just this single occurence

 */

void CalenEditorPrivate::showEditOccurencePopup()

{

	OstTraceFunctionEntry0( CALENEDITORPRIVATE_SHOWEDITOCCURENCEPOPUP_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();

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

	// Create cancel action

	HbAction *cancelAction =

	        new HbAction(hbTrId("txt_common_button_cancel_singledialog"));

	popUp->addAction(cancelAction);

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

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

	        SLOT(handleEditOccurence(int)));

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

	// Show the popup

	popUp->open();

	OstTraceFunctionExit0( CALENEDITORPRIVATE_SHOWEDITOCCURENCEPOPUP_EXIT );

}

/*!

	Slot to handle User selection for series editing or single occurence popup

 */

void CalenEditorPrivate::handleEditOccurence(int index)

{

	OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLEEDITOCCURENCE_ENTRY );

	switch (index) {

		case 0:

			// User wants to edit only this occurence

			mEditRange = ThisOnly;

			break;

		case 1:

			// User wants to edit all the occurences

			mEditRange = ThisAndAll;

			break;

	}

	// If user has selected to edit all the occurences, 

	// then get the parent of it

	AgendaEntry entryToBeEdited = mEntry;

	if (mEditRange == ThisAndAll) {

		entryToBeEdited = mAgendaUtil->parentEntry(mEntry);

	}

	showEditor(entryToBeEdited);

	OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLEEDITOCCURENCE_EXIT );

}

/*!

	Slot to handle cancel action on the popup

 */

void CalenEditorPrivate::handleCancel()

{

	OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLECANCEL_ENTRY );

	// User has chosen not to edit the event, hence return

	mEditRange = UserCancelled;

	// Do cleanup and return

	emit q_ptr->dialogClosed();

	OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLECANCEL_EXIT );

	return;

}

/*!

	Opens the editor.

 */

void CalenEditorPrivate::openEditor(AgendaEntry entry)

{

	OstTraceFunctionEntry0( CALENEDITORPRIVATE_OPENEDITOR_ENTRY );

	if (0 < entry.id()) {

		mNewEntry = false;

	}

	if (!mNewEntry) {

		// Before we do anything, check in the entry is repeating

		// OR its a child item

		mIsChild = !(entry.recurrenceId().isNull());

		bool isRepeating = entry.isRepeating();

		// For later reference

		mEntry = entry;

		if (mIsChild || isRepeating) {

			// Query user if he wants to edit whole series 

			// or just this occurence

			showEditOccurencePopup();

			OstTraceFunctionExit0( CALENEDITORPRIVATE_OPENEDITOR_EXIT );

			return;

		}else {

			mEditRange = ThisAndAll;

		}

	}

	showEditor(entry);

	OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_OPENEDITOR_EXIT );

}

/*!

	Displays the editor.

 */

void CalenEditorPrivate::showEditor(AgendaEntry entry)

{

	OstTraceFunctionEntry0( CALENEDITORPRIVATE_SHOWEDITOR_ENTRY );

	mOriginalEntry = new AgendaEntry(entry);

	mEditedEntry = new AgendaEntry(entry);

	if (!mEditedEntry->description().isEmpty()) {

		mDescriptionItemAdded = true;

	}

	// Construct the view using docloader

	setUpView();

	// Set the title text. 

	mEditorView->setTitle(hbTrId("txt_calendar_title_calendar"));

	mSoftKeyAction = new HbAction(Hb::BackNaviAction);

	mEditorView->setNavigationAction(mSoftKeyAction);

	connect(mSoftKeyAction, SIGNAL(triggered()), this,

	        SLOT(saveAndCloseEditor()));

	// Create the data handler

	mDataHandler = new CalenEditorDataHandler(this,mEditedEntry, mOriginalEntry);

	OstTraceFunctionExit0( CALENEDITORPRIVATE_SHOWEDITOR_EXIT );