/*

* 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:

*

*/

// System includes

#include <QObject>

#include <QDateTime>

#include <QGraphicsLinearLayout>

#include <QFile>

#include <QString>

#include <QTimer>

#include <QPluginLoader>

#include <QDir>

#include <HbInstance>

#include <HbMainWindow>

#include <HbView>

#include <HbMenu>

#include <HbGroupBox>

#include <HbScrollArea>

#include <HbIcon>

#include <HbAction>

#include <HbExtendedLocale>

#include <HbToolBar>

#include <hbi18ndef.h>

#include <HbRadioButtonList>

#include <HbMessageBox>

#include <HbDialog>

#include <HbLabel>

#include <HbTranslator>

// User includes

#include <maptileservice.h>//maptile service

#include <agendautil.h>

#include <NotesEditorInterface>

#include <CalenEditor>

#include "calenagendautils.h"

#include "agendaeventview.h"

#include "agendaeventviewerdocloader.h"

#include "agendaeventviewercommon.h"

#include "agendaeventviewer_p.h"

#include "agendaeventvieweritem.h"

#include "calendateutils.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "agendaeventviewTraces.h"

#endif

// Constants

#define CHARACTER_SPACE     " "

#define CHARACTER_HYPHEN    " - "

/*!

	\class AgendaEventView.

	Responsible for viewing viewing agenda entries. This is friend of

	AgendaEventViewerPrivate and it handles all the cases

	related to agenda entry viewing.

 */

/*!

	Default constructor.

	\param owner pointer to AgendaEventViewerPrivate.

	\param parent pointer to QGraphicsWidget.

 */

AgendaEventView::AgendaEventView(

		AgendaEventViewerPrivate *owner, QObject *parent):

		QObject(parent),

		mMainWindow(NULL),

		mOwner(owner),

		mTranslator(new HbTranslator("caleneventviewer")),

		mReminderWidgetAdded(true),

		mMaptilePath(NULL),

		mMaptileService(NULL),

		mProgressTimer(NULL),

		mProgressIconCount(0),

		mMaptileStatusReceived(false),

		mMaptileStatus(-1),

		mNotesPluginLoaded(false),

{

	OstTraceFunctionEntry0( AGENDAEVENTVIEW_AGENDAEVENTVIEW_ENTRY );

	mTranslator->loadCommon();

	mDocLoader = new AgendaEventViewerDocLoader;

	// Load to-do viewer's docml.

	bool loadSuccess;

	mDocLoader->load(AGENDA_EVENT_VIEWER_DOCML, &loadSuccess);

	if (!loadSuccess) {

		    qFatal("agendaeventview.cpp : Unable to load XML");

	}

	// Load the to-viewer's view.

	mViewer = qobject_cast<HbView *> (mDocLoader->findWidget(

			AGENDA_EVENT_VIEWER_VIEW_OBJECT));

	// Load all the widgets.

	mSubjectWidget = qobject_cast<AgendaEventViewerItem *> (

			mDocLoader->findWidget(AGENDA_EVENT_VIEWER_SUBJECT_WIDGET));

	mDateTimeWidget = qobject_cast<AgendaEventViewerItem *> (

			mDocLoader->findWidget(AGENDA_EVENT_VIEWER_DATE_TIME_WIDGET));

	mLocationWidget = qobject_cast<AgendaEventViewerItem *> (

			mDocLoader->findWidget(AGENDA_EVENT_VIEWER_LOCATION_WIDGET));

	mMaptileLabel = qobject_cast<HbLabel *> (

	                mDocLoader->findWidget(AGENDA_EVENT_VIEWER_MAPTILE_WIDGET));

	mReminderWidget = qobject_cast<AgendaEventViewerItem *> (

			mDocLoader->findWidget(AGENDA_EVENT_VIEWER_REMINDER_WIDGET));

	mRepeatWidget = qobject_cast<AgendaEventViewerItem *> (

			mDocLoader->findWidget(AGENDA_EVENT_VIEWER_REPEAT_WIDGET));

	mDescriptionWidget = qobject_cast<AgendaEventViewerItem *> (

			mDocLoader->findWidget(AGENDA_EVENT_VIEWER_DESCRIPTION_WIDGET));

    HbWidget *scrollAreaWidget = qobject_cast<HbWidget *>(

               mDocLoader->findWidget(AGENDA_EVENT_VIEWER_SCROLLAREA_CONTENTS));

    mLinearLayout = 

    		static_cast<QGraphicsLinearLayout *> (scrollAreaWidget->layout());

    //maptile service object , to retrive maptile path from database.

    mMaptileService= new MapTileService();   

    mLocationFeatureEnabled = mMaptileService->isLocationFeatureEnabled(

        MapTileService::AppTypeCalendar);

    if (mLocationFeatureEnabled) {

        //timer to run progress indicator icon.

        mProgressTimer = new QTimer(this);

        mProgressTimer->setSingleShot(true);

        connect(mProgressTimer, SIGNAL(timeout()), this, SLOT(updateProgressIndicator()));

    }

    OstTraceFunctionExit0( AGENDAEVENTVIEW_AGENDAEVENTVIEW_EXIT );

}

