/*

* 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 of CalenEditorRepeatField class.

*

*/

// System Includes

#include <QDate>

#include <hbdataformmodelitem.h>

#include <hbdataformviewitem.h>

#include <hbdataformmodel.h>

#include <hbdataform.h>

#include <hbcombobox.h>

#include <hblabel.h>

#include <hbdatetimepicker.h>

#include <hbaction.h>

#include <agendautil.h>

// User Included

#include "caleneditorrepeatfield.h"

#include "caleneditorcustomitem.h"

#include "caleneditorreminderfield.h"

#include "calendateutils.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "caleneditorrepeatfieldTraces.h"

#endif

// Constants

const int userRole = Qt::UserRole + 100;

/*!

	\class CalenEditorRepeatField

 */

/*!

    \enum CalenEditorRepeatField::RepeatTypes

    This enum defines the different repeat types of an entry

 */

/*!

    \var CalenEditorRepeatField::RepeatTypes CalenEditorRepeatField::RepeatOnce

    No repeating type.

 */

/*!

    \var CalenEditorRepeatField::RepeatTypes CalenEditorRepeatField::RepeatDaily

    Daily repeating type.

 */

/*!

    \var CalenEditorRepeatField::RepeatTypes CalenEditorRepeatField::RepeatWorkdays

    Workdays repeating type.

 */

/*!

    \var CalenEditorRepeatField::RepeatTypes CalenEditorRepeatField::RepeatWeekly

    Weekly repeating type.

 */

/*!

    \var CalenEditorRepeatField::RepeatTypes CalenEditorRepeatField::RepeatBiWeekly

    Fortnightly repeating type.

 */

/*!

    \var CalenEditorRepeatField::RepeatTypes CalenEditorRepeatField::RepeatMonthly

    Monthly repeating type.

 */

/*!

    \var CalenEditorRepeatField::RepeatTypes CalenEditorRepeatField::RepeatYearly

    Yearly repeating type.

 */

/*!

	Constructor.

	\param parent QObject pointer

 */

CalenEditorRepeatField::CalenEditorRepeatField(CalenEditorPrivate* calenEditor,

       										HbDataForm* form, 

       										HbDataFormModel* model,

       										QObject *parent)

	:QObject(parent),

    mCalenEditor(calenEditor), 

	mEditorForm(form), 

	mCalenEditorModel(model), 

	mRepeatItem(0),

	mRepeatComboBox(0),

	mCustomRepeatUntilItem(0),

	mRepeatRoleValue(0),

	mIsBiWeekly(false),

	mIsWorkdays(false),

	mRepeatUntilItemAdded(false)

{

	OstTraceFunctionEntry0( CALENEDITORREPEATFIELD_CALENEDITORREPEATFIELD_ENTRY );

	if (!mCalenEditor->editedEntry()->repeatRule().isNull()) {

		mRepeatRuleType = mCalenEditor->editedEntry()->repeatRule().type();

		mRepeatUntilDate = mCalenEditor->editedEntry()->repeatRule().until().date();

	}

	mRepeatItem = new HbDataFormModelItem();

	mRepeatItem->setType(HbDataFormModelItem::ComboBoxItem);

	mRepeatItem->setData(HbDataFormModelItem::LabelRole,

	                     hbTrId("txt_calendar_setlabel_repeat"));

	// Create the repeat choices

	QStringList repeatChoices;

	repeatChoices << hbTrId("txt_calendar_setlabel_repeat_val_only_once")

					<< hbTrId("txt_calendar_setlabel_repeat_val_daily")

					<< hbTrId("txt_calendar_setlabel_repeat_val_workdays")

					<< hbTrId("txt_calendar_setlabel_repeat_val_weekly")

					<< hbTrId("txt_calendar_setlabel_repeat_val_fortnightly")

					<< hbTrId("txt_calendar_setlabel_repeat_val_monthly")

					<< hbTrId("txt_calendar_setlabel_repeat_val_yearly");

		mRepeatItem->setContentWidgetData("items", repeatChoices);

		mRepeatItem->setContentWidgetData("objectName", "repeatItem");

		mCalenEditorModel->appendDataFormItem( mRepeatItem,

									mCalenEditorModel->invisibleRootItem());

	OstTraceFunctionExit0( CALENEDITORREPEATFIELD_CALENEDITORREPEATFIELD_EXIT );

}

