/*

* 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: Homescreen calendar widget's content layout handler.

*

*/

// System includes

#include <HbColorScheme>

#include <QDateTime>

#include <HbLabel>

#include <HbDocumentLoader>

#include <HbCore>

#include <HbFrameDrawer>

#include <HbFrameItem>

#include <QTimer>

#ifndef TEST

#include <agendautil.h>

#else

#include "mockagendautil.h"

#endif

#include <agendaentry.h>

#include <xqsettingsmanager.h>

#include <xqsettingskey.h>

#include <calnotification.h>

#include <QGraphicsLayout>

#include <QPointF>

#include <xqaiwrequest.h>

#include <xqappmgr.h>

#include <QCoreApplication>

// User includes

#include "contentlayouthandler.h"

#include "calendarwidgetdebug.h"

#include "datetimeobserver.h"

// Local constants

namespace {

    const HbFrameDrawer::FrameType REMINDER_FRAME_TYPE = HbFrameDrawer::OnePiece;

    const char *CONTENT_CONTAINER = "contentContainer";

    const char *UPPER_LABEL_SHORT = "upperLabelShort";

    const char *UPPER_LABEL_LONG = "upperLabelLong";

    const char *MIDDLE_LABEL = "middleLabel";

    const char *LOWER_LABEL = "lowerLabel";

    const char *REMINDER_ICON_LABEL = "reminderLabel";

    const char *REMINDER_IMAGE_NAME = "qtg_small_reminder";

    const char *HIGHLIGHT_IMAGE_NAME = "qtg_fr_hsitems_pressed";

    //same color applies to upper and middle labels

    const char *UPPER_LABEL_COLOR = "qtc_hs_list_item_title_normal";

    const char *LOWER_LABEL_COLOR = "qtc_hs_list_item_content_normal";

    const char *HIGHLIGHT_LABEL_COLOR = "qtc_hs_list_item_pressed";

    // time constants

    const int KHalfHour = 30;

    const int KSecondInMillisec = 1000;

    const int KSecondsInMinute = 60;

    const int KToday = 1;

    const int KComingDays = 0;

    const int KDaysInWeek = 7;

    const int KHourMinuteSeparatorIndex = 1;

    const int KPassedEventTimeoutSecs = 1800; // Half hour

    //from DateIconLayoutHandler

    const HbFrameDrawer::FrameType DATE_ICON_BACKGROUND_FRAME_TYPE = HbFrameDrawer::OnePiece;

    const char *ICON_CONTAINER = "iconContainer";

    const char *DATE_ICON_LABEL = "iconLabel";

    const char *DATE_ICON_DAYNUMBER = "dayNumber";

    const char *DATE_ICON_MONTHLABEL = "month";

    const char *DATE_ICON_HIGHLIGHTLABEL = "iconHighlight";

    const char *NUMBER_LABEL_COLOR = "qtc_hs_cal";

    const char *MONTH_LABEL_COLOR = "qtc_hs_list_item_title_normal";

    //const char *HIGHLIGHT_LABEL_COLOR = "qtc_hs_list_item_pressed";

    const char *DATE_BACKGROUND = "qtg_large_calendar_dynamic";

    //const char *HIGHLIGHT_IMAGE_NAME = "qtg_fr_hsitems_pressed";

    //From MainLayoutHandler

    const char WIDGET[] = "CalendarWidget";

    const char *BACKGROUND_LABEL = "widgetBackground";

    const char *SEPARATOR_LABEL = "separatorLabel";

    const char *SEPARATOR_IMAGE_NAME = "qtg_graf_divider_v_thin";

    const char *BACKGROUND_IMAGE_NAME = "qtg_fr_hswidget_normal";

    const HbFrameDrawer::FrameType BACKGROUND_FRAME_TYPE = HbFrameDrawer::NinePieces;

    const HbFrameDrawer::FrameType SEPARATOR_FRAME_TYPE = HbFrameDrawer::OnePiece;

}

// ======== MEMBER FUNCTIONS ========

/*

 * ContentLayoutHandler::ContentLayoutHandler()

 */

