/*

* Copyright (c) 2010 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 of CalenEditorDataHandler class.

*

*/

// System Includes

#include <hbmessagebox.h>

#include <hbdataformmodelitem.h>

// User Includes

#include "caleneditordatahandler.h"

#include "calendateutils.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "caleneditordatahandlerTraces.h"

#endif

/*!

	\class CalenEditorDataHandler

 */

/*!

	Constructor.

 */

CalenEditorDataHandler::CalenEditorDataHandler(CalenEditorPrivate* calenEditor,

                                               AgendaEntry* editedEntry, 

                    	                       AgendaEntry* originalEntry)

: mCalenEditor(calenEditor),mEditedEntry(editedEntry), mOriginalEntry(originalEntry)

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_CALENEDITORDATAHANDLER_ENTRY );

	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_CALENEDITORDATAHANDLER_EXIT );

}

/*!

	 Destructor

 */

CalenEditorDataHandler::~CalenEditorDataHandler()

{

	OstTraceFunctionEntry0( DUP1_CALENEDITORDATAHANDLER_CALENEDITORDATAHANDLER_ENTRY );

	// Nothing Yet

	OstTraceFunctionExit0( DUP1_CALENEDITORDATAHANDLER_CALENEDITORDATAHANDLER_EXIT );

}

/*!

	 Returns pointer for edited entry

	 \return pointer for edited entry

 */

AgendaEntry* CalenEditorDataHandler::editedEntry()

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_EDITEDENTRY_ENTRY );

	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_EDITEDENTRY_EXIT );

	return mEditedEntry;

}

/*!

	 Returns pointer for original entry

	 \return pointer for original entry

 */

AgendaEntry* CalenEditorDataHandler::originalEntry()

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ORIGINALENTRY_ENTRY );

	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_ORIGINALENTRY_EXIT );

	return mOriginalEntry;

}

/*!

	 Checks if user entered data violates the permitted attributes

	 \return Error Error indicating the violated parameter

 */

CalenEditorPrivate::Error CalenEditorDataHandler::checkErrorsForThisAndAll()

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_CHECKERRORSFORTHISANDALL_ENTRY );

	//TODO :  Remove implementation once handle all repeating errors

	const QDateTime startTime = mEditedEntry->startTime();

	const QDateTime endTime = mEditedEntry->endTime();

	// Repeating entry checks:

	if (mEditedEntry->isRepeating()) {

		// Check that repeat until date is a) later than start date

		//										(for new notes)

		//									b) not before start date

		//										(for existing notes)

		QDateTime repeatUntilDay = mEditedEntry->repeatRule().until();

		QDateTime repeatStartDay;

		// if new note or old note isnt repeating

		// edited.repeatUntil date must be greater than edited.start date

		// else

		// if IsRepeatRuleEdited or IsStartDateTimeEdited 

		// (either one above will make a new rule in which edited.startdate

		// is the start date)

		// edited.repeatUntil must be greater than edited.start date

		// else

		// edited.repeatUntil must be greater than start date on disk

		if (mCalenEditor->isNewEntry() || mOriginalEntry->repeatRule().isNull()

				|| isRepeatRuleEdited() || isStartDateTimeEdited()) {

			// We don't have an rrule so we can't get the rrule start date,

			// or user has edited a field that will cause new start date to be

			// used in the new rule.

			// Use the edited entry's start date.

			repeatStartDay = startTime;

		} else {

			// original rule is valid and new rule will not be created

			repeatStartDay = mOriginalEntry->repeatRule().repeatRuleStart();

		}

		if (durationGreaterThanRepeatIntervalError()) {

			OstTraceFunctionExit0( CALENEDITORDATAHANDLER_CHECKERRORSFORTHISANDALL_EXIT );

			return CalenEditorPrivate::

							CalenEditorErrorDurationGreaterThanRepeatInterval;

		}

		OstTraceFunctionExit0( DUP1_CALENEDITORDATAHANDLER_CHECKERRORSFORTHISANDALL_EXIT );

		return CalenEditorPrivate::CalenEditorErrorNone;

	}

	OstTraceFunctionExit0( DUP2_CALENEDITORDATAHANDLER_CHECKERRORSFORTHISANDALL_EXIT );

	return CalenEditorPrivate::CalenEditorErrorNone;

}

/*!

	Returns true if the entry has been modified, false otherwise.

	\return true if the entry has been modified, false otherwise.

 */

bool CalenEditorDataHandler::isEdited() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISEDITED_ENTRY );

	return (isSummaryEdited() ||

			isAllDayEdited() ||

			isLocationEdited() ||

			isStartDateTimeEdited() ||

			isEndDateTimeEdited() ||

			isAlarmEdited() ||

			isRepeatRuleEdited() ||

			isDescriptionEdited());

}

