/*

 * 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 CalenMonthGrid.

 *

 */

// System includes

#include <hbgridview.h>

#include <hbabstractviewitem.h>

#include <hbstyleloader.h>

#include <hbcolorscheme.h>

#include <hbpangesture.h>

#include <hbswipegesture.h>

#include <hbtapgesture.h>

#include <hbdeviceprofile.h>

#include <hbinstance.h>

// User includes

#include "calenmonthgrid.h"

#include "calengriditemprototype.h"

#include "calenmonthdata.h"

#include "calenmonthview.h"

#include "calendateutils.h"

#include "calencommon.h"

#include "calenconstants.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "calenmonthgridTraces.h"

#endif

// Constants

#define SCROLL_SPEEED 3000 

#define GRIDLINE_WIDTH 0.075 //units

#define MAX_PAN_DIRECTION_THRESHOLD 50

#define MIN_PAN_DIRECTION_THRESHOLD 20

/*!

 \class CalenMonthGrid

 Implements the month grid

 */

/*!

 Default constructor.

 */

CalenMonthGrid::CalenMonthGrid(QGraphicsItem *parent):

	HbGridView(parent),

	mModel(0),

	mDirection(invalid),

	mIsPanGesture(false),

	mIsAtomicScroll(true),

	mView(NULL),

	mCurrentRow(-100),

	mIsNonActiveDayFocused(false),

	mIgnoreItemActivated(false),

	mGridBorderColor(Qt::gray)

{

    OstTraceFunctionEntry0( CALENMONTHGRID_CALENMONTHGRID_ENTRY );

	setScrollDirections(Qt::Vertical);

	setRowCount(KNumOfVisibleRows);

	setColumnCount(KCalenDaysInWeek);

	setLongPressEnabled(false);

	setItemRecycling(false);

	setSelectionMode(HbGridView::NoSelection);

	setUniformItemSizes(true);

	setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

	setClampingStyle(HbScrollArea::StrictClamping);

	setEnabledAnimations(HbAbstractItemView::None);

	setFrictionEnabled(false);

	setFlag(QGraphicsItem::ItemHasNoContents, false);

	resetTransform();

	// Get the content widget of the scroll area to draw the grid lines

	mContentWidget = contentWidget();

	// Get the all required colors 

	// Color of the grid lines

	mGridLineColor = HbColorScheme::color("qtc_cal_grid_line");

	// Get the localised dates well before

	// TODO: Need to update the mLocalisedDates when user changes the

	// phone language keeping calendar application in background

	HbExtendedLocale locale = HbExtendedLocale::system();

	for (int i = 1; i <= 31; i++) {

		mLocalisedDates.append(locale.toString(i));

	}

	// Connect to scrolling finished signal

	connect(this, SIGNAL(scrollingEnded()), this,

			SLOT(scrollingFinished()));

	OstTraceFunctionExit0( CALENMONTHGRID_CALENMONTHGRID_EXIT );

}

/*!

 Destructor

 */

CalenMonthGrid::~CalenMonthGrid()

{

    OstTraceFunctionEntry0( DUP1_CALENMONTHGRID_CALENMONTHGRID_ENTRY );

	// Nothing Yet

    OstTraceFunctionExit0( DUP1_CALENMONTHGRID_CALENMONTHGRID_EXIT );

}

/*!

 Stores the view pointer

 */

void CalenMonthGrid::setView(CalenMonthView *view)

{

    OstTraceFunctionEntry0( CALENMONTHGRID_SETVIEW_ENTRY );

	mView = view;

	OstTraceFunctionExit0( CALENMONTHGRID_SETVIEW_EXIT );

}

/*!

 Updates the model with the proper dates and sets the required user roles

 */

void CalenMonthGrid::updateMonthGridModel(QList<CalenMonthData> &monthDataArray,

                        int indexToBeScrolled, bool isFirstTime)