ContentLayoutHandler::ContentLayoutHandler()

        : mContainer(0),

          mReminderLabel(0),

          mUpperLabelShort(0),

          mUpperLabelLong(0),

          mMiddleLabel(0),

          mLowerLabel(0),

          mIconContainer(0),

          mIconLabel(0),

          mNumberLabel(0),

          mMonthLabel(0),

          mHighlightLabel(0),

          mDateIconFrameDrawer(0),

          mReminderDrawer(0),

          mEventTimer(0),

          mAgendaUtil(0),

          mCalendarKeyManager(0),

          mDateHighlightActive(0),

          mContentHighlightActive(0)

{

    LOGS("ContentLayoutHandler::ContentLayoutHandler");

    mCalendarKeyManager = new XQSettingsManager();

    unsigned long int key = (unsigned long int)ECalPubSubEventNotification;

    XQSettingsKey calendarKey(XQSettingsKey::TargetPublishAndSubscribe,

        KCalPubSubCategory.iUid, key);

    mCalendarKeyManager->startMonitoring(calendarKey);

    connect(mCalendarKeyManager, SIGNAL(valueChanged(XQSettingsKey, QVariant)),

        this, SLOT(calendarChanged(XQSettingsKey, QVariant)));

}

/*

 * ContentLayoutHandler::~ContentLayoutHandler()

 */

ContentLayoutHandler::~ContentLayoutHandler()

{

    LOGS("ContentLayoutHandler::~ContentLayoutHandler");

    unsigned long int key = (unsigned long int)ECalPubSubEventNotification;

    XQSettingsKey calendarKey(XQSettingsKey::TargetPublishAndSubscribe,

        KCalPubSubCategory.iUid, key);

    mCalendarKeyManager->stopMonitoring(calendarKey);

    delete mCalendarKeyManager;

}

/*

 * ContentLayoutHandler::initializeLayout()

 */

void ContentLayoutHandler::initializeLayout(const HbDocumentLoader &layoutLoader,

    QObject *owner)