/*!

	Returns true if the summary has been edited, false otherwise.

	\return true if the summary has been edited, false otherwise.

 */

bool CalenEditorDataHandler::isSummaryEdited() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISSUMMARYEDITED_ENTRY );

	return (mOriginalEntry->summary() != mEditedEntry->summary());

}

/*!

	Returns true if the all day has been edited, false otherwise.

	\return true if the all day has been edited, false otherwise.

 */

bool CalenEditorDataHandler::isAllDayEdited() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISALLDAYEDITED_ENTRY );

	HbDataFormModelItem* alldayItem = mCalenEditor->allDayCheckBoxItem();

	if (alldayItem) {

		if (mOriginalEntry->type() == AgendaEntry::TypeEvent) {

			if (alldayItem->contentWidgetData("checkState")

			        == Qt::Checked) {

				OstTraceFunctionExit0( CALENEDITORDATAHANDLER_ISALLDAYEDITED_EXIT );

				return false;

			} else {

				OstTraceFunctionExit0( DUP1_CALENEDITORDATAHANDLER_ISALLDAYEDITED_EXIT );

				return true;

			}

		} else if (mOriginalEntry->type() == AgendaEntry::TypeAppoinment) {

			if (alldayItem->contentWidgetData("checkState")

			        == Qt::Checked) {

				OstTraceFunctionExit0( DUP2_CALENEDITORDATAHANDLER_ISALLDAYEDITED_EXIT );

				return true;

			} else {

				OstTraceFunctionExit0( DUP3_CALENEDITORDATAHANDLER_ISALLDAYEDITED_EXIT );

				return false;

			}

		}

	}

	OstTraceFunctionExit0( DUP4_CALENEDITORDATAHANDLER_ISALLDAYEDITED_EXIT );

	return false;

}

/*!

	Returns true if the location has been edited, false otherwise.

	\return true if the location has been edited, false otherwise.

 */

bool CalenEditorDataHandler::isLocationEdited() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISLOCATIONEDITED_ENTRY );

	return (mOriginalEntry->location() != mEditedEntry->location());

}

/*!

	Returns true if the start date/time has been edited, false otherwise.

	\return true if the start date/time has been edited, false otherwise.

 */

bool CalenEditorDataHandler::isStartDateTimeEdited() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISSTARTDATETIMEEDITED_ENTRY );

	return (mOriginalEntry->startTime() != mEditedEntry->startTime());

}

/*!

	Returns true if the end date/time has been edited, false otherwise.

	\return true if the end date/time has been edited, false otherwise.

 */

bool CalenEditorDataHandler::isEndDateTimeEdited() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISENDDATETIMEEDITED_ENTRY );

	return (mOriginalEntry->endTime() != mEditedEntry->endTime());

}

/*!

	Returns true if the alarm has been edited, false otherwise.

	\return true if the alarm has been edited, false otherwise.

 */

bool CalenEditorDataHandler::isAlarmEdited() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISALARMEDITED_ENTRY );

	return (mOriginalEntry->alarm() != mEditedEntry->alarm());

}

/*!

	Returns true if the repeat rule has been edited, false otherwise.

	\return true if the repeat rule has been edited, false otherwise.

 */

bool CalenEditorDataHandler::isRepeatRuleEdited() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISREPEATRULEEDITED_ENTRY );

	if ((mOriginalEntry->repeatRule().type() == AgendaRepeatRule::InvalidRule)

	        && (mEditedEntry->repeatRule().type()

	                == AgendaRepeatRule::InvalidRule)) {

		OstTraceFunctionExit0( CALENEDITORDATAHANDLER_ISREPEATRULEEDITED_EXIT );

		return false;

	} else {

	}

}

/*!

	Returns true if the Description field has been edited, false otherwise.

	\return true if the Description field has been edited, false otherwise.

 */

bool CalenEditorDataHandler::isDescriptionEdited() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISDESCRIPTIONEDITED_ENTRY );

	return (mOriginalEntry->description() != mEditedEntry->description());

}

/*!

	Returns true if any of the non-text items (e.g. time fields) of the entry

	have been edited, false otherwise.

	\return true if any of the non text items edited,false otherwise.

 */

bool CalenEditorDataHandler::nonTextItemsEdited() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_NONTEXTITEMSEDITED_ENTRY );

	return (isAllDayEdited() ||

			isStartDateTimeEdited() ||

			isEndDateTimeEdited() ||

			isAlarmEdited() ||

			isRepeatRuleEdited());

}