{

    OstTraceFunctionEntry0( CALENMONTHGRID_UPDATEMONTHGRIDMODEL_ENTRY );

	int loopStart = 0;

	int loopEnd = monthDataArray.count();

	if (isFirstTime) {

		// Create the model with only 42 items as visible to the user

		mModel = new QStandardItemModel(KCalenDaysInWeek * KNumOfVisibleRows, 

		                                1, this);

		loopStart = (mView->rowsInPrevMonth()) * KCalenDaysInWeek;

		loopEnd = loopStart + (KCalenDaysInWeek * KNumOfVisibleRows);

	} else {

		// Block the signals generated by model, this is being done as

		// we want to avoid the overload of view listening to signals

		mModel->blockSignals(true);

		// Check the counts

		int dataCount = monthDataArray.count();

		int rowCount = mModel->rowCount();

		int countDiff = dataCount - rowCount;

		if (countDiff < 0) {

			// Delete extra rows in the model

			mModel->removeRows(dataCount,abs(countDiff));

		} else if (countDiff > 0) {

			// Add the necessary number of rows

			mModel->insertRows(rowCount,countDiff);

		}

		loopEnd = dataCount;

	}

	QDateTime currDate = mView->getCurrentDay();

	QDateTime currDateTime = CalenDateUtils::beginningOfDay(currDate);

	QDateTime activeDay = mView->getActiveDay();

	QDateTime activeDateTime = CalenDateUtils::beginningOfDay(activeDay);

	QModelIndex currentIndex;

	int modelIndex = 0;

	for (int i = loopStart; i < loopEnd; i++) {

		QDateTime dateTime = monthDataArray[i].Day();

		currentIndex = mModel->index(modelIndex++, 0);

		// Create the variant list to contain the date to depict a grid item

		QVariantList itemData;

		// !!!NOTE!!!: Add the data in the order mentioned in the 

		// CalendarNamespace::DataRole enum. Dont change the order.

		itemData << mLocalisedDates.at(dateTime.date().day()-1); 

		// Check for active day

		if (activeDateTime == CalenDateUtils::beginningOfDay(dateTime)) {

			mCurrentRow = i;

			// Set the focus attribute to true

			itemData << true;

		} else {

			// reset the highlight

			itemData << false;

		}

		// Check for current day

		if (currDateTime == CalenDateUtils::beginningOfDay(dateTime)) {

			// Set the underline attribute to true

			itemData << true;

		} else {			

			itemData << false;

		}

		// Check for events

		if (monthDataArray[i].HasEvents()) {

			// Set the event indicator attribute

			itemData << true;

		} else {

			itemData << false;

		}

		// Add default text color

		if (monthDataArray[i].isActive()) {

			itemData << true;

		} else {

			itemData << false;

		}

		mModel->itemFromIndex(currentIndex)->setData(itemData);

	}

	if (isFirstTime) {

		// Color of the today indicator

		QColor todayIndColor = HbColorScheme::color("qtc_cal_month_current_day");

		// Color of the active dates

		QColor mActiveTextColor = 

								HbColorScheme::color("qtc_cal_month_active_dates");

		// Color of the inactive dates

		QColor mInActiveTextColor = 

							HbColorScheme::color("qtc_cal_month_notactive_dates");

		// Create the prototype

		CalenGridItemPrototype* gridItemPrototype = new CalenGridItemPrototype(

						todayIndColor, mActiveTextColor, mInActiveTextColor, this);

		// Set the mode and the prototype

		setModel(mModel,gridItemPrototype);

		// Register the widgetml and css files

		HbStyleLoader::registerFilePath(":/");

		// Set the layout name

		setLayoutName("calendarCustomGridItem");

	} else {

		// Since, we have finished setData, Now unblock the signals

		mModel->blockSignals(false);

		// Since till now, we had blocked signals being generated frm the mode

		// view will be unaware of the items that we added. Hence, inform the view

		// explicitly in one shot

		QModelIndex leftIndex = mModel->index(0, 0);

		QModelIndex rightIndex = mModel->index(loopEnd-1, 0);

		dataChanged(leftIndex, rightIndex);

		// NOTE: To make sure that we always display proper month,

		// two calls have been  made to scrollTo(), one with top

		// visible item and other with bottom visible item

		// Calculate the first visible item in the grid

		QModelIndex firstVisibleIndex = mModel->index(indexToBeScrolled - 

								(KNumOfVisibleRows * KCalenDaysInWeek - 1), 0);

		scrollTo(firstVisibleIndex);

		// Calculate the last visible item in the grid

		QModelIndex lastVisibleIndex = mModel->index(indexToBeScrolled, 0);

		scrollTo(lastVisibleIndex);

	}

	OstTraceFunctionExit0( CALENMONTHGRID_UPDATEMONTHGRIDMODEL_EXIT );

}

/*!

	Updates the view with jprevious month dates when calendar is opened for the 

	first time to improve the opening time

 */