{

    this->setParent(owner);

    this->setObjectName("contentlayouthandler");

    //From MainLayoutHandler

    mWidget = (HbWidget*)layoutLoader.findWidget(WIDGET);

    mBgLabel = qobject_cast<HbLabel*>(layoutLoader.findWidget(BACKGROUND_LABEL));

    mSeparatorLabel = qobject_cast<HbLabel*>(layoutLoader.findWidget(QString(SEPARATOR_LABEL)));

    // Discontinue initialization of the main widget is missing

    if (!mWidget) {

        return;

    }

    addItem(mWidget);

    mWidget->setVisible(true);

    // Create main background drawer

    if (mBgLabel) {

        HbFrameDrawer* backgroundFrameDrawer = new HbFrameDrawer(BACKGROUND_IMAGE_NAME,

            BACKGROUND_FRAME_TYPE);

        mBackgroundLayoutItem = new HbFrameItem(backgroundFrameDrawer);

        mBgLabel->setBackgroundItem(mBackgroundLayoutItem);

    }

    // Create separator graphics drawer

    HbFrameDrawer* separatorFrameDrawer = new HbFrameDrawer(SEPARATOR_IMAGE_NAME,

        SEPARATOR_FRAME_TYPE);

    mSeparatorLayoutItem = new HbFrameItem(separatorFrameDrawer);

    mSeparatorLabel->setBackgroundItem(mSeparatorLayoutItem);

    setPreferredSize(mWidget->preferredSize());

    //END

    //From DateIconLayoutHandler

    mIconContainer = qobject_cast<HbWidget*>(layoutLoader.findWidget(QString(ICON_CONTAINER)));

    mIconLabel = qobject_cast<HbLabel*>(layoutLoader.findWidget(QString(DATE_ICON_LABEL)));

    mNumberLabel = qobject_cast<HbLabel*>(layoutLoader.findWidget(QString(DATE_ICON_DAYNUMBER)));

    mMonthLabel = qobject_cast<HbLabel*>(layoutLoader.findWidget(QString(DATE_ICON_MONTHLABEL)));

    mHighlightLabel = qobject_cast<HbLabel*>(layoutLoader.findWidget(QString(DATE_ICON_HIGHLIGHTLABEL)));

    // Create background drawer only if day container loading succeeded

    if (mIconLabel) {

        mDateIconFrameDrawer = new HbFrameDrawer(DATE_BACKGROUND, DATE_ICON_BACKGROUND_FRAME_TYPE);

        HbFrameItem* dateIconFrameItem = new HbFrameItem(mDateIconFrameDrawer);

        mIconLabel->setBackgroundItem(dateIconFrameItem);

    }

    setCalendarIconContent();

    setLabelsColor();

    // The icon label should never show text

    if (mIconLabel) {

        mIconLabel->clear();

    }

    if (mHighlightLabel) {

        mHighlightLabel->clear();

    }

    mDateObserver = new DateTimeObserver();

    connect(mDateObserver, SIGNAL(completed()), this, SIGNAL(dateChanged()));

    connect(this, SIGNAL(dateChanged()), this, SLOT(updateLayout()));

    //END

    // Get widget handles

    mContainer = qobject_cast<HbWidget*>(

        layoutLoader.findWidget(QString(CONTENT_CONTAINER)));

    mUpperLabelShort = qobject_cast<HbLabel*>(

        layoutLoader.findWidget(QString(UPPER_LABEL_SHORT)));

    mUpperLabelLong = qobject_cast<HbLabel*>(

        layoutLoader.findWidget(QString(UPPER_LABEL_LONG)));

    mMiddleLabel = qobject_cast<HbLabel*>(

        layoutLoader.findWidget(QString(MIDDLE_LABEL)));

    mLowerLabel = qobject_cast<HbLabel*>(

        layoutLoader.findWidget(QString(LOWER_LABEL)));

    mReminderLabel = qobject_cast<HbLabel*>(

        layoutLoader.findWidget(QString(REMINDER_ICON_LABEL)));

    // Create reminder icon drawer only if reminder label loading succeeded.

    if (mReminderLabel) {

        // Make sure there's no text in reminder icon label

        mReminderLabel->clear();

        // Create drawer for reminder icon

        mReminderDrawer = new HbFrameDrawer(REMINDER_IMAGE_NAME,

            REMINDER_FRAME_TYPE);

        //ownership transferred

        HbFrameItem* reminderFrameItem = new HbFrameItem(mReminderDrawer);

        //ownership transferred

        mReminderLabel->setBackgroundItem(reminderFrameItem);

    }

    setLabelsColor();

    hideLabels();

    createAgendaUtilsInstance();

    initializeTimer();

}

/*

 * ContentLayoutHandler::calendarChanged()

 */

void ContentLayoutHandler::calendarChanged(const XQSettingsKey& key,

    const QVariant& value)

{

    LOGS("ContentLayoutHandler::calendarChanged");

    Q_UNUSED(key);

    Q_UNUSED(value);

    updateLayout();

}

/*

 * ContentLayoutHandler::updateLayout()

 */

void ContentLayoutHandler::updateLayout()

{

    LOGS("ContentLayoutHandler::updateLayout");

    decorateContent();

    setTimerForNextUpdate();

    //From DateIconLayoutHandler

    setCalendarIconContent();

}

/*

 * ContentLayoutHandler::onThemeChange()

 */

void ContentLayoutHandler::onThemeChange()

{

    LOGS("ContentLayoutHandler::onThemeChange");

    if (mReminderDrawer) {

        mReminderDrawer->themeChanged();

    }

    if (mDateIconFrameDrawer) {

        mDateIconFrameDrawer->themeChanged();

    }

    if (mBackgroundLayoutItem) {

        mBackgroundLayoutItem->frameDrawer().themeChanged();

    }

    if (mSeparatorLayoutItem) {

        mSeparatorLayoutItem->frameDrawer().themeChanged();

    }

    setLabelsColor();

}

/*

 * ContentLayoutHandler::createAgendaUtilsInstance()

 */