/*!

 Destructor

 */

CalenEditorRepeatField::~CalenEditorRepeatField()

{

	OstTraceFunctionEntry0( DUP1_CALENEDITORREPEATFIELD_CALENEDITORREPEATFIELD_ENTRY );

	// Nothing Yet

	OstTraceFunctionExit0( DUP1_CALENEDITORREPEATFIELD_CALENEDITORREPEATFIELD_EXIT );

}

/*!

	Adds repeat item to the model

 */

void CalenEditorRepeatField::addItemToModel()

{	

	OstTraceFunctionEntry0( CALENEDITORREPEATFIELD_ADDITEMTOMODEL_ENTRY );

	// Add reminder to the model

	mCalenEditorModel->appendDataFormItem( mRepeatItem,

				   mCalenEditorModel->invisibleRootItem());

	OstTraceFunctionExit0( CALENEDITORREPEATFIELD_ADDITEMTOMODEL_EXIT );

}

/*!

	Removes the repeat item from the model

 */

void CalenEditorRepeatField::removeItemFromModel()

{

	OstTraceFunctionEntry0( CALENEDITORREPEATFIELD_REMOVEITEMFROMMODEL_ENTRY );

	mCalenEditorModel->removeItem(modelIndex());

	OstTraceFunctionExit0( CALENEDITORREPEATFIELD_REMOVEITEMFROMMODEL_EXIT );

}

/*!

	 Populates repeat item with the options available

	 \param index index at which repeat item needs to be added

 */

void CalenEditorRepeatField::populateRepeatItem(int index)

{

	OstTraceFunctionEntry0( CALENEDITORREPEATFIELD_POPULATEREPEATITEM_ENTRY );

	HbDataFormViewItem

			*item =

					qobject_cast<HbDataFormViewItem *> (

							mEditorForm->itemByIndex(

										mCalenEditorModel->index( index, 0)));

	mRepeatComboBox

			= qobject_cast<HbComboBox *> (item->dataItemContentWidget());

	// Set the user roles for the combobox items so that we depend on these

	// roles to identify the correct repeat type when repeat choices are 

	// dynamically removed or added

	mRepeatComboBox->setItemData(RepeatOnce, RepeatOnce, userRole);

	mRepeatComboBox->setItemData(RepeatDaily, RepeatDaily, userRole);

	mRepeatComboBox->setItemData(RepeatWorkdays, 

								 RepeatWorkdays, userRole);

	mRepeatComboBox->setItemData(RepeatWeekly, RepeatWeekly, userRole);

	mRepeatComboBox->setItemData(RepeatBiWeekly, 

								 RepeatBiWeekly, userRole);

	mRepeatComboBox->setItemData(RepeatMonthly, 

								 RepeatMonthly, userRole);

	mRepeatComboBox->setItemData(RepeatYearly, RepeatYearly, userRole);

	if (mCalenEditor->editedEntry()->isRepeating()) {

		switch (mCalenEditor->editedEntry()->repeatRule().type()) {

			case AgendaRepeatRule::DailyRule: {

				mRepeatComboBox->setCurrentIndex(DailyRole);

			}

				break;

			case AgendaRepeatRule::WeeklyRule: {

				bool isWorkdays = AgendaUtil::isWorkdaysRepeatingEntry(

						mCalenEditor->editedEntry()->repeatRule());

				if (isWorkdays) {

					mRepeatComboBox->setCurrentIndex(WorkdaysRole);

					mIsWorkdays = true;

				} else {

					if (mCalenEditor->editedEntry()->repeatRule().interval() == 1) {

						mRepeatComboBox->setCurrentIndex(WeeklyRole);

					} else {

						mRepeatComboBox->setCurrentIndex(BiWeeklyRole);

						mIsBiWeekly = true;

					}

				}

			}

				break;

			case AgendaRepeatRule::MonthlyRule: {

				mRepeatComboBox->setCurrentIndex(MonthlyRole);

			}

				break;

			case AgendaRepeatRule::YearlyRule: {

				mRepeatComboBox->setCurrentIndex(YearlyRole);

			}

				break;

			default:

				break;

		}

		// If entry is repeating type then insert the repeatuntil item.

		insertRepeatUntilItem();

	} else {

		mRepeatComboBox->setCurrentIndex(0);

		// Set the Original entry value also.

		mCalenEditor->originalEntry()->setRepeatRule(

									  AgendaRepeatRule(

									  AgendaRepeatRule::InvalidRule));

	}

	// Connect the slot once the updation of mRepeatComboBox is done

	connect(mRepeatComboBox, SIGNAL(currentIndexChanged(int)), this,

				SLOT(handleRepeatIndexChanged(int)));

	// Update the repeat choices depending upon the duration

	updateRepeatChoices();

	OstTraceFunctionExit0( CALENEDITORREPEATFIELD_POPULATEREPEATITEM_EXIT );

}