/*!

	Returns true if summary && location && description text items are all empty,

	false otherwise.

	\return true if text items are all empty,false otherwise.

 */

bool CalenEditorDataHandler::areTextItemsEmpty() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ARETEXTITEMSEMPTY_ENTRY );

	return (mEditedEntry->summary().isEmpty()

	        && mEditedEntry->location().isEmpty()

	        && mEditedEntry->description().isEmpty());

}

/*!

	Returns true if the user cleared the text in the location and summary items,

	false otherwise.

	\return true if summary & location items are cleared,false otherwise.

 */

bool CalenEditorDataHandler::areTextItemsCleared() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ARETEXTITEMSCLEARED_ENTRY );

	if (mEditedEntry->summary().isEmpty() &&

			mEditedEntry->location().isEmpty() &&

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

		if (isSummaryEmptied() 

				|| isLocationEmptied() 

				|| isDescriptionEmptied()) {

			OstTraceFunctionExit0( CALENEDITORDATAHANDLER_ARETEXTITEMSCLEARED_EXIT );

			return true;

		}

	}

	OstTraceFunctionExit0( DUP1_CALENEDITORDATAHANDLER_ARETEXTITEMSCLEARED_EXIT );

	return false;

}

/*!

	Returns true the summary was not empty in original && is empty

	in the edited note,false otherwise

	\return true if summary is cleared in edited note,false otherwise

 */

bool CalenEditorDataHandler::isSummaryEmptied() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISSUMMARYEMPTIED_ENTRY );

	return (!mOriginalEntry->summary().isEmpty()

	        && mEditedEntry->summary().isEmpty());

}

/*!

	Returns true the location was not empty in original && is empty

	in the edited note,false otherwise

	\return true if location is cleared in edited note,false otherwise

 */

bool CalenEditorDataHandler::isLocationEmptied() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISLOCATIONEMPTIED_ENTRY );

	return (!mOriginalEntry->location().isEmpty()

	        && mEditedEntry->location().isEmpty());

}

/*!

	Returns true the description was not empty in original && is empty

	in the edited note,false otherwise

	\return true if description is cleared in edited note,false otherwise

 */

bool CalenEditorDataHandler::isDescriptionEmptied() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISDESCRIPTIONEMPTIED_ENTRY );

	return (!mOriginalEntry->description().isEmpty()

	        && mEditedEntry->description().isEmpty());

}

/*!

	Works out whether the entry should be deleted, saved, 

	or whether no action should be taken.

	\return enum Action

 */

CalenEditorPrivate::Action CalenEditorDataHandler::shouldSaveOrDeleteOrDoNothing(bool launchCalendar) 

																		const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_SHOULDSAVEORDELETEORDONOTHING_ENTRY );

	// Need to save the entry if third party calls editor to launch the

	// calendar after that. So, that entry will be new entry adn we assume

	// that client launches editor with some prefilled text items

	if (!isEdited() && !launchCalendar) {

		// Not edited at all OR

		// Only added space characters to text fields but not

		// edited the non-text items

		// no need to save the entry

		OstTraceFunctionExit0( CALENEDITORDATAHANDLER_SHOULDSAVEORDELETEORDONOTHING_EXIT );

		return CalenEditorPrivate::ActionNothing;

	}

	// new entry is edited

	if (mCalenEditor->isNewEntry()) {

		// Subject && Location && Description are text items.

		// If text items as a whole is not empty, we can save the note

		// If text items as a whole is empty, we can still save the note

		// since we edited "non-text" fields

		if (!nonTextItemsEdited() && areTextItemsEmpty()) {

			OstTraceFunctionExit0( DUP1_CALENEDITORDATAHANDLER_SHOULDSAVEORDELETEORDONOTHING_EXIT );

			return CalenEditorPrivate::ActionNothing;

		} else {

			OstTraceFunctionExit0( DUP2_CALENEDITORDATAHANDLER_SHOULDSAVEORDELETEORDONOTHING_EXIT );

			return CalenEditorPrivate::ActionSave;

		}

	}

	if (areTextItemsCleared() && !nonTextItemsEdited()) {

		// ***** edited entry + text items emptied + non-text items not edited

		// Even if user may have edited non-text fields, 

		// delete the note 

		OstTraceFunctionExit0( DUP3_CALENEDITORDATAHANDLER_SHOULDSAVEORDELETEORDONOTHING_EXIT );

		return CalenEditorPrivate::ActionDelete;

	}

	// Save the note, since the text fields contain something

	OstTraceFunctionExit0( DUP4_CALENEDITORDATAHANDLER_SHOULDSAVEORDELETEORDONOTHING_EXIT );

	return CalenEditorPrivate::ActionSave;

}

