/*

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

*

*/

// System includes

#include <QStandardItemModel>

#include <QGraphicsSceneEvent>

#include <QDir>

#include <QPluginLoader>

#include <hbi18ndef.h>

#include <hbextendedlocale.h>

#include <hbgroupbox.h>

#include <hbmenu.h>

#include <hbaction.h>

#include <hbmainwindow.h>

#include <hbstyleloader.h>

#include <hbdatetimepicker.h>

#include <hbdialog.h>

#include <xqsettingsmanager.h>

#include <agendautil.h>

#include <NotesEditorInterface>

// User includes

#include "calenagendaviewwidget.h"

#include "calencommon.h"

#include "calenagendaview.h"

#include "calendocloader.h"

#include "calenservices.h"

#include "calencontext.h"

#include "calendateutils.h"

#include "calenagendautils.h"

#include "CalenUid.h"

#include "caleneventlistviewitem.h"

#include "calenpluginlabel.h"

#include "calendarprivatecrkeys.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "calenagendaviewwidgetTraces.h"

#endif

// Constants

const QString singleSpace(" ");

const QString doubleSpace("  ");

const QString space("              ");

const QString singleHyphen("-");

const QString customLayout("custom");

const char *stretchLayout("stretchItem");

const QString toDoIcon("qtg_small_todo");

const QString reminderIcon("qtg_mono_alarm");

const QString locationIcon("qtg_mono_location");

const QString repeatIcon("qtg_mono_repeat");

// TODO: Replace with actual image name once its available

const QString allDayIcon("qtg_small_day");

const QString exceptionIcon("qtg_mono_repeat_exception");

const int singleColumn(1);

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::CalenAgendaViewWidget

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//

EXPORT_C CalenAgendaViewWidget::CalenAgendaViewWidget(MCalenServices &services,

                                       CalenDocLoader *docLoader) :

mServices(services),

mDocLoader(docLoader),

mRegionalInfoGroupBox(NULL),

mLongTapEventFlag(false),

mNotesPluginLoaded(false),

mIndex(0),

mIconCheck(false)

{

    OstTraceFunctionEntry0( CALENAGENDAVIEWWIDGET_CALENAGENDAVIEWWIDGET_ENTRY );

    // Construct the list view prototype

    mListViewPrototype = new CalenEventListViewItem(this);

    // Create the list model

    mListModel = new QStandardItemModel(this);

    // Register the custom docml and css to provide our own style to the list items

    HbStyleLoader::registerFilePath(":/");

    //Create the setting manager

    mSettingsManager = new XQSettingsManager(this);

    OstTraceFunctionExit0( CALENAGENDAVIEWWIDGET_CALENAGENDAVIEWWIDGET_EXIT );

}

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::~CalenAgendaViewWidget

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//    

EXPORT_C CalenAgendaViewWidget::~CalenAgendaViewWidget()

{

    OstTraceFunctionEntry0( DUP1_CALENAGENDAVIEWWIDGET_CALENAGENDAVIEWWIDGET_ENTRY );

	// Unload notes editor if loaded.

	if (mNotesEditorPluginLoader) {

		mNotesEditorPluginLoader->unload();

		delete mNotesEditorPluginLoader;

		mNotesEditorPluginLoader = 0;

	}

    if (mSettingsManager) {

    	delete mSettingsManager;

    	mSettingsManager = NULL;

    }

    OstTraceFunctionExit0( DUP1_CALENAGENDAVIEWWIDGET_CALENAGENDAVIEWWIDGET_EXIT );

}

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::setupWidget

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//    

void CalenAgendaViewWidget::setupWidget(CalenAgendaView *view)

{

    OstTraceFunctionEntry0( CALENAGENDAVIEWWIDGET_SETUPWIDGET_ENTRY );

    // Store the view for future reference

	mView = view;

	if (!mDocLoader) {

	    // Nothing much can be done. Simply return

	    OstTraceFunctionExit0( CALENAGENDAVIEWWIDGET_SETUPWIDGET_EXIT );

	    return;

	}

	// Initialize the child widgets

	initChildWidgets();

	OstTraceFunctionExit0( DUP1_CALENAGENDAVIEWWIDGET_SETUPWIDGET_EXIT );

}

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::showWidget

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//

void CalenAgendaViewWidget::showWidget()

