/*

 * 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 Clock AlarmEditor.

 *

 */

// System includes

#include <QDateTime>

#include <HbDataForm>

#include <HbDataFormModel>

#include <HbDataFormModelItem>

#include <HbDataFormViewItem>

#include <HbInstance>

#include <HbAction>

#include <HbMenu>

#include <HbLabel>

#include <HbNotificationDialog>

#include <HbDialog>

#include <HbDateTimePicker>

#include <HbCheckBox>

#include <HbExtendedLocale>

#include <HbGroupBox>

#include <HbDocumentLoader>

#include <HbTranslator>

#include <HbAbstractVkbHost>

#include <HbLineEdit>

#include <xqsettingsmanager.h>

#include <xqsettingskey.h>

#include <QLocale>

// User includes

#include "clockprivatecrkeys.h"

#include "clockalarmeditor.h"

#include "alarmclient.h"

#include "settingsutility.h"

#include "timezoneclient.h"

#include "clockalarmcustomitem.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "clockalarmeditorTraces.h"

#endif

// Constants

const int KOneHourInMinute(60);

const int KOneMinuteInSecons(60);

const int KOneMinute(1);

const int KOneHour(1);

const int KSecondsInOneDay(24 * 60 * 60);

const int KDaysInWeek(7);

/*!

    \class ClockAlarmEditor

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

    of the HbMainWindow.

 */

/*!

    Constructor.

    \param parentViewIndex Previous view Index.

    \param alarmId Id of the alarm, if new alarm(0) or else id of alarm to be

    edit.

    \param parent The parent object.

 */

ClockAlarmEditor::ClockAlarmEditor(

		AlarmClient &alarmClient, int alarmId,

		QObject *parent)

:QObject(parent),

 mAlarmId(alarmId),

 mStartOfWeek(0),

 mAlarmDayItemInserted(false),

 mIsQuickAlarm(true),

 mAlarmEditorForm(0),

 mAlarmEditorModel(0),

 mAlarmTimeItem(0),

 mAlarmOccurenceItem(0),

 mAlarmDayItem(0),

 mAlarmSoundItem(0),

 mAlarmDescription(0),

 mAlarmClient(alarmClient)

{

 	OstTraceFunctionEntry0( CLOCKALARMEDITOR_CLOCKALARMEDITOR_ENTRY );

 	// Load the translation file and install the alarmeditor specific translator

	mTranslator = new HbTranslator("clockalarmeditor");

	mTranslator->loadCommon();

	// create the timezone client object

	mTimezoneClient = TimezoneClient::getInstance();

	// Create the settings manager.

	mSettingsManager = new XQSettingsManager(this);

	mPreviosAlarmTime = new XQSettingsKey(

			XQSettingsKey::TargetCentralRepository,

			KCRUidNitz,

			KPreviousAlarmTime);

	// Create settings utility object. To get the date & time format.

	// TODO: do i need to delete this object ??

	SettingsUtility *settingsUtil = new SettingsUtility(this);

	mTimeFormat = settingsUtil->timeFormatString();

	// Get start of week from the locale.

    HbExtendedLocale locale = HbExtendedLocale::system();

    mStartOfWeek = locale.startOfWeek();

	// Create the HbDocumentLoader object.

	HbDocumentLoader *loader = new HbDocumentLoader();

	bool success;

	loader->load(":/xml/clockalarmeditor.docml", &success);

	mAlarmEditorView = qobject_cast<HbView *>(

			loader->findWidget("alarmEditorView"));

	// Get the subtitle groupBox.

	HbGroupBox *subtitleGroupBox = qobject_cast<HbGroupBox *>(

			loader->findWidget("subtitleGroupBox"));

	// Set the heading of the subtitle groupBox.

	if (mAlarmId) {

		subtitleGroupBox->setHeading(hbTrId("txt_clock_subhead_alarm"));

	} else {

		subtitleGroupBox->setHeading(hbTrId("txt_clock_subhead_new_alarm"));

	}

	// Get the Alarm Editor DataForm.

	mAlarmEditorForm = qobject_cast<HbDataForm *> (

			loader->findWidget("alarmEditorForm"));

	mAlarmEditorForm->setItemPixmapCacheEnabled(true);

	// Create the alarm info structure with desired values.

	initAlarmInfo();

	// Creates & initializes the DataFormModel for the AlarmEditor DataForm.

	initModel();

	QList <HbAbstractViewItem*> prototypes = mAlarmEditorForm->itemPrototypes();

	ClockAlarmCustomItem *customItem =

			new ClockAlarmCustomItem(mAlarmEditorForm);

	prototypes.append(customItem);

	mAlarmEditorForm->setItemPrototypes(prototypes);

	// Get the menu items for the alarm editor.

	mDeleteAction = qobject_cast<HbAction *> (

			loader->findObject("deleteAction"));

	// Connect the signals for the menu item.

	connect(

			mDeleteAction, SIGNAL(triggered()),

			this, SLOT(handleDeleteAction()));

	// Add the done soft key action.

	mDoneAction = new HbAction(Hb::DoneNaviAction);

	connect(

			mDoneAction, SIGNAL(triggered()),

			this, SLOT(handleDoneAction()));

	mAlarmEditorView->setNavigationAction(mDoneAction);

	if (mAlarmEditorView) {

		mVirtualKeyboard = new HbAbstractVkbHost(mAlarmEditorView);

    }

	connect(

			mVirtualKeyboard, SIGNAL(keypadOpened()),

			this, SLOT(handleKeypadOpen()));

	connect(

			mVirtualKeyboard, SIGNAL(keypadClosed()),

			this, SLOT(handleKeypadClosed()));

	OstTraceFunctionExit0( CLOCKALARMEDITOR_CLOCKALARMEDITOR_EXIT );

}