/*!

	Destructor.

 */

AgendaEventView::~AgendaEventView()

{

    OstTraceFunctionEntry0( DUP1_AGENDAEVENTVIEW_AGENDAEVENTVIEW_ENTRY );

	// Remove the translator

	if (mTranslator) {

		delete mTranslator;

		mTranslator = 0;

	}

	mDocLoader->reset();

	delete mDocLoader;

	// Unload notes editor if loaded.

	if (mNotesEditorPluginLoader) {

		mNotesEditorPluginLoader->unload();

		delete mNotesEditorPluginLoader;

		mNotesEditorPluginLoader = 0;

	}

	// Delete the mainwindow if we have created any

	if (mMainWindow) {

		delete mMainWindow;

		mMainWindow = NULL;

	}

	if (mMaptileService) {

        delete mMaptileService;

        mMaptileService = NULL;

    }

	if (mProgressTimer) {

        delete mProgressTimer;

        mProgressTimer = NULL;

    }

	OstTraceFunctionExit0( DUP1_AGENDAEVENTVIEW_AGENDAEVENTVIEW_EXIT );

}

/*!

	Displays the to-do viewer and populates the to-do entry attributes.

	\param entry Agenda entry from which attributes have to be read.

 */

void AgendaEventView::execute(AgendaEntry entry,

											AgendaEventViewer::Actions action)

{

    OstTraceFunctionEntry0( AGENDAEVENTVIEW_EXECUTE_ENTRY );

	mOriginalAgendaEntry = entry;

	mAgendaEntry = entry;

	// Add the viewer data reading from the agenda entry.

	addViewerData();

	// Remove unnecessary widget from event viewer.

	removeWidget();

	// Add the menu items to event viewer.

	addMenuItem();

	// Add the toolbar items to event viewer

	addToolBarItem(action);

	// Connect for the entry updation and addtion signal to refresh the view

	// when the same is edited in editor.

	connect(mOwner->mAgendaUtil, SIGNAL(entryUpdated(ulong)),

				this, SLOT(handleEntryUpdation(ulong)));

	connect(mOwner->mAgendaUtil, SIGNAL(entryAdded(ulong)),

				this, SLOT(handleEntryUpdation(ulong)));

	// Connect for entry deletion signal to close the event viewer.

	connect(mOwner->mAgendaUtil, SIGNAL(entryDeleted(ulong)), this,

	        SLOT(handleEntryDeletion(ulong)));

	// Add the view to the main window.

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

	if (!window) {

		// Might be some non-ui based app called us

		// so create mainwindow now

		mMainWindow = new HbMainWindow();

		mMainWindow->addView(mViewer);

		mMainWindow->setCurrentView(mViewer);

	} else {

		window->addView(mViewer);

		window->setCurrentView(mViewer);

	}

	// Add softkey after adding view on window

	mBackAction = new HbAction(Hb::BackNaviAction);

	mViewer->setNavigationAction(mBackAction);

	connect(mBackAction, SIGNAL(triggered()), this, SLOT(close()));

	OstTraceFunctionExit0( AGENDAEVENTVIEW_EXECUTE_EXIT );

}

/*!

	Refreshes the to-do viewer after the to-do editor is closed.

 */

void AgendaEventView::addViewerData()