{

    OstTraceFunctionEntry0( CALENAGENDAVIEWWIDGET_SHOWWIDGET_ENTRY );

    // Get the date for which this view has been launched

    mDate = mServices.Context().focusDateAndTime();

    // Set the heading text

    setHeadingText();

    // Get the instance list

    getInstanceList();

    // Check if regional information needs to be shown

    // and add it or remove it

    showHideRegionalInformation();

    // Load the appropriate section based on the number of events for the day

    if (0 == mInstanceArray.count()) {

        // There are no entries for the day

        // Load and show the empty list section

        bool loadSuccess = false;

        // Hide the list which shows the events

        mEventsList->hide();

        // Show the empty list text

        mEmptyListLabel->show();

        // Get the current device orientation

        int orientation = mServices.MainWindow().orientation();

        if (Qt::Vertical == orientation) {

            mDocLoader->load(CALEN_AGENDAVIEW_XML_FILE, "emptyList", &loadSuccess);

        } else {

            mDocLoader->load(CALEN_AGENDAVIEW_XML_FILE, "emptyLandscape", &loadSuccess);

        }

        if (!loadSuccess) {

            qFatal("calenagendaviewwidget.cpp : Unable to load empty list section");

        }

    } else {

        // Hide the empty view label

        mEmptyListLabel->hide();

        // Show the events list

        mEventsList->show();

        // There are one or more events. Load the non-empty section

        bool loadSuccess = false;

        mDocLoader->load(CALEN_AGENDAVIEW_XML_FILE, "nonEmptyList", &loadSuccess);

        if (!loadSuccess) {

            qFatal("calenagendaviewwidget.cpp : Unable to load non-empty list section");

        }

        // Now populate the list with the events

        populateListWidget();

    }

    OstTraceFunctionExit0( CALENAGENDAVIEWWIDGET_SHOWWIDGET_EXIT );

}

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::orientationChanged

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//

void CalenAgendaViewWidget::orientationChanged(Qt::Orientation orientation)

{

    OstTraceFunctionEntry0( CALENAGENDAVIEWWIDGET_ORIENTATIONCHANGED_ENTRY );

    // Load the appropriate section based on the number of events for the day

    if (0 == mInstanceArray.count()) {

        // There are no entries for the day

        // Load and show the empty list section

        bool loadSuccess = false;

        // Hide the list which shows the events

        mEventsList->hide();

        // Show the empty list text

        mEmptyListLabel->show();

        if (Qt::Vertical == orientation) {

            mDocLoader->load(CALEN_AGENDAVIEW_XML_FILE, "emptyList", &loadSuccess);

        } else {

            mDocLoader->load(CALEN_AGENDAVIEW_XML_FILE, "emptyLandscape", &loadSuccess);

        }

        if (!loadSuccess) {

            qFatal("calenagendaviewwidget.cpp : Unable to load empty list section");

        }

    } else {

        // Hide the empty view label

        mEmptyListLabel->hide();

        // Show the events list

        mEventsList->show();

        // There are one or more events. Load the non-empty section

        bool loadSuccess = false;

        mDocLoader->load(CALEN_AGENDAVIEW_XML_FILE, "nonEmptyList", &loadSuccess);

        if (!loadSuccess) {

            qFatal("calenagendaviewwidget.cpp : Unable to load non-empty list section");

        }

        handleListItemStretching(orientation);

    }

    OstTraceFunctionExit0( CALENAGENDAVIEWWIDGET_ORIENTATIONCHANGED_EXIT );

}

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::handleLocaleChange

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//

void CalenAgendaViewWidget::handleLocaleChange()

{

    OstTraceFunctionEntry0( CALENAGENDAVIEWWIDGET_HANDLELOCALECHANGE_ENTRY );

    OstTraceFunctionExit0( CALENAGENDAVIEWWIDGET_HANDLELOCALECHANGE_EXIT );

}

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::setContextFromHighlight

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//    

void CalenAgendaViewWidget::setContextFromHighlight(AgendaEntry entry)

{

    OstTraceFunctionEntry0( CALENAGENDAVIEWWIDGET_SETCONTEXTFROMHIGHLIGHT_ENTRY );

    if (entry.isTimedEntry()) {

        // Timed entry.

        QDateTime start = entry.startTime();

        // start.setDate(mDate.date());

        mServices.Context().setFocusDateAndTimeAndInstance(start,

                                                            TCalenInstanceId::create(entry));

    } else {

        // Untimed entry.

        if (CalenDateUtils::onSameDay(TCalenInstanceId::create(entry).mInstanceTime,

                                      mDate)) {

            mServices.Context().setInstanceId(TCalenInstanceId::create(entry));

        } else {

            // Multi-day untimed note (either multi-day day note or weird todo).

            // Focus on the instance and set the focus time to the highlighted day.

            mServices.Context().setFocusDateAndTimeAndInstance(mDate,

                                                                TCalenInstanceId::create(entry));

        }

    }

    OstTraceFunctionExit0( CALENAGENDAVIEWWIDGET_SETCONTEXTFROMHIGHLIGHT_EXIT );

}

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::initChildWidgets

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//