/*!

    Destructor.

 */

ClockAlarmEditor::~ClockAlarmEditor()

{

	OstTraceFunctionEntry0( DUP1_CLOCKALARMEDITOR_CLOCKALARMEDITOR_ENTRY );

	// Remove the translator

	if (mTranslator) {

		delete mTranslator;

		mTranslator = 0;

	}

	OstTraceFunctionExit0( DUP1_CLOCKALARMEDITOR_CLOCKALARMEDITOR_EXIT );

}

/*!

    Show the alarm editor.

 */

void ClockAlarmEditor::showAlarmEditor()

{

	OstTraceFunctionEntry0( CLOCKALARMEDITOR_SHOWALARMEDITOR_ENTRY );

	// Store the current view and set alarm editor as current view.

	HbMainWindow *window = hbInstance->allMainWindows().first();

	window->addView(mAlarmEditorView);

	window->setCurrentView(mAlarmEditorView);

	OstTraceFunctionExit0( CLOCKALARMEDITOR_SHOWALARMEDITOR_EXIT );

}

/*!

    Handles done action on the editor. Saves the alarm

 */

void ClockAlarmEditor::handleDoneAction()

{

	OstTraceFunctionEntry0( CLOCKALARMEDITOR_HANDLEDONEACTION_ENTRY );

	int alarmDayIndex = -1;

	if (mAlarmDayItemInserted) {

		alarmDayIndex = mAlarmDayItem->contentWidgetData("currentIndex").toInt();

		alarmDayIndex += mStartOfWeek;

		if(alarmDayIndex >= KDaysInWeek){

		   alarmDayIndex -= KDaysInWeek;

		}

	}

	if(mAlarmId) {

		mAlarmClient.deleteAlarm(mAlarmId);

	}

	setAlarm(

			mAlarmTimeItem->contentWidgetData("text").toString(),

			mAlarmDescription->contentWidgetData("text").toString(),

			mAlarmOccurenceItem->contentWidgetData("currentIndex").toInt(),

			alarmDayIndex);

	mAlarmDayItemInserted = false;

	emit alarmSet();

	closeAlarmEditor();

	OstTraceFunctionExit0( CLOCKALARMEDITOR_HANDLEDONEACTION_EXIT );

}

/*!

	Handles delete action on the editor. Deletes the alarm.

 */

void ClockAlarmEditor::handleDeleteAction()

{

	OstTraceFunctionEntry0( CLOCKALARMEDITOR_HANDLEDELETEACTION_ENTRY );

	if(mAlarmId) {

		mAlarmClient.deleteAlarm(mAlarmId);

	}

	closeAlarmEditor();

	OstTraceFunctionExit0( CLOCKALARMEDITOR_HANDLEDELETEACTION_EXIT );

}

/*!

    Handles change in alarmtime item of the data form.

 */

void ClockAlarmEditor::handleTimeChange(const QString &text)