void ContentLayoutHandler::createAgendaUtilsInstance()

{

    LOGS("ContentLayoutHandler::createAgendaUtilsInstance");

    mAgendaUtil = new AgendaUtil(this);

    connect(mAgendaUtil, SIGNAL(entryViewCreationCompleted(int)),

        this, SLOT(updateLayout()));

}

/*

 * ContentLayoutHandler::initializeTimer()

 */

void ContentLayoutHandler::initializeTimer()

{

    LOGS("ContentLayoutHandler::initializeTimer");

    mEventTimer = new QTimer();

    mEventTimer->setSingleShot(true);

    connect(mEventTimer, SIGNAL(timeout()), this, SLOT(eventTimerExpired()));

    setTimerForNextUpdate();

}

/*

 * ContentLayoutHandler::hideLabels()

 */

void ContentLayoutHandler::hideLabels()

{

    LOGS("ContentLayoutHandler::hideLabels");

    setLabelVisible(mMiddleLabel, false);

    setLabelVisible(mUpperLabelShort, false);

    setLabelVisible(mUpperLabelLong, false);

    setLabelVisible(mLowerLabel, false);

    setLabelVisible(mReminderLabel, false);

}

/*

 * ContentLayoutHandler::setLabelsColor()

 */

void ContentLayoutHandler::setLabelsColor()

{

    LOGS("ContentLayoutHandler::setLabelsColor");

    // --- Content layout ---

    // Choose text colors according to highlight state

    QString upperLabelColorAttribute;

    QString lowerLabelColorAttribute;

    if (mContentHighlightActive) {

        upperLabelColorAttribute = HIGHLIGHT_LABEL_COLOR;

        lowerLabelColorAttribute = HIGHLIGHT_LABEL_COLOR;

    }

    else {

        upperLabelColorAttribute = UPPER_LABEL_COLOR;

        lowerLabelColorAttribute = LOWER_LABEL_COLOR;

    }

    QColor upperLabelTextColor(HbColorScheme::color(upperLabelColorAttribute));

    QColor lowerLabelTextColor(HbColorScheme::color(lowerLabelColorAttribute));

    // Set upper and middle label text color

    if (upperLabelTextColor.isValid()) {

        if (mUpperLabelShort) {

            mUpperLabelShort->setTextColor(upperLabelTextColor);

        }

        if (mUpperLabelLong) {

            mUpperLabelLong->setTextColor(upperLabelTextColor);

        }

        if (mMiddleLabel) {

            mMiddleLabel->setTextColor(upperLabelTextColor);

        }

    }

    // Set lower label text color

    if (lowerLabelTextColor.isValid()) {

        if (mLowerLabel) {

            mLowerLabel->setTextColor(lowerLabelTextColor);

        }

    }

    // --- DateIconLayoutHandler ---

    QString numberLabelColorAttribute;

    QString monthLabelColorAttribute;

    if (mDateHighlightActive) {

        numberLabelColorAttribute = NUMBER_LABEL_COLOR;

        monthLabelColorAttribute = HIGHLIGHT_LABEL_COLOR;

    }

    else {

        numberLabelColorAttribute = NUMBER_LABEL_COLOR;

        monthLabelColorAttribute = MONTH_LABEL_COLOR;

    }

    QColor numberLabelTextColor(HbColorScheme::color(numberLabelColorAttribute));

    QColor monthLabelTextColor(HbColorScheme::color(monthLabelColorAttribute));

    // Set day number label text color

    if (numberLabelTextColor.isValid()) {

        if (mNumberLabel) {

            mNumberLabel->setTextColor(numberLabelTextColor);

        }

    }

    // Set month label text color

    if (monthLabelTextColor.isValid()) {

        if (mMonthLabel) {

            mMonthLabel->setTextColor(monthLabelTextColor);

        }

    }

}

/*

 * ContentLayoutHandler::eventTimerExpired

 */

void ContentLayoutHandler::eventTimerExpired()