/*!

	Returns true if the duration of instances of the meeting is greater than

	the repeat period of the series, false otherwise.

	\return true if duration of meeting is greater than repeat period, false

	otherwise

 */

bool CalenEditorDataHandler::durationGreaterThanRepeatIntervalError() const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_DURATIONGREATERTHANREPEATINTERVALERROR_ENTRY );

	bool isError = false;

	switch (mEditedEntry->repeatRule().type()) {

		case AgendaRepeatRule::DailyRule: {

			int durationDays =

			        mEditedEntry->startTime().daysTo(mEditedEntry->endTime());

			isError = durationDays >= 1;

		}

		break;

		case AgendaRepeatRule::WeeklyRule: {

			int durationDays =

			        mEditedEntry->startTime().daysTo(mEditedEntry->endTime());

			if (mEditedEntry->repeatRule().interval() == 1) {

				isError = durationDays >= 7;

			} else {

				isError = durationDays >= 14;

			}

		}

		break;

		case AgendaRepeatRule::MonthlyRule: {

			if (mEditedEntry->endTime()

			        >= (mEditedEntry->startTime().addMonths(1))) {

				isError = true;

			}

		}

		break;

		case AgendaRepeatRule::YearlyRule: {

			if (mEditedEntry->endTime()

			        >= (mEditedEntry->startTime().addYears(1))) {

				isError = true;

			}

		}

		break;

		default:

			// Not repeating, no error

			isError = false;

			break;

	}

	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_DURATIONGREATERTHANREPEATINTERVALERROR_EXIT );

	return isError;

}

/*!

	Check the alarm fields for errors.

	\return the error if found, or CalenEditorErrorNone if no error found.

 */

CalenEditorPrivate::Error CalenEditorDataHandler::checkAlarmFieldsForErrors(

															bool series) const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_CHECKALARMFIELDSFORERRORS_ENTRY );

	CalenEditorPrivate::Error error = CalenEditorPrivate::CalenEditorErrorNone;

	// If alarm not active, no check

	if (!mEditedEntry->alarm().isNull()) {

		int alarm = mEditedEntry->alarm().timeOffset();

		QDateTime startTime = mEditedEntry->startTime();

		QDateTime alarmTime;

		if (alarm > 0) {

			alarmTime = startTime.addSecs(-alarm * 60);

		} else {

			alarmTime = startTime.addSecs(alarm * 60);

		}

		QDateTime currentTime = CalenDateUtils::now();

		if (isAlarmInAcceptablePeriod(error, alarmTime, startTime)) {

			if (!series && (alarmTime < currentTime)) {

				// dont let non-repeating future entries have alarms in past

				error = CalenEditorPrivate::CalenEditorErrorAlarmTimePast;

			}

		}

	}

	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_CHECKALARMFIELDSFORERRORS_EXIT );

	return error;

}

/*!

	Checks if AlarmTime is 31 days from StartTime, 

	then sets Error to CalenEditorErrorAlarmDateTooManyDaysBeforeNote and

	returns false

	Checks if AlarmTime is later StartTime, 

	then sets Error to CalenEditorErrorAlarmTimeLaterThanNote and returns false

	\return true if error untouched, false otherwise 

 */

bool CalenEditorDataHandler::isAlarmInAcceptablePeriod(CalenEditorPrivate::Error &error,

										const QDateTime &alarmTime,

										const QDateTime &startTime) const

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISALARMINACCEPTABLEPERIOD_ENTRY );

	QDateTime upperLimit = startTime;

	QDateTime lowerLimit = startTime.addDays(-31);

	bool acceptable = true;

	if (alarmTime < lowerLimit) {

		acceptable = false;

		error = CalenEditorPrivate::CalenEditorErrorAlarmDateTooManyDaysBeforeNote;

	} else {

		if (alarmTime > upperLimit) {

			acceptable = false;

			error = CalenEditorPrivate::CalenEditorErrorAlarmTimeLaterThanNote;

		}

	}

	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_ISALARMINACCEPTABLEPERIOD_EXIT );

	return acceptable;

}

/*!

	Display the given error msg

	\param error Error value for which message has to be displayed

 */

void CalenEditorDataHandler::displayErrorMsg(int error)

{

	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_DISPLAYERRORMSG_ENTRY );

	QString errorMsg = QString::Null();

	switch (error) {

		case CalenEditorPrivate::CalenEditorErrorAlarmTimeLaterThanNote:

			errorMsg.append( hbTrId(