/*!

	Removes the repeat until item from the model

	and removed the connection for date picker launch too.

 */

void CalenEditorRepeatField::removeRepeatUntilItem()

{

	OstTraceFunctionEntry0( CALENEDITORREPEATFIELD_REMOVEREPEATUNTILITEM_ENTRY );

	mRepeatRuleType = AgendaRepeatRule::InvalidRule;

	if (mRepeatUntilItemAdded) {

		mEditorForm->removeConnection(mCustomRepeatUntilItem, SIGNAL(clicked()),

	                                this, SLOT(launchRepeatUntilDatePicker()));

		QModelIndex repeatIndex =

		        mCalenEditorModel->indexFromItem(mRepeatItem);

		mCalenEditorModel->removeItem(

		                              mCalenEditorModel->index(

		                              repeatIndex.row()+ 1, 0));

		mRepeatUntilItemAdded = false;

		mCustomRepeatUntilItem = 0;

	}

	OstTraceFunctionExit0( CALENEDITORREPEATFIELD_REMOVEREPEATUNTILITEM_EXIT );

}

/*!

	Triggerd from tapping on reminder item.

	Handles the reminder time change and updates the same in the event.

	\param index The new index chosen in the reminder list.

 */

void CalenEditorRepeatField::handleRepeatIndexChanged(int index)