{

	OstTraceFunctionEntry0( AGENDAEVENTVIEW_ADDVIEWERDATA_ENTRY );

	// Add the title to event viewer.

	addGroupBoxData();

	// Set the summary & priority to viewer.

	addSubjectAndPriorityData();

	// Set Date & Time to viewer.

	addDateTimeData();

	// Add agenda entry specific fields to the viewer

	switch (mAgendaEntry.type()) {

		case AgendaEntry::TypeAppoinment:

		case AgendaEntry::TypeEvent:

			addLocationData();

			addMapTileImage();	

			addReminderData();

			addRepeatData();

			break;

		case AgendaEntry::TypeAnniversary:

			break;

		case AgendaEntry::TypeTodo:

			if (AgendaEntry::TodoCompleted == mAgendaEntry.status()) { 

				addCompletedTodoData();

			} else {

				addReminderData();

			}

			break;

		default:

			break;

	}

	// Set the description.

	addDescriptionData();

	OstTraceFunctionExit0( AGENDAEVENTVIEW_ADDVIEWERDATA_EXIT );

}

/*!

	Add the menu item depends up on entry type

 */

void AgendaEventView::addMenuItem()

{

	OstTraceFunctionEntry0( AGENDAEVENTVIEW_ADDMENUITEM_ENTRY );

	if (mAgendaEntry.type() == AgendaEntry::TypeTodo) {

		HbMenu *menu = qobject_cast<HbMenu *> (

				mDocLoader->findWidget(AGENDA_EVENT_VIEWER_MENU));

		mMarkTodoAction = new HbAction(this);

		if (mAgendaEntry.status() == AgendaEntry::TodoCompleted) {

			mMarkTodoAction->setText(

								hbTrId("txt_calendar_menu_mark_as_not_done"));

		} else {

			mMarkTodoAction->setText(hbTrId("txt_calendar_menu_mark_as_done"));

		}

		connect(mMarkTodoAction, SIGNAL(triggered()), this,

		        SLOT(markTodoStatus()));

		menu->addAction(mMarkTodoAction);

	}

	OstTraceFunctionExit0( AGENDAEVENTVIEW_ADDMENUITEM_EXIT );

}

/*!

	Add the toolbar item

 */

void AgendaEventView::addToolBarItem(AgendaEventViewer::Actions action)

{

    OstTraceFunctionEntry0( AGENDAEVENTVIEW_ADDTOOLBARITEM_ENTRY );

	HbToolBar *toolBar = qobject_cast<HbToolBar *> (

	                       mDocLoader->findWidget(AGENDA_EVENT_VIEWER_TOOLBAR));

	// Load all the actions for event viewer

	if ((action == AgendaEventViewer::ActionEditDelete) || (action

	        == AgendaEventViewer::ActionEdit)) {

		HbAction *editAction = new HbAction();

		editAction->setIcon(HbIcon("qtg_mono_edit"));

		connect(editAction, SIGNAL(triggered()), this, SLOT(edit()));

		toolBar->addAction(editAction);

	}

	if ((action == AgendaEventViewer::ActionEditDelete) || (action

	        == AgendaEventViewer::ActionDelete)) {

		HbAction *deleteAction = new HbAction();

		deleteAction->setIcon(HbIcon("qtg_mono_delete"));

		connect(deleteAction, SIGNAL(triggered()), this,

		        SLOT(deleteAgendaEntry()));

		toolBar->addAction(deleteAction);

	}

	if (action == AgendaEventViewer::ActionSave) {

		HbAction *saveAction = new HbAction();

		saveAction->setIcon(HbIcon("qtg_mono_add_to_calendar"));

		connect(saveAction, SIGNAL(triggered()), this, SLOT(saveAgendaEntry()));

		toolBar->addAction(saveAction);

	}

	OstTraceFunctionExit0( AGENDAEVENTVIEW_ADDTOOLBARITEM_EXIT );

}

/*!

	Add the groupbox data depends up on entry type

 */

void AgendaEventView::addGroupBoxData()

{

	OstTraceFunctionEntry0( AGENDAEVENTVIEW_ADDGROUPBOXDATA_ENTRY );

	HbGroupBox *groupBox = qobject_cast<HbGroupBox *> (

			mDocLoader->findWidget(AGENDA_EVENT_VIEWER_GROUPBOX));

	AgendaEntry::Type entryType = mAgendaEntry.type();

	if (entryType == AgendaEntry::TypeTodo) {

		groupBox->setHeading(hbTrId("txt_calendar_subhead_to_do"));

	} else if (CalenAgendaUtils::isAlldayEvent(mAgendaEntry)) {

        groupBox->setHeading(hbTrId("txt_calendar_subhead_all_day_event"));

	} else if (entryType == AgendaEntry::TypeAppoinment) {

		groupBox->setHeading(hbTrId("txt_calendar_subhead_meeting"));

	} 

	OstTraceFunctionExit0( AGENDAEVENTVIEW_ADDGROUPBOXDATA_EXIT );

}