void CalenMonthGrid::updateMonthGridWithInActiveMonths(

										QList<CalenMonthData> &monthDataArray)

{	

    OstTraceFunctionEntry0( CALENMONTHGRID_UPDATEMONTHGRIDWITHINACTIVEMONTHS_ENTRY );

	// Prepend the required rows

	handlePrependingRows(monthDataArray);

	// Append the required rows

	handleAppendingRows(monthDataArray);

	int rowsInPrevMonth = mView->rowsInPrevMonth();

	// Calculate the proper index to be scrolled to

	int itemToBeScrolled = rowsInPrevMonth * KCalenDaysInWeek;

	QModelIndex indexToBeScrolled = mModel->index(itemToBeScrolled, 0);

	mIsAtomicScroll = true;

	scrollTo(indexToBeScrolled);

	// Scroll to proper index

	itemToBeScrolled = ((rowsInPrevMonth + KNumOfVisibleRows) * 

								   KCalenDaysInWeek) - 1;

	indexToBeScrolled = mModel->index(itemToBeScrolled, 0);

	mIsAtomicScroll = true;

	scrollTo(indexToBeScrolled);

	// Update the sart position of the content widget

	mStartPos = mContentWidget->pos();

	// Now connect to the signal which gets emitted when any item on the grid 

	// is tapped.

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

						SLOT(itemActivated(const QModelIndex &)));

	OstTraceFunctionExit0( CALENMONTHGRID_UPDATEMONTHGRIDWITHINACTIVEMONTHS_EXIT );

}

/*!

	Updates the view with just event indicators

 */

void CalenMonthGrid::updateMonthGridWithEventIndicators(

										QList<CalenMonthData> &monthDataArray)

{

    OstTraceFunctionEntry0( CALENMONTHGRID_UPDATEMONTHGRIDWITHEVENTINDICATORS_ENTRY );

	int count(monthDataArray.count());

	for(int i = 0; i < count; i++) {

		// Check if the day has events

		if (monthDataArray[i].HasEvents()) {

			QModelIndex itemIndex = mModel->index(i,0);

			QVariant itemData = itemIndex.data(Qt::UserRole + 1);

			QVariantList list = itemData.toList();

			list.replace(CalendarNamespace::CalendarMonthEventRole, true);

			mModel->itemFromIndex(itemIndex)->setData(list);

		}

	}

	OstTraceFunctionExit0( CALENMONTHGRID_UPDATEMONTHGRIDWITHEVENTINDICATORS_EXIT );

}

/*!

 Scrolls the content dowmwards

 */

void CalenMonthGrid::downGesture()

{

    OstTraceFunctionEntry0( CALENMONTHGRID_DOWNGESTURE_ENTRY );

    // Make sure that content widget is properly placed

    if (mIsNonActiveDayFocused) {

        mIsAtomicScroll = true;

        int itemToBeScrolled = mView->rowsInPrevMonth() * KCalenDaysInWeek;

        QModelIndex indexToBeScrolled  = mModel->index(itemToBeScrolled, 0);

        scrollTo(indexToBeScrolled);

    }

    mDirection = down;

    mIsAtomicScroll = false;

    setAttribute(Hb::InteractionDisabled);

    QPointF targetPos(0.0, 0.0);

    scrollContentsTo(targetPos,500);

    OstTraceFunctionExit0( CALENMONTHGRID_DOWNGESTURE_EXIT );

}

/*!

 Scrolls the content upwards

 */

void CalenMonthGrid::upGesture()

{

    OstTraceFunctionEntry0( CALENMONTHGRID_UPGESTURE_ENTRY );

    // Make sure that content widget is properly placed

    if (mIsNonActiveDayFocused) {

        mIsAtomicScroll = true;

        int itemToBeScrolled = mView->rowsInPrevMonth() * KCalenDaysInWeek;

        itemToBeScrolled += KNumOfVisibleRows * KCalenDaysInWeek;

        QModelIndex indexToBeScrolled  = mModel->index(itemToBeScrolled, 0);

        scrollTo(indexToBeScrolled);

    }

    mDirection = up;

    mIsAtomicScroll = false;

    setAttribute(Hb::InteractionDisabled);

    QPointF targetPos(0.0, mStartPos.y() - size().height());

    scrollContentsTo(-targetPos,500);

    OstTraceFunctionExit0( CALENMONTHGRID_UPGESTURE_EXIT );

}

/*!

 Function to listen mouse press events

 */