{

	OstTraceFunctionEntry0( CALENEDITORREPEATFIELD_HANDLEREPEATINDEXCHANGED_ENTRY );

	HbExtendedLocale locale = HbExtendedLocale::system();

	// Get the user role we have set for this index

	QVariant role = mRepeatComboBox->itemData(index, userRole);

	int value = role.toInt();

	// Boolean to check if the repeating property of the entry is changed.

	// based on the value and mRepeatUntilItemAdded

	// ie. From repeating to non repeating OR vice versa OR No change

	bool repeatPropertyChange = false;

	if (value > 0 && value <= 6 && !mRepeatUntilItemAdded) {

		// Non repeating to repeating

		repeatPropertyChange = true;

	}else if(mRepeatUntilItemAdded && value == 0) {

		// Repeating to non repeating

		repeatPropertyChange = true;

	}else {

		// No change in repeat value

		repeatPropertyChange = false;

	}

	QDate repeatUntilDate = mRepeatUntilDate;

	int itemIndex = CalenEditorPrivate::RepeatUntilItem;

	if (!mCalenEditor->isReminderTimeForAllDayAdded()) {

		itemIndex -= 1;

	}

	// Update the repeat type only if its has been changed

	// ie. if the previous repeatrole is different from the current repeat role

	if (value != mRepeatRoleValue) {

		mRepeatRoleValue = value;

		mIsBiWeekly = false;

		mIsWorkdays = false;

		switch (value) {

			case DailyRole: {

				if (!mRepeatUntilItemAdded) {

					insertRepeatUntilItem();

				}

				if (mCustomRepeatUntilItem) {

					// Show default repeat until date till one year for daily rule 

					mRepeatUntilDate = 

						mCalenEditor->editedEntry()->startTime().date().addYears(1);

					mCustomRepeatUntilItem->setContentWidgetData( "text", 

						locale.format( 

								mRepeatUntilDate, r_qtn_date_usual_with_zero));

				}

				mRepeatRuleType = AgendaRepeatRule::DailyRule;

			}

			break;

			case WorkdaysRole: {

				if (!mRepeatUntilItemAdded) {

					insertRepeatUntilItem();

				}

				if (mCustomRepeatUntilItem) {

					// Show default repeat until date till one year for workdays rule

					mRepeatUntilDate = 

						mCalenEditor->editedEntry()->startTime().date().addYears(1);

					mCustomRepeatUntilItem->setContentWidgetData( "text",

						locale.format( 

								mRepeatUntilDate, r_qtn_date_usual_with_zero));

				}

				mRepeatRuleType = AgendaRepeatRule::WeeklyRule;

				mIsWorkdays = true;

			}

			break;

			case WeeklyRole: {

				if (!mRepeatUntilItemAdded) {

					insertRepeatUntilItem();

				}

				if (mCustomRepeatUntilItem) {

					// Show default repeat until date till one year for weekly rule

					mRepeatUntilDate = 

						mCalenEditor->editedEntry()->startTime().date().addYears(1);

					mCustomRepeatUntilItem->setContentWidgetData( "text",

						locale.format( 

								mRepeatUntilDate, r_qtn_date_usual_with_zero));

				}

				mRepeatRuleType = AgendaRepeatRule::WeeklyRule;

			}

			break;

			case BiWeeklyRole: {

				if (!mRepeatUntilItemAdded) {

					insertRepeatUntilItem();

				}

				if (mCustomRepeatUntilItem) {

					// Show default repeat until date till one year for bi-weekly rule

					mRepeatUntilDate = 

						mCalenEditor->editedEntry()->startTime().date().addYears(1);

					mCustomRepeatUntilItem->setContentWidgetData( "text",

						locale.format( 

							mRepeatUntilDate, r_qtn_date_usual_with_zero));

				}

				mRepeatRuleType = AgendaRepeatRule::WeeklyRule;

				mIsBiWeekly = true;

			}

			break;

			case MonthlyRole: {

				if (!mRepeatUntilItemAdded) {

					insertRepeatUntilItem();

				}

				if (mCustomRepeatUntilItem) {

					// Show default repeat until date till one year for monthly rule

					mRepeatUntilDate = 

						mCalenEditor->editedEntry()->startTime().date().addYears(1);

					mCustomRepeatUntilItem->setContentWidgetData( "text",

						locale.format(

								mRepeatUntilDate, r_qtn_date_usual_with_zero));

				}

				mRepeatRuleType = AgendaRepeatRule::MonthlyRule;

			}

			break;

			case YearlyRole: {

				if (!mRepeatUntilItemAdded) {

					insertRepeatUntilItem();

				}

				if (mCustomRepeatUntilItem) {

					// Show default repeat until date till ten years for yearly rule

					mRepeatUntilDate = 

						mCalenEditor->editedEntry()->startTime().date().addYears(10);

					mCustomRepeatUntilItem->setContentWidgetData( "text",

						locale.format(

							mRepeatUntilDate, r_qtn_date_usual_with_zero));

				}

				mRepeatRuleType = AgendaRepeatRule::YearlyRule;

			}

			break;

			default: {

				removeRepeatUntilItem();

			}

			break;

		}

	}

	if(!mCalenEditor->isNewEntry()) {

		mCalenEditor->addDiscardAction();

	}

	// Depending on repeatPropertyChange value and the repeatuntil date change 

	// the reminder choices are updated 

	if(repeatPropertyChange || repeatUntilDate != mRepeatUntilDate) {

		mCalenEditor->updateReminderChoices();

		// Once the entry is changed from  non repeating to repeating we scroll to the repeat until item.

		if(repeatPropertyChange && mRepeatUntilItemAdded) {

			mEditorForm->scrollTo(mCalenEditorModel->index(itemIndex, 0), HbAbstractItemView::EnsureVisible);

			// Once the entry is changed from  non repeating to repeating 

			// and if the alarm set is off 

			// Then change the reminder option to the default 'one day before' 

			// if the option is valid

			if (mCalenEditor->isAllDayEvent()) {

				if(!mCalenEditor->isReminderTimeForAllDayAdded() &&

						mCalenEditor->getReminderCount() >= 3) {

					mCalenEditor->setCurrentIndexOfReminderField(

							CalenEditorReminderField::ReminderOneDayBefore);

				}

			}

		}

	}

	OstTraceFunctionExit0( CALENEDITORREPEATFIELD_HANDLEREPEATINDEXCHANGED_EXIT );

}