{

	OstTraceFunctionEntry0( CLOCKALARMEDITOR_HANDLETIMECHANGE_ENTRY );

	// If it is a new alarm.

	if (!mAlarmId) {

		// Decide the day to focus.

		int alarmDayIndex = (QDate::currentDate()).dayOfWeek() - 1;

		QTime alarmTime = QTime::fromString(

				text,

				mTimeFormat);

		if (!alarmTime.isValid()) {

			OstTraceFunctionExit0( CLOCKALARMEDITOR_HANDLETIMECHANGE_EXIT );

			return;

		}

		QTime homeTime = QTime::currentTime();

		if (-1 == alarmDayIndex) {

			OstTraceFunctionExit0( DUP1_CLOCKALARMEDITOR_HANDLETIMECHANGE_EXIT );

			return;

		}

		if (homeTime > alarmTime) {

			alarmDayIndex++;

		}

		if (7 == alarmDayIndex) {

			alarmDayIndex = 0;

		}

		if (mAlarmDayItemInserted) {

  		    alarmDayIndex -= mStartOfWeek;

            if(0 > alarmDayIndex){

               alarmDayIndex += KDaysInWeek;

            }

            mAlarmEditorForm->removeConnection(

            					mAlarmDayItem, SIGNAL(currentIndexChanged(int)),

            					this, SLOT(handleDayChanged(int)));

            mIsQuickAlarm = true;

			mAlarmDayItem->setContentWidgetData(

					"currentIndex",

					alarmDayIndex);

			mAlarmEditorForm->addConnection(

								mAlarmDayItem, SIGNAL(currentIndexChanged(int)),

								this, SLOT(handleDayChanged(int)));

		}

	}

	OstTraceFunctionExit0( DUP2_CLOCKALARMEDITOR_HANDLETIMECHANGE_EXIT );

}

/*!

    Handles change in alarm occurence item of the data form.

 */

void ClockAlarmEditor:: handleOccurenceChanged(int index)

{

	OstTraceFunctionEntry0( CLOCKALARMEDITOR_HANDLEOCCURENCECHANGED_ENTRY );

	Q_UNUSED(index)

	mIsQuickAlarm = false;

	int repeatIndex =

			mAlarmOccurenceItem->contentWidgetData("currentIndex").toInt();

	if ((Weekly == repeatIndex || Once == repeatIndex)) {

		// Decide which day to focus.

		int alarmDayIndex = (QDate::currentDate()).dayOfWeek() - 1;

		QTime alarmTime = QTime::fromString(

				mAlarmTimeItem->contentWidgetData("text").toString(),

				mTimeFormat);

		QTime homeTime = QTime::currentTime();

		if (-1 == alarmDayIndex) {

			OstTraceFunctionExit0( CLOCKALARMEDITOR_HANDLEOCCURENCECHANGED_EXIT );

			return;

		}

		if (homeTime > alarmTime) {

			alarmDayIndex++;

		}

		if (7 == alarmDayIndex) {

			alarmDayIndex = 0;

		}

		if (!mAlarmDayItemInserted) {

			// Show the alarm days field to select the day.

			mAlarmDayItem = new HbDataFormModelItem(

					HbDataFormModelItem::ComboBoxItem,

					QString(hbTrId("txt_clk_setlabel_day")));

			mAlarmEditorForm->addConnection(

								mAlarmDayItem, SIGNAL(currentIndexChanged(int)),

								this, SLOT(handleDayChanged(int)));

			// Add the alarm days beginning from the start of week.

			QStringList alarmDays;

			sortAlarmDaysList(alarmDays);

			alarmDayIndex -= mStartOfWeek;

			if(0 > alarmDayIndex){

				alarmDayIndex += KDaysInWeek;

			}

			mAlarmDayItem->setContentWidgetData("items", alarmDays);

			mAlarmDayItem->setContentWidgetData(

					"currentIndex",

					alarmDayIndex);

			int insertIndex = mAlarmEditorModel

					->indexFromItem(mAlarmOccurenceItem).row() + 1;

			mAlarmEditorModel->insertDataFormItem(insertIndex, mAlarmDayItem);

			mAlarmDayItemInserted = true;

		}

	} else {

		// Check if the Alarm days item is added.

		// Remove if already added.

		if (mAlarmDayItemInserted) {

			mAlarmEditorForm->removeConnection(

								mAlarmDayItem, SIGNAL(currentIndexChanged(int)),

								this, SLOT(handleDayChanged(int)));

			mAlarmEditorModel->removeItem(mAlarmDayItem);

			mAlarmDayItemInserted = false;

		}

	}

	OstTraceFunctionExit0( DUP1_CLOCKALARMEDITOR_HANDLEOCCURENCECHANGED_EXIT );

}

/*!

    Called when `OK' is pressed on the Dialog.

 */

void ClockAlarmEditor::handleOkAction()