void CalenAgendaViewWidget::initChildWidgets()

{

    OstTraceFunctionEntry0( CALENAGENDAVIEWWIDGET_INITCHILDWIDGETS_ENTRY );

    // Get the pointer to the events list

    mEventsList = static_cast<HbListView*> (mDocLoader->findWidget(CALEN_AGENDAVIEW_LISTWIDGET));

    if (!mEventsList) {

        qFatal("calenagendaviewwidget.cpp : Unable to find the events list");

    }

    // NOTE: Layout name MUST be same as the name mentioned in the css

    mEventsList->setLayoutName(customLayout);

    // TODO : remove this line after gestures are available

    mEventsList->installEventFilter(mView);

    // Connect to the long press and activation signals

    connect(mEventsList, SIGNAL(longPressed(HbAbstractViewItem*, const QPointF&)),

            this, SLOT(itemLongPressed(HbAbstractViewItem*, const QPointF&)));

    connect(mEventsList, SIGNAL(activated(const QModelIndex&)), this,

            SLOT(itemActivated(const QModelIndex&)));

    // Get the pointer to label from the loader.

    mHeadingLabel = qobject_cast<HbGroupBox*> (mDocLoader->findWidget(CALEN_AGENDAVIEW_HEADING));

    if (!mHeadingLabel) {

        qFatal("calenagendaviewwidget.cpp : Unable to find heading widget");

    }

    // Get the pointer to the empty view label

    mEmptyListLabel = qobject_cast<HbLabel*> (mDocLoader->findWidget("noEventsLabel"));

    if (!mEmptyListLabel) {

        qFatal("calenagendaviewwidget.cpp : Unable to find empty list label");

    }

    HbWidget *headingPluginWidget = 

    		qobject_cast<HbWidget*> (mDocLoader->findWidget(CALEN_AGENDAVIEW_HEADING_REGIONALPLUGIN_WIDGET));

    mRegionalPluginLayout = static_cast<QGraphicsLinearLayout*>(headingPluginWidget->layout());

    OstTraceFunctionExit0( CALENAGENDAVIEWWIDGET_INITCHILDWIDGETS_EXIT );

}

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::populateListWidget

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//    

void CalenAgendaViewWidget::populateListWidget()

{

    OstTraceFunctionEntry0( CALENAGENDAVIEWWIDGET_POPULATELISTWIDGET_ENTRY );

    // Recycle the list items so that only needed rows

    // are added or removed

    if (mInstanceArray.count() == 0) {

        // Reset the list

        mEventsList->reset();

        // Clear the model to ensure it does not have any old items

        mListModel->clear();

        OstTraceFunctionExit0( CALENAGENDAVIEWWIDGET_POPULATELISTWIDGET_EXIT );

        return;

    } else if (mInstanceArray.count() > mListModel->rowCount()) {

        // There are more events than the number of items

        // in the list. Add more rows

        mListModel->insertRows(0, mInstanceArray.count() - mListModel->rowCount());

    } else if (mInstanceArray.count() < mListModel->rowCount()) {

        // There are less number of events than the number

        // of items in the list. Remove the extra rows

        mListModel->removeRows(0, mListModel->rowCount() - mInstanceArray.count());

    }

    //to set the index to first item of the list , when view refresh

    mIndex = 0; 

    //status reset for not setting any property

    mIconCheck = false;

    mListModel->setColumnCount(singleColumn);

    mIconCheck = true;

    // Add all the events to the list

    for (int index = 0; index < mInstanceArray.count(); index++) {

        // Get each of the entry details

        AgendaEntry entry = mInstanceArray[index];

        // Create a list item for each entry

        createListItem(index, entry);

    }

    // Add the item on to the list widget

    mEventsList->setModel(mListModel, mListViewPrototype);

    // Now get the item to scroll to

    int scrollToIndex = getIndexToScrollTo();

    if (mListModel->rowCount() > 0) {

        // Scroll to the index only if index is valid

        mEventsList->scrollTo(mListModel->index(scrollToIndex, 0));

    }

    OstTraceFunctionExit0( DUP1_CALENAGENDAVIEWWIDGET_POPULATELISTWIDGET_EXIT );

}

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::getInstanceList

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//    