/*!

	Add subject and priority data to Event viewer

 */

void AgendaEventView::addSubjectAndPriorityData()

{

    OstTraceFunctionEntry0( AGENDAEVENTVIEW_ADDSUBJECTANDPRIORITYDATA_ENTRY );

	QStringList itemList;

	itemList.append(hbTrId("txt_calendar_dblist_subject"));

	if (mAgendaEntry.summary().isEmpty()) {

		itemList.append(hbTrId("txt_calendar_dblist_val_unnamed"));

	} else {

		itemList.append(mAgendaEntry.summary());

	}

	mSubjectWidget->setEventViewerItemData(itemList, Qt::DisplayRole);

    itemList.clear();

    QString priorityIcon(QString::null);

    QString subjectIcon(QString::null);

    getPriorityIcon(mAgendaEntry.priority(), priorityIcon);

    getSubjectIcon(mAgendaEntry.type(),subjectIcon);

    itemList.append(subjectIcon);

    itemList.append(priorityIcon);

    itemList.append(QString::null);

	mSubjectWidget->setEventViewerItemData(itemList, Qt::DecorationRole);

	OstTraceFunctionExit0( AGENDAEVENTVIEW_ADDSUBJECTANDPRIORITYDATA_EXIT );

}

/*!

	Add date & time data to Event viewer

 */

void AgendaEventView::addDateTimeData()

{

    OstTraceFunctionEntry0( AGENDAEVENTVIEW_ADDDATETIMEDATA_ENTRY );

    QStringList itemData;

    HbExtendedLocale systemLocale = HbExtendedLocale::system();

    QDateTime startDateTime = mAgendaEntry.startTime();

    QDateTime endDateTime = mAgendaEntry.endTime();

    itemData.append(QString::null);

    itemData.append(QString::null);

    itemData.append("qtg_small_calendar");

    mDateTimeWidget->setEventViewerItemData(itemData, Qt::DecorationRole);

    itemData.clear();

    itemData.append(QString::null);

    QString startTimeText;

    QString endTimeText;

    QString startDateText;

    QString dateTimeText;

    QString data;

    // Add agenda entry specific fields to the viewer

    switch (mAgendaEntry.type()) {

    	case AgendaEntry::TypeAppoinment:

    	case AgendaEntry::TypeEvent:

    	    // Check if entry is an all-day

    	    if (CalenAgendaUtils::isAlldayEvent(mAgendaEntry)) {

                dateTimeText.append(systemLocale.format(startDateTime.date(),

    	                                                        r_qtn_date_usual_with_zero));

                if (CalenDateUtils::onSameDay(startDateTime, endDateTime.addSecs(-60))) {

                    data.append(dateTimeText);

                } else {

                    QString endDate;

                    endDate.append(

                            systemLocale.format(endDateTime.addSecs(-60).date(),

                                                r_qtn_date_usual_with_zero));

                    data.append(dateTimeText);

                    data.append(" - ");

                    data.append(endDate);

                }

    	    } else {

                startTimeText.append(systemLocale.format(

                                startDateTime.time(), r_qtn_time_usual_with_zero));

                endTimeText.append(systemLocale.format(endDateTime.time(),

                                                    r_qtn_time_usual_with_zero));

                startDateText.append(

                        systemLocale.format(startDateTime.date(),

                                                    r_qtn_date_usual_with_zero));

                if (CalenDateUtils::onSameDay(startDateTime, endDateTime)) {

                    data.append(startTimeText);

                    data.append(CHARACTER_HYPHEN);

                    data.append(endTimeText);

                    data.append(CHARACTER_SPACE);

                    data.append(startDateText);

                } else {

                    // If both start and end time of a meeting are on different dates

                    data.append(startTimeText);

                    data.append(CHARACTER_SPACE);

                    data.append(startDateText);

                    QString endDateText;

                    endDateText.append(

                            systemLocale.format(endDateTime.date(),

                                                r_qtn_date_usual_with_zero));

                    data.append(CHARACTER_HYPHEN);

                    data.append(endTimeText);

                    data.append(CHARACTER_SPACE);

                    data.append(endDateText);

                }

    	    }

    		break;

    	case AgendaEntry::TypeAnniversary:

    	case AgendaEntry::TypeTodo:

    		dateTimeText.append(systemLocale.format(endDateTime.date(),

    											r_qtn_date_usual_with_zero));