void CalenMonthGrid::mousePressEvent(QGraphicsSceneMouseEvent* event)

{

    OstTraceFunctionEntry0( CALENMONTHGRID_MOUSEPRESSEVENT_ENTRY );

	// Pass it to parent

	HbGridView::mousePressEvent(event);

	OstTraceFunctionExit0( CALENMONTHGRID_MOUSEPRESSEVENT_EXIT );

}

/*!

 Function to listen mouse release events

 */

void CalenMonthGrid::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)

{

    OstTraceFunctionEntry0( CALENMONTHGRID_MOUSERELEASEEVENT_ENTRY );

	// Pass it grid view if pan gesture is not in progress else pass it to

	// scrollarea. Problem here is, if we pass to gridview when panning, then 

	// its emitting item activated signal simply becasue of which focus item

	// is getting changed when you finish the pan / shake

	if (!mIsPanGesture) {

		HbGridView::mouseReleaseEvent(event);

	} else {

		HbScrollArea::mouseReleaseEvent(event);

	}

	OstTraceFunctionExit0( CALENMONTHGRID_MOUSERELEASEEVENT_EXIT );

}

/*!

    Function to list for all the gesture events

 */

void CalenMonthGrid::gestureEvent(QGestureEvent *event)

{

    OstTraceFunctionEntry0( CALENMONTHGRID_GESTUREEVENT_ENTRY );

   if(HbPanGesture *gesture = qobject_cast<HbPanGesture *>(event->gesture(Qt::PanGesture))) {

        if (gesture->state() == Qt::GestureStarted) {

            setAttribute(Hb::InteractionDisabled);

            mIsAtomicScroll = false;

            if (!mIsPanGesture) {

                mDirection = invalid;

                mStartPos = mContentWidget->pos();

                // TODO: This work aroung till framework provides an api

                // to know the direciton of the pan, until then we need

                // calculate the direction explicitly

                // Get to know the direction of the gesture

                // Use our defined threshold temporarily till scrollarea 

                // frm orbit side is made clever enough not to scroll in other direction

                // apart frm the registered scroll direction

                QPointF delta = gesture->delta();

                // Check the current orientation of the device and

                // swap the vertical and horizontal distances in landscape

                qreal horizontalDiff = 0.0;

                qreal verticalDiff = 0.0;

                if (hbInstance->allMainWindows().at(0)->orientation() == Qt::Vertical) {

                    horizontalDiff = delta.x();

                    verticalDiff = delta.y();

                } else {

                    horizontalDiff = delta.y();

                    verticalDiff = delta.x();

                }

                if (abs(horizontalDiff) > MAX_PAN_DIRECTION_THRESHOLD) {

                    // Now see if y coord diff has crossed threshold

                    if (verticalDiff > MAX_PAN_DIRECTION_THRESHOLD) {

                        mIsPanGesture = true;

                        mIgnoreItemActivated = true;

                        mDirection = down;

                    } else if (verticalDiff < -MAX_PAN_DIRECTION_THRESHOLD){

                        mIsPanGesture = true;

                        mIgnoreItemActivated = true;

                        mDirection = up;

                    } else {

                        event->accept(Qt::PanGesture);

                        OstTraceFunctionExit0( CALENMONTHGRID_GESTUREEVENT_EXIT );

                        return;

                    }

                } else if (abs(horizontalDiff) < MAX_PAN_DIRECTION_THRESHOLD) {

                   if (verticalDiff > MIN_PAN_DIRECTION_THRESHOLD) {

                        mIsPanGesture = true;

                        mIgnoreItemActivated = true;

                        mDirection = down;

                   } else if (verticalDiff < -MIN_PAN_DIRECTION_THRESHOLD){

                        mIsPanGesture = true;

                        mIgnoreItemActivated = true;

                        mDirection = up;

                   }else {

                       event->accept(Qt::PanGesture);

                       OstTraceFunctionExit0( DUP1_CALENMONTHGRID_GESTUREEVENT_EXIT );

                       return;

                   }

                } 

            }

        }

    } else if(HbSwipeGesture *gesture = qobject_cast<HbSwipeGesture *>(event->gesture(Qt::SwipeGesture))) {

        if (gesture->state() == Qt::GestureStarted) {

            setAttribute(Hb::InteractionDisabled);

            mIsAtomicScroll = false;

            mDirection = invalid;

            if (gesture->sceneVerticalDirection() == QSwipeGesture::Down) {

                mDirection = down;