void CalenAgendaViewWidget::getInstanceList()

{

    OstTraceFunctionEntry0( CALENAGENDAVIEWWIDGET_GETINSTANCELIST_ENTRY );

    // Clear the previous instance list

    mInstanceArray.clear();

    // Check if the date is valid

    if (!CalenDateUtils::isValidDay(mDate)) {

        mDate = CalenDateUtils::today();

    }

    // Set the filter flags to fetch all relevant entries

    AgendaUtil::FilterFlags filter = AgendaUtil::FilterFlags(AgendaUtil::IncludeAnniversaries |

                                                             AgendaUtil::IncludeAppointments | 

                                                             AgendaUtil::IncludeEvents |

                                                             AgendaUtil::IncludeReminders |

                                                             AgendaUtil::IncludeIncompletedTodos);

    // Fetch the instance list from the agenda interface

    mInstanceArray = mServices.agendaInterface()->createEntryIdListForDay(mDate, filter);

    OstTraceFunctionExit0( CALENAGENDAVIEWWIDGET_GETINSTANCELIST_EXIT );

}

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::setDateToLabel

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//

void CalenAgendaViewWidget::setHeadingText()

    {

    OstTraceFunctionEntry0( CALENAGENDAVIEWWIDGET_SETHEADINGTEXT_ENTRY );

    // Format the date as per the device locale settings

	HbExtendedLocale systemLocale = HbExtendedLocale::system();

	// Get localised name of the day from locale

	QString dayString = systemLocale.dayName(mDate.date().dayOfWeek());

	// Append a single space

	dayString.append(singleSpace);

	// Set the heading

	// Append the date which is formatted as per the locale

	mHeadingLabel->setHeading(hbTrId(

				"txt_calendar_subhead_1_2").arg(dayString).arg(

				systemLocale.format(mDate.date(), r_qtn_date_usual_with_zero)));

	OstTraceFunctionExit0( CALENAGENDAVIEWWIDGET_SETHEADINGTEXT_EXIT );

}

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::createListItem

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//

void CalenAgendaViewWidget::createListItem(int index, AgendaEntry entry)

{

    OstTraceFunctionEntry0( CALENAGENDAVIEWWIDGET_CREATELISTITEM_ENTRY );

    if (index < 0 || entry.isNull()) {

        // Not a valid index or entry. Dont do anything

        OstTraceFunctionExit0( CALENAGENDAVIEWWIDGET_CREATELISTITEM_EXIT );

        return;

    }

    // Check if the entry is a timed entry and not all day event

    // an all-day event when it is synched from OUTLOOK then entry type will be EAppt

    if (!CalenAgendaUtils::isAlldayEvent(entry) && entry.isTimedEntry()) {

        // Get the text and icon data for the entry

        addTimedEventToList(index, entry);

    } else {

        addNonTimedEventToList(index, entry);

    }

    OstTraceFunctionExit0( DUP1_CALENAGENDAVIEWWIDGET_CREATELISTITEM_EXIT );

}

// ----------------------------------------------------------------------------

// CalenAgendaViewWidget::addTimedEventToList

// Rest of the details are commented in the header

// ----------------------------------------------------------------------------

//

void CalenAgendaViewWidget::addTimedEventToList(int index, AgendaEntry entry)

{

    OstTraceFunctionEntry0( CALENAGENDAVIEWWIDGET_ADDTIMEDEVENTTOLIST_ENTRY );

    // Create text and icon list to set to the model

    QVariantList textData;

    QVariantList iconData;

    bool twoLines = false;

    /**

     * IMPORTANT NOTE: All the text and icon items must be

     * inserted into the variant list in a specific order.

     * If not, chaos will set it!!!

     * On a more serious note, the mesh layout depends on the

     * fact that the icons and text data will be added in a

     * particular order. If one of the items go missing, the

     * layout might get messed up. Also in case a particular item

     * is not required to be added in the middle of the list, an

     * empty QVariant must be added to indicate to the list view

     * that the item must be removed from the layout.

     * Do not mess with the order in case you are not sure what

     * you are exactly doing.

     */

    // The first icon to show to-do or all day should not be shown

    // Append empty data to the icons list

    iconData << QVariant();

    // Check if alarm is enabled for the entry       

    if (entry.alarm().isNull()) {

        // Insert a blank icon. Else the next icon