{

    LOGS("ContentLayoutHandler::eventTimerExpired");

    decorateContent();

    setTimerForNextUpdate();

}

/*

 * ContentLayoutHandler::timeToNextCheck()

 */

int ContentLayoutHandler::timeToNextCheck()

{

    LOGS("ContentLayoutHandler::timeToNextCheck");

    QDateTime now = currentDateTime();

    int secondsToNextCheck = 0;

    int currentSeconds = 0;

    currentSeconds = now.toTime_t();

    int entryStartTimeSeconds = 0;

    int entryEndTimeSeconds = 0;

    int indexEntryToCheck = firstEntryIndex();

    QDateTime startTime = mAgendaEntryList.at(indexEntryToCheck).startTime();

    QDateTime endTime = mAgendaEntryList.at(indexEntryToCheck).endTime();

    entryStartTimeSeconds = startTime.toTime_t();

    entryEndTimeSeconds = endTime.toTime_t();

    //check if the event is bigger than half hour

    if ((entryEndTimeSeconds - entryStartTimeSeconds) < (KHalfHour * KSecondsInMinute)) {

        secondsToNextCheck = entryEndTimeSeconds - currentSeconds;

    }

    else {

        //check that it's not an all time event.

        //if it's an all day event there's no need to set the timer because there is already a date check and the widget content

        //will be updated anyway.

        if (!isAllDayEvent(mAgendaEntryList.at(indexEntryToCheck))) {

            secondsToNextCheck = entryStartTimeSeconds + KHalfHour * KSecondsInMinute

                - currentSeconds;

        }

    }

    int mSecsToNextCheck = 0;

    if (secondsToNextCheck > INT_MAX / KSecondInMillisec) {

        mSecsToNextCheck = INT_MAX;

    }

    else {

        //seconds to milliseconds

        mSecsToNextCheck = secondsToNextCheck * KSecondInMillisec;

    }

    return mSecsToNextCheck;

}

/*

 * ContentLayoutHandler::firstEntryIndex()

 */

int ContentLayoutHandler::firstEntryIndex()

{

    int indexEntryToCheck = 0;

    LOGS("ContentLayoutHandler::firstEntryIndex()");

    //let's find the first non all day event in the list

    while (isAllDayEvent(mAgendaEntryList.at(indexEntryToCheck))

        && (indexEntryToCheck < mAgendaEntryList.count() - 1)) {

        indexEntryToCheck++;

    }

    //if we found the first valid non all day event as last in the array then we have to keep that index

    if ((indexEntryToCheck == mAgendaEntryList.count() - 1)

        && isAllDayEvent(mAgendaEntryList.at(indexEntryToCheck))) {

        indexEntryToCheck = 0;

    }

    return indexEntryToCheck;

}

/*

 * ContentLayoutHandler::decorateContent()

 */

void ContentLayoutHandler::decorateContent()

{

    LOGS("ContentLayoutHandler::decorateContent");

    updateList();

    if (mAgendaEntryList.count()) {

        removeTodosFrom();

        //it removes the events that are shorter than 30 minutes and are already passed

        removePassedEvents();

    }

    //there might be only ToDos. Let's check again.

    if (mAgendaEntryList.count()) {

        int endEventIndex = 0;

        if (todayHasValidEvents()) {

            int numOverlappingEvents = checkOverlappingEvents(0, endEventIndex);

            if (!numOverlappingEvents) {

                showNextEvent();

            }

            else {

                showOverlappingEvents(KToday, numOverlappingEvents, endEventIndex);

            }

        }

        else {

            int numOverlappingEvents = checkOverlappingEvents(0, endEventIndex);

            if (!numOverlappingEvents) {

                showNextDaysEvent();

            }

            else {

                showOverlappingEvents(KComingDays, numOverlappingEvents, endEventIndex);

            }

        }

    }

    else {

        showNoEventsNextWeek();

    }

    QDateTime date;

    if (mAgendaEntryList.count()) {

        date = mAgendaEntryList.at(0).startTime();

    }

    else {

        date = QDateTime::currentDateTime();

    }

    emit currentDate(date);