{

	OstTraceFunctionEntry0( CLOCKALARMEDITOR_HANDLEOKACTION_ENTRY );

	// Get the time from the time picker.

	QTime newAlarmTime = static_cast<HbDateTimePicker *> (

			mTimePickerDialog->contentWidget())->time();

	// Update the selected time value.

	mAlarmTimeItem->setContentWidgetData("text",newAlarmTime.toString(mTimeFormat));

	if (mOldAlarmTime != newAlarmTime && mIsQuickAlarm) {

		handleTimeChange(newAlarmTime.toString(mTimeFormat));

	}

	mOldAlarmTime = newAlarmTime;

	OstTraceFunctionExit0( CLOCKALARMEDITOR_HANDLEOKACTION_EXIT );

}

/*!

    Launches datetimepicker when Alarm time button is clicked.

 */

void ClockAlarmEditor::launchTimePicker()

{

	OstTraceFunctionEntry0( CLOCKALARMEDITOR_LAUNCHTIMEPICKER_ENTRY );

	if (mTimePickerDialog) {

		delete mTimePickerDialog;

	}

	// Create the dialog.

	mTimePickerDialog = new HbDialog;

	mTimePickerDialog->setTimeout(HbDialog::NoTimeout);

	mTimePickerDialog->setDismissPolicy(HbDialog::NoDismiss);

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

	// Set the heading for the dialog.

	HbLabel * timeLabel =

		new HbLabel(hbTrId("txt_tumbler_title_alarm_time"),

			mTimePickerDialog);

	mTimePickerDialog->setHeadingWidget(timeLabel);

	SettingsUtility *settingsUtil = new SettingsUtility(this);

	QStringList timeSeparator;

	int index = settingsUtil->timeFormat(timeSeparator);

	QString tumblerDisplayFormat =

			mTimeFormat.replace(timeSeparator.at(index), QString("."));

	// Create the tumbler.

	HbDateTimePicker *timePicker = new HbDateTimePicker(mTimePickerDialog);

	timePicker->setDisplayFormat(tumblerDisplayFormat);

	mTimePickerDialog->setContentWidget(timePicker);

	QString timeString = mAlarmTimeItem->contentWidgetData("text").toString();

	QTime time = QTime::fromString(timeString, mTimeFormat);

	timePicker->setTime(time);

	mOkAction =

		new HbAction(QString(hbTrId("txt_common_button_ok")),

			mTimePickerDialog);

	mCancelAction =

		new HbAction(QString(hbTrId("txt_common_button_cancel")),

			mTimePickerDialog);

	mTimePickerDialog->addAction(mOkAction);

	mTimePickerDialog->addAction(mCancelAction);

	mTimePickerDialog->open(this, SLOT(selectedAction(HbAction*)));

	OstTraceFunctionExit0( CLOCKALARMEDITOR_LAUNCHTIMEPICKER_EXIT );

}

/*!

	Handles the alarm sound change.

 */

void ClockAlarmEditor::handleAlarmSoundChanged(int checkedState)

{

	OstTraceFunctionEntry0( CLOCKALARMEDITOR_HANDLEALARMSOUNDCHANGED_ENTRY );

	Q_UNUSED(checkedState)

	mIsQuickAlarm = false;

/*	if (AlarmVolumeOff == mAlarmInfo.volumeStatus) {

		mAlarmInfo.volumeStatus = AlarmVolumeOn;

	} else {

		mAlarmInfo.volumeStatus = AlarmVolumeOff;

	}*/

	OstTraceFunctionExit0( CLOCKALARMEDITOR_HANDLEALARMSOUNDCHANGED_EXIT );

}

/*!

	Slot to handle the selected action

 */

void ClockAlarmEditor::selectedAction(HbAction *action)

{

	OstTraceFunctionEntry0( CLOCKALARMEDITOR_SELECTEDACTION_ENTRY );

	if (action == mOkAction) {

		handleOkAction();

	}

	OstTraceFunctionExit0( CLOCKALARMEDITOR_SELECTEDACTION_EXIT );

}

/*!

	Slot to handle the change in day item.

 */

void ClockAlarmEditor::handleDayChanged(int index)

{

	Q_UNUSED(index)

	mIsQuickAlarm = false;

}

/*!

	Slot to handle the change in description.

 */

void ClockAlarmEditor::handleDescriptionChanged(const QString &text)

{

	Q_UNUSED(text)

	mIsQuickAlarm = false;

}

/*!

	Slot to handle the open event of vkb.

 */