/*!

	 Returns model index of the repeat item

	 \return Model index of the repeat item

 */

QModelIndex CalenEditorRepeatField::modelIndex()

{

	OstTraceFunctionEntry0( CALENEDITORREPEATFIELD_MODELINDEX_ENTRY );

	return mCalenEditorModel->indexFromItem(mRepeatItem);

}

/*!

	Inserts the repeat until item to the dataform model

 */

void CalenEditorRepeatField::insertRepeatUntilItem()

{

	OstTraceFunctionEntry0( CALENEDITORREPEATFIELD_INSERTREPEATUNTILITEM_ENTRY );

	HbDataFormModelItem::DataItemType itemType =

	        static_cast<HbDataFormModelItem::DataItemType> (RepeatUntilOffset);

	int index = CalenEditorPrivate::RepeatUntilItem;

	if (!mCalenEditor->isReminderTimeForAllDayAdded()) {

		index -= 1;

	}

	mCustomRepeatUntilItem = mCalenEditorModel->insertDataFormItem(

										index,

										itemType,

										QString(

										hbTrId(

										"txt_calendar_setlabel_repeat_until")),

										mCalenEditorModel->invisibleRootItem());

	mRepeatUntilItemAdded = true;

	mEditorForm->addConnection(mCustomRepeatUntilItem, SIGNAL(clicked()),

	                                this, SLOT(launchRepeatUntilDatePicker()));

	if (!mCalenEditor->isNewEntry() && mRepeatRuleType != AgendaRepeatRule::InvalidRule) {

		HbExtendedLocale locale = HbExtendedLocale::system();

		QString dateString = locale.format(

				mCalenEditor->editedEntry()->repeatRule().until().date(),

				r_qtn_date_usual_with_zero);

		mCustomRepeatUntilItem->setContentWidgetData("text", dateString);

	}

	OstTraceFunctionExit0( CALENEDITORREPEATFIELD_INSERTREPEATUNTILITEM_EXIT );

}

/*!

	 Informs if repeat until item has been added or not

	 \return true if repeat until item is added else false

 */

bool CalenEditorRepeatField::isRepeatUntilItemAdded()

{

	OstTraceFunctionEntry0( CALENEDITORREPEATFIELD_ISREPEATUNTILITEMADDED_ENTRY );

	OstTraceFunctionExit0( CALENEDITORREPEATFIELD_ISREPEATUNTILITEMADDED_EXIT );

	return mRepeatUntilItemAdded;

}

/*!

	Launches the date picker by tapping on the repaet until pushbutton

 */

void CalenEditorRepeatField::launchRepeatUntilDatePicker()

{

	OstTraceFunctionEntry0( CALENEDITORREPEATFIELD_LAUNCHREPEATUNTILDATEPICKER_ENTRY );

	HbDialog *popUp = new HbDialog();

	// Set the parent for the dialog

	// Once the parent object is deleted the dialog will also be deleted

	popUp->setParent(this);

	popUp->setDismissPolicy(HbDialog::NoDismiss);

	popUp->setTimeout(HbDialog::NoTimeout);

	popUp->setHeadingWidget( new HbLabel(

									hbTrId("txt_calendar_title_repeat